GVKun编程网logo

python如何序列化json数据（python json 序列化）

8

关于python如何序列化json数据和pythonjson序列化的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于.Net使用Newtonsoft.Json.dll(JSON.NET)对象

关于python如何序列化json数据和python json 序列化的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于.Net使用Newtonsoft.Json.dll(JSON.NET)对象序列化成json、反序列化json示例教程、c# – 无法反序列化JSON数组到类型 – Json.NET、c# 使用 Newtonsoft.Json 序列化json字符串以及,反序列化对象、fastjson生成和解析json数据，序列化和反序列化数据等相关知识的信息别忘了在本站进行查找喔。

本文目录一览：

python如何序列化json数据（python json 序列化）

python如何序列化json数据（python json 序列化）

 使用json模块提供的loads方法和dumps方法，可以很方便的载入和读取json数据格式。而在具体实际应用中，我们使用python数据格式是 string、list 或dict等，这类格式如何直接转换为json格式呢？

可以借用python内部的__dict__ 字典方法将格式转换为json格式并读取，不带参数示例如下：

一、不带参数的class类转化为json

class Foo(object):
def __init__(self):
self.x = 1
self.y = 2
foo = Foo()
# s = json.dumps(foo) # raises TypeError with "is not JSON serializable"
s = json.dumps(foo.__dict__) # s set to: {"x":1, "y":2}

调用上面的方法时，print s时，其值为：{"x":1, "y":2} 。

二、带参数的class方法转化为json

如果要传入的是一个多行字符串参数，其也可以自动进行转义：

#!/usr/bin/env python
# coding=utf8
# Copyright (C) 2018 www.361way.com site All rights reserved.
import json
class Foo(object):
def __init__(self,cmd):
self.Command = cmd
cmd="""
#!/bin/bash
echo "Result:4 "
ps -ef|grep java|wc -l
netstat -an|grep 15380
echo ";"
"""
foo = Foo(cmd)
s = json.dumps(foo.__dict__)
print s

其执行输出如下：

[root@localhost tmp]# python a.py
{"Command": "\n#!/bin/bash\n\necho \"Result:4 \"\nps -ef|grep java|wc -l\nnetstat -an|grep 15380\necho \";\"\n\n"}

后面的结构体转义部分，实际上就是json.JSONEncoder().encode方法处理的结果：

print json.JSONEncoder().encode(cmd)

可以用上面的命令进行测试，将上面的代码加入到上面python文件的最后，执行的结果如下：

[root@localhost tmp]# python a.py
{"Command": "\n#!/bin/bash\n\necho \"Result:4 \"\nps -ef|grep java|wc -l\nnetstat -an|grep 15380\necho \";\"\n\n"}
"\n#!/bin/bash\n\necho \"Result:4 \"\nps -ef|grep java|wc -l\nnetstat -an|grep 15380\necho \";\"\n\n"

.Net使用Newtonsoft.Json.dll(JSON.NET)对象序列化成json、反序列化json示例教程

.Net使用Newtonsoft.Json.dll(JSON.NET)对象序列化成json、反序列化json示例教程

JSON作为一种轻量级的数据交换格式，简单灵活，被很多系统用来数据交互，作为一名.NET开发人员，JSON.NET无疑是最好的序列化框架，支持XML和JSON序列化，高性能，免费开源，支持LINQ查询。目前已被微软集成于webapi框架之中，因此，熟练掌握JSON.NET相当重要，这篇文章是零度参考官网整理的示例，通过这些示例，可以全面了解JSON.NET提供的功能。

Newtonsoft.Json的地址：

官网：http://json.codeplex.com/

源码地址：https://github.com/JamesNK/Newtonsoft.Json

Newtonsoft.Json.dll下载：https://github.com/JamesNK/Newtonsoft.Json/releases

1、使用Newtonsoft.Json(JSON.NET)序列化对象,通过Newtonsoft.Json.Formatting将json格式化输出。

            Account account = new Account
            {
                Email = "1930906722@qq.com",Active = true,CreatedDate =DateTime.Now,Roles = new List<string> { "User","Admin" }
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(account,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);
    public class Account
    {
        public string Name { get; set; }
        public string Email { get; set; }
        public bool Active { get; set; }
        public DateTime CreatedDate { get; set; }
        public IList<string> Roles { get; set; }
    }

执行结果：

2、使用Newtonsoft.Json(JSON.NET)序列化List集合：

            List<string> videogames = new List<string> { "HTML5","JavaScript",".net","c#",".net core" };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(videogames);
            Console.WriteLine(json);

执行结果：

3、使用Newtonsoft.Json(JSON.NET)序列化dictionary字典

            System.Collections.Generic.Dictionary<string,string> dic = new System.Collections.Generic.Dictionary<string,string>
            {
                { "Name","张三" },{ "Age","20" },{ "Email","193090622@qq.com" }
            };
            string json1 = Newtonsoft.Json.JsonConvert.SerializeObject(dic,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json1);
            Console.WriteLine("");
            Console.WriteLine("未格式化的json：");
            string json2 = Newtonsoft.Json.JsonConvert.SerializeObject(dic,Newtonsoft.Json.Formatting.None);
            Console.WriteLine(json2);

执行结果：

4、Newtonsoft.Json(JSON.NET)将序列化结果保存到指定的文件：

            User movie = new User { Name = "张三",Age = 1993 };
            using (System.IO.StreamWriter file = System.IO.File.CreateText(@"F:\UserInfo.txt"))
            {
                Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
                serializer.Serialize(file,movie);
            }
    public class User
    {
        public string Name { set; get; }
        public int Age { set; get; }
    }

执行后保存到文件的结果：

5、Newtonsoft.Json(JSON.NET)基于枚举类型的JsonConverters转换器

            List<JosnEnum> list = new List<JosnEnum> { JosnEnum.NotStartus,JosnEnum.Startus };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(list);
            Console.WriteLine(json);
            Console.WriteLine("");

            System.Collections.Generic.Dictionary<string,int> dic = new System.Collections.Generic.Dictionary<string,int>
            { 
            {((JosnEnum)(int)JosnEnum.NotStartus).ToString(),(int)JosnEnum.NotStartus},{((JosnEnum)(int)JosnEnum.Startus).ToString(),(int)JosnEnum.Startus}
            };
            string dicJson = Newtonsoft.Json.JsonConvert.SerializeObject(dic);
            Console.WriteLine(dicJson);

            Console.WriteLine("");
            List<JosnEnum> list2 = new List<JosnEnum>
            {
                JosnEnum.NotStartus,JosnEnum.Startus
            };
            string json3 = Newtonsoft.Json.JsonConvert.SerializeObject(list2,new Newtonsoft.Json.Converters.StringEnumConverter());
            Console.WriteLine(json3);

            Console.WriteLine("");

            List<JosnEnum> result = Newtonsoft.Json.JsonConvert.DeserializeObject<List<JosnEnum>>(json3,new Newtonsoft.Json.Converters.StringEnumConverter());
            Console.WriteLine(string.Join(",",result.Select(c => c.ToString())));
    public enum JosnEnum
    {
        NotStartus = 0,Startus = 1
    }

执行结果：

6、Newtonsoft.Json(JSON.NET)通过JRaw将JS函数序列化到JSON中

            JavaScriptSettings settings = new JavaScriptSettings
            {
                OnLoadFunction = new Newtonsoft.Json.Linq.JRaw("OnLoad"),OnSucceedFunction = new Newtonsoft.Json.Linq.JRaw("function(e) { alert(e); }")
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(settings,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);
    public class JavaScriptSettings
    {
        public Newtonsoft.Json.Linq.JRaw OnLoadFunction { get; set; }
        public Newtonsoft.Json.Linq.JRaw OnSucceedFunction { get; set; }
    }

7、使用Newtonsoft.Json(JSON.NET)将json反序列化对象

  string json = @"{
   'Email': '1930906722@qq.com','Active': true,'CreatedDate': '2016-11-26 20:39','Roles': [
     'User','Admin'
]
 }";
            Account account = Newtonsoft.Json.JsonConvert.DeserializeObject<Account>(json);
            Console.WriteLine(account.Email);
    public class Account
    {
        public string Name { get; set; }
        public string Email { get; set; }
        public bool Active { get; set; }
        public DateTime CreatedDate { get; set; }
        public IList<string> Roles { get; set; }
    }

执行结果：

8、使用Newtonsoft.Json(JSON.NET)反序列化List集合：

            string json = @"['Html5','C#','.Net','.Net Core']";
            List<string> videogames = Newtonsoft.Json.JsonConvert.DeserializeObject<List<string>>(json);
            Console.WriteLine(string.Join(",videogames));

执行结果：

9、使用Newtonsoft.Json(JSON.NET)反序列化dictionary字典

            string json = @"{'Name': '张三','Age': '23'}";
            var htmlAttributes = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string,string>>(json);
            Console.WriteLine(htmlAttributes["Name"]);
            Console.WriteLine(htmlAttributes["Age"]);

执行结果：

10、使用Newtonsoft.Json(JSON.NET)序列化var匿名类型，有时候，我们并不需要先定义一个类，然后new一个对象后再进行序列化，JSON.NET支持匿名类型的序列化和反序列化。

            var test1 = new { Name = "李四",Age = 26 };
            var json = Newtonsoft.Json.JsonConvert.SerializeObject(test1);
            Console.WriteLine(json);

            Console.WriteLine("");
            var test2 = new { Name = "",Age = 0 };
            string json1 = @"{'Name':'张三','Age':'25'}";
            var result = Newtonsoft.Json.JsonConvert.DeserializeAnonymousType(json1,test2);
            Console.WriteLine(result.Name);

执行结果：

11、Newtonsoft.Json(JSON.NET)用新JSON字符串填充指定对象的属性值

            Account account = new Account
            {
                Email = "1930906722@qq.com",CreatedDate = DateTime.Now,"Admin" }
            };
            string json = @"{'Active': false,'Roles': ['Expired']}";
            Newtonsoft.Json.JsonConvert.PopulateObject(json,account);
            Console.WriteLine(account.Active);
            Console.WriteLine(account.Email);
    public class Account
    {
        public string Name { get; set; }
        public string Email { get; set; }
        public bool Active { get; set; }
        public DateTime CreatedDate { get; set; }
        public IList<string> Roles { get; set; }
    }

执行结果：

12、使用Newtonsoft.Json(JSON.NET)反序列化时可指定构造函数：

首先我们定义如下的类型，我们希望JSON.NET反序列化对象时使用第2个构造函数，我们将第一个默认构造函数屏蔽，标记为私有private修饰符。第2个构造函数需要指定一个website对象作为参数，如果提供的参数为null则抛出异常：

public class Website
{
    public string Url { get; set; }
    private Website()
    {
    }
    public Website(Website website)
    {
        if (website == null) throw new ArgumentNullException("website");
        Url = website.Url;
    }
}

现在使用一般的方式反序列化一个JSON字符串。执行出现的结果：

我们发现该序列化方法抛出了异常，并没有按照我们预想的方式进行反序列化，JSON.NET提供如下的方式指定公有构造函数。

            string json = @"{'Url':'http://www.cnblogs.com/linJie1930906722/'}";
            Website website = Newtonsoft.Json.JsonConvert.DeserializeObject<Website>(json,new Newtonsoft.Json.JsonSerializerSettings
            {
                ConstructorHandling = Newtonsoft.Json.ConstructorHandling.AllowNonPublicDefaultConstructor
            });
            Console.WriteLine(website.Url);

执行结果：

另外，JSON.NET提供了指定任何构造函数的JsonConstructorAttribute特性，只需要在构造函数上标记，即可指定构造函数。

    public class Users
    {
        public string UserName { get; private set; }
        public bool Enabled { get; private set; }
        public Users()
        {
        }
        [Newtonsoft.Json.JsonConstructor]
        public Users(string userName,bool enabled)
        {
            UserName = userName;
            Enabled = enabled;
        }
    }
            string json = @"{""UserName"": ""希特勒"",""Enabled"": true}";
            Users user = Newtonsoft.Json.JsonConvert.DeserializeObject<Users>(json);
            Console.WriteLine(user.UserName);

执行结果：

13、当对象的属性为默认值(0或null)时不序列化该属性

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public Person Partner { get; set; }
        public decimal? Salary { get; set; }
    }
            Person person1 = new Person();
            string json1 = Newtonsoft.Json.JsonConvert.SerializeObject(person1,Newtonsoft.Json.Formatting.Indented,new Newtonsoft.Json.JsonSerializerSettings
            {
                DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore
            });
            Console.WriteLine(json1);

            Console.WriteLine("");
            Person person2 = new Person(){Name = "奥巴马"};
            string json2 = Newtonsoft.Json.JsonConvert.SerializeObject(person2,new Newtonsoft.Json.JsonSerializerSettings
            {
                DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore
            });
            Console.WriteLine(json2);

执行结果：

14、Newtonsoft.Json（JSON.NET）中忽略null值得处理器

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public Person Partner { get; set; }
        public decimal? Salary { get; set; }
    }
            Person person = new Person { Name = "张三",Age = 46 };
            string jsonIncludeNullValues = Newtonsoft.Json.JsonConvert.SerializeObject(person,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(jsonIncludeNullValues);
            Console.WriteLine("");
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(person,new Newtonsoft.Json.JsonSerializerSettings
            {
                NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore
            });
            Console.WriteLine(json);

执行结果：

15、JSON.NET中循环引用的处理方法

            Employee employee1 = new Employee { Name = "张三" };
            Employee employee2 = new Employee { Name = "李四" };
            employee1.Manager = employee2;
            employee2.Manager = employee2;
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(employee1,new Newtonsoft.Json.JsonSerializerSettings
            {
                ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
            });
            Console.WriteLine(json);
    public class Employee
    {
        public string Name { get; set; }
        public Employee Manager { get; set; }
    }

执行结果：

16、通过ContractResolver指定属性名首字母小写，通常，在.NET中属性采用PascalCase规则（首字母大写），在JavaScript中属性名使用CamelCase规则（首字母小写），我们希望序列化后的JSON字符串符合CamelCase规则，JSON.NET提供的ContractResolver可以设置属性名小写序列化

    public class User
    {
        public string Name { set; get; }
        public int Age { set; get; }
    }
            User person = new User { Name = "张三",Age =52 };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(person,new Newtonsoft.Json.JsonSerializerSettings
            {
                ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver()
            });
            Console.WriteLine(json);

执行结果：

17、JSON.NET中通过特性序列化枚举类型

    public enum ProductStatus
    { 
        NotConfirmed,Active,Deleted
    }

    public class Product
    {
        public string Name { get; set; }

        [Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]
        public ProductStatus Status { get; set; }
    }
            Product user = new Product { Name = @"羽绒服",Status = ProductStatus.Deleted };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(user,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

执行结果：

18、指定需要序列化的属性

    [Newtonsoft.Json.JsonObject(Newtonsoft.Json.MemberSerialization.OptIn)]
    public class Categroy
    {
        //Id不需要序列化
        public Guid Id { get; set; }

        [Newtonsoft.Json.JsonProperty]
        public string Name { get; set; }

        [Newtonsoft.Json.JsonProperty]
        public int Size { get; set; }
    }
            Categroy categroy = new Categroy
            {
                Id = Guid.NewGuid(),Name = "内衣",Size = 52
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(categroy,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

执行结果：

19、序列化对象时指定属性名

    public class Videogame
    {
        [Newtonsoft.Json.JsonProperty("name")]
        public string Name { get; set; }

        [Newtonsoft.Json.JsonProperty("release_date")]
        public DateTime ReleaseDate { get; set; }
    }
            Videogame starcraft = new Videogame
            {
                Name = "英雄联盟",ReleaseDate = DateTime.Now
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(starcraft,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

执行结果：

20、序列化时指定属性在JSON中的顺序

    public class Personl
    {
        [Newtonsoft.Json.JsonProperty(Order = 2)]
        public string FirstName { get; set; }

        [Newtonsoft.Json.JsonProperty(Order = 1)]
        public string LastName { get; set; }
    }
            Personl person = new Personl { FirstName = "张三",LastName = "李四" };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(person,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

执行结果：

21、反序列化指定属性是否必须有值必须不为null，在反序列化一个JSON时，可通过JsonProperty特性的required指定反序列化行为，当反序列化行为与指定的行为不匹配时，JSON.NET将抛出异常，required是枚举，required.Always表示属性必须有值切不能为null，required.AllowNull表示属性必须有值，但允许为null值。

    public class Order
    {
        [Newtonsoft.Json.JsonProperty(required = Newtonsoft.Json.required.Always)]
        public string Name { get; set; }

        [Newtonsoft.Json.JsonProperty(required = Newtonsoft.Json.required.AllowNull)]
        public DateTime? ReleaseDate { get; set; }
    }
            string json = @"{
    'Name': '促销订单','ReleaseDate': null
  }";
            Order order = Newtonsoft.Json.JsonConvert.DeserializeObject<Order>(json);
            Console.WriteLine(order.Name);
            Console.WriteLine(order.ReleaseDate);

执行结果：

22、通过特性指定null值忽略序列化

    public class Vessel
    {
        public string Name { get; set; }

        [Newtonsoft.Json.JsonProperty(NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
        public DateTime? launchdate { get; set; }
    }
            Vessel vessel = new Vessel { Name = "张三" };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(vessel,Newtonsoft.Json.Formatting.Indented);
            Console.WriteLine(json);

执行结果：

23、忽略不需要序列化的属性，并不是对象所有属性都要参与序列化，我们可以使用JsonIgnore特性排除不需要序列化的属性，下面示例中的PasswordHash将被忽略。

    public class Accounts
    {
        public string FullName { get; set; }
        public string EmailAddress { get; set; }
        [Newtonsoft.Json.JsonIgnore]
        public string PasswordHash { get; set; }
    }
            Accounts account = new Accounts
            {
                FullName = "admin",EmailAddress = "1930906722@qq.com",PasswordHash = "dfsfgerhtyhsasdhjyujtgwe454811sfsg8d"
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(account);
            Console.WriteLine(json);

执行结果：

24、序列化或反序列化时指定日期时间格式，JSON.NET中提供一个名为JsonSerializerSettings的设置对象，可通过此对象设置很多序列化和反序列化的行为，如果要设置JSON.NET序列化输出的日期时间格式，只需要指定格式化字符串即可。通过JsonSerializerSettings的DateFormatString属性指定日期时间格式：

    public class Customer
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public DateTime CreateDate { get; set; }
    }
            Customer custom = new Customer { FirstName = "张三",LastName = "李四",CreateDate = DateTime.Now };
            Newtonsoft.Json.JsonSerializerSettings settings = new Newtonsoft.Json.JsonSerializerSettings
            {
                DateFormatString = "yyyy-MM-dd HH:mm:ss",Formatting = Newtonsoft.Json.Formatting.Indented
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(custom,settings);
            Console.WriteLine(json);

执行结果：

c# – 无法反序列化JSON数组到类型 – Json.NET

c# – 无法反序列化JSON数组到类型 – Json.NET

我试图将一个json数据反序列化为一个模型类,但是我失败了.这是我做的： 
public CountryModel GetCountries() {

        using (WebClient client = new WebClient()) {

            var result = client.DownloadString("http://api.worldbank.org/incomeLevels/LIC/countries?format=json");

            var output = JsonConvert.DeserializeObject<List<CountryModel>>(result);

            return output.First();
        }
    }

这是我的模型如何：

public class CountryModel
{
    public int Page { get; set; }
    public int Pages { get; set; }
    public int Per_Page { get; set; }
    public int Total { get; set; }

    public List<Country> Countries { get; set; }
}

public class Country
{
    public int Id { get; set; }
    public string Iso2Code { get; set; }
    public string Name { get; set; }
    public Region Region { get; set; }
}

public class Region
{
    public int Id { get; set; }
    public string Value { get; set; }
}

你可以看到Json我到了这里：http://api.worldbank.org/incomeLevels/LIC/countries?format=json

这是我得到的错误：

Cannot deserialize JSON array into type ‘Mvc4AsyncSample.Models.CountryModel’. Line 1,position 1.

解决方法

你必须编写一个自定义JsonConverter： 
public class CountryModelConverter : JsonConverter
    {

        public override bool CanConvert(Type objectType)
        {
            if (objectType == typeof(CountryModel))
            {
                return true;
            }

            return false;
        }

        public override object ReadJson(JsonReader reader,Type objectType,object existingValue,JsonSerializer serializer)
        {
            reader.Read(); //start array
            //reader.Read(); //start object
            JObject obj = (JObject)serializer.Deserialize(reader);

            //{"page":1,"pages":1,"per_page":"50","total":35}
            var model = new CountryModel();

            model.Page = Convert.ToInt32(((JValue)obj["page"]).Value);
            model.Pages = Convert.ToInt32(((JValue)obj["pages"]).Value);
            model.Per_Page = Int32.Parse((string) ((JValue)obj["per_page"]).Value);
            model.Total = Convert.ToInt32(((JValue)obj["total"]).Value);

            reader.Read(); //end object

            model.Countries = serializer.Deserialize<List<Country>>(reader);

            reader.Read(); //end array

            return model;
        }

        public override void WriteJson(JsonWriter writer,object value,JsonSerializer serializer)
        {
            throw new NotImplementedException();
        }
    }

并用该转换器标记CountryModel(我也必须将一些int转换为字符串)：

[JsonConverter(typeof(CountryModelConverter))]
    public class CountryModel
    {
        public int Page { get; set; }
        public int Pages { get; set; }
        public int Per_Page { get; set; }
        public int Total { get; set; }

        public List<Country> Countries { get; set; }
    }

    public class Country
    {
        public string Id { get; set; }
        public string Iso2Code { get; set; }
        public string Name { get; set; }
        public Region Region { get; set; }
    }

    public class Region
    {
        public string Id { get; set; }
        public string Value { get; set; }
    }

那么你应该能够像这样反序列化：

var output = JsonConvert.DeserializeObject<CountryModel>(result);

c# 使用 Newtonsoft.Json 序列化json字符串以及,反序列化对象

c# 使用 Newtonsoft.Json 序列化json字符串以及,反序列化对象

1. 序列化 对象

 

/** 使用 Newtonsoft.Json 序列化对象 **/

 [WebMethod]
 public String getPersonInfos() {
     // 初始化数据
     List < Pserson > mlist = new List < Pserson > ();
     for (int i = 0; i < 5; i++)
     {
         Pserson mpersopn = new Pserson();
         mpersopn.name = "张三";
         mpersopn.sex = i % 2 == 0 ? "男" : "女";
         mpersopn.age = 20 + i;
         mlist.Add(mpersopn);
     }
     CallbackObject mcallback = new CallbackObject();
     mcallback.falg = "200";
     mcallback.message = "请求成功";
     mcallback.result = mlist;
     String str = JsonConvert.SerializeObject(mcallback);
     return str;
 }

　　

 

2. 反序列化 json字符串

  /** 使用 Newtonsoft.Json 反序列化json字符串 **

 [WebMethod]
 public List < Pserson > getPersonInfo()
 {
     string jsonText = "[{''name'':''张三'',''sex'':''男'',''age'':30},{''name'':''李四'',''sex'':''女'',''age'':25}]";
     List < Pserson > personlist = JsonConvert.DeserializeObject < List < Pserson >> (jsonText);
     foreach(Pserson p in personlist) {
         System.Diagnostics.Debug.WriteLine("\n\n");
         String str = "name = " + p.name + "\t sex = " + p.sex + "\t age = " + p.age + "\n";
         System.Diagnostics.Debug.WriteLine(str);
     }
     return personlist;
 }

　　

 

 

var result = JsonConvert.DeserializeAnonymousType(client.Execute(request).Content, new { access_token = string.Empty, expires_in = string.Empty });
var o2 = JsonConvert.DeserializeObject(json) as JObject;

 

fastjson生成和解析json数据，序列化和反序列化数据

fastjson生成和解析json数据，序列化和反序列化数据

本文讲解2点：

1. fastjson生成和解析json数据

(举例：4种常用类型:JavaBean,List<JavaBean>,List<String>,List<Map<String,Object>)

2.通过一个android程序测试fastjson的用法。

fastjson简介：

Fastjson是一个Java语言编写的高性能功能完善的JSON库。fastjson采用独创的算法，将parse的速度提升到极致，超过所有json库，包括曾经号称最快的jackson。并且还超越了google的二进制协议protocol buf。Fastjson完全支持http://json.org的标准，也是官方网站收录的参考实现之一。支持各种JDK类型。包括基本类型、JavaBean、Collection、Map、Enum、泛型等。支持JDK 5、JDK 6、Android、阿里云手机等环境。

一. fastjson生成json字符串(JavaBean,Object>)

String jsonStrng = JSON.toJSONString(object);

二. fastjson 解析json字符串为四种类型

1. JavaBean

Person person = JSON.parSEObject(jsonString,Person.class);

2. List<JavaBean>

List<Person> listPerson =JSON.parseArray(jsonString,Person.class);

3. List<String>

List<String> listString = JSON.parseArray(jsonString,String.class);

4. List<Map<String,Object>>

List<Map<String,Object>> listMap = JSON.parSEObject(jsonString,new TypeReference<List<Map<String,Object>>>(){}); (注意：此处可看出fastjson反射机制比gson更准确， id = 1001 通过fastjson反射仍是 id = 1001,而通过gson反射结果 为 id =1001.0,

JSON解析器fastjson（阿里巴巴出品，版本1.1.26），如果定义了JSONObject为{"JACKIE_ZHANG":"张学友","ANDY_LAU":"刘德华","LIMING":"黎明","Aaron_Kwok":"郭富城"}，那么读取值时,KEY顺序无序，测试代码：

  • importcom.alibaba.fastjson.JSONObject;
  • /**
  • *Createdbywangzhenfeion14-4-15.
  • */
  • publicclassFastJsonTest{
  • publicstaticvoidmain(String[]args){
  • StringjsonStr="{\"JACKIE_ZHANG\":\"张学友\",\"ANDY_LAU\":\"刘德华\",\"LIMING\":\"黎明\",\"Aaron_Kwok\":\"郭富城\"}";
  • //做5次测试
  • for(inti=0,j=5;i<j;i++)
  • {
  • JSONObjectjsonObject=JSONObject.parSEObject(jsonStr);
  • for(java.util.Map.Entry<String,Object>entry:jsonObject.entrySet()){
  • System.out.print(entry.getKey()+"-"+entry.getValue()+"\t");
  • }
  • System.out.println();//用来换行
  • }
  • }


    • 运行结果：

      LIMING-黎明Aaron_Kwok-郭富城JACKIE_ZHANG-张学友ANDY_LAU-刘德华
    1. Aaron_Kwok-郭富城ANDY_LAU-刘德华LIMING-黎明JACKIE_ZHANG-张学友
    2. Aaron_Kwok-郭富城JACKIE_ZHANG-张学友ANDY_LAU-刘德华LIMING-黎明
    3. LIMING-黎明ANDY_LAU-刘德华JACKIE_ZHANG-张学友Aaron_Kwok-郭富城
    4. JACKIE_ZHANG-张学友LIMING-黎明ANDY_LAU-刘德华Aaron_Kwok-郭富城

    解决办法：定义为JSONArray，代码如下：

    importcom.alibaba.fastjson.JSONArray;
  • /**
  • *Createdbywangzhenfeion14-4-15.
  • */
  • publicclassFastJsonTest{
  • publicstaticvoidmain(String[]args){
  • StringjsonStr="[{\"JACKIE_ZHANG\":\"张学友\"},{\"ANDY_LAU\":\"刘德华\"},{\"LIMING\":\"黎明\"},{\"Aaron_Kwok\":\"郭富城\"}]";
  • //做5次测试
    • 5;i<j;i++)
  • {
  • JSONArrayjsonArray=JSONArray.parseArray(jsonStr);
  • for(intk=0;k<jsonArray.size();k++){
  • System.out.print(jsonArray.get(k)+"\t");
  • }


    • 运行结果为：

    {"JACKIE_ZHANG":"张学友"}{"ANDY_LAU":"刘德华"}{"LIMING":"黎明"}{"Aaron_Kwok":"郭富城"}
  • {"JACKIE_ZHANG":"张学友"}{"ANDY_LAU":"刘德华"}{"LIMING":"黎明"}{"Aaron_Kwok":"郭富城"}
  • {"JACKIE_ZHANG":"张学友"}{"ANDY_LAU":"刘德华"}{"LIMING":"黎明"}{"Aaron_Kwok":"郭富城"}

    • 如果就想要定义为JSONObject，而不是JSONArray，可以选用其他JSON解析器，个人推荐使用google的gson，文档明显比fastjson好很多（从这里可以看出阿里巴巴和谷歌的差距）：

    importcom.google.gson.JsonElement;
  • importcom.google.gson.JsonObject;
  • importcom.google.gson.JsonParser;
  • StringjsonStr="{\"JACKIE_ZHANG\":\"张学友\",\"Aaron_Kwok\":\"郭富城\"}";
  • JsonObjectjsonObject=(JsonObject)newJsonParser().parse(jsonStr);
    • System.out.print(entry.getKey()+"-"+entry.getValue()+"\t");
  • System.out.println();//用来换行
  • }


    • 运行结果：

    1. JACKIE_ZHANG-"张学友"ANDY_LAU-"刘德华"LIMING-"黎明"Aaron_Kwok-"郭富城"
    2. JACKIE_ZHANG-"张学友"ANDY_LAU-"刘德华"LIMING-"黎明"Aaron_Kwok-"郭富城"
    3. JACKIE_ZHANG-"张学友"ANDY_LAU-"刘德华"LIMING-"黎明"Aaron_Kwok-"郭富城"

    原文地址http://www.cnblogs.com/goody9807/p/4244862.html

    今天关于python如何序列化json数据和python json 序列化的讲解已经结束，谢谢您的阅读，如果想了解更多关于.Net使用Newtonsoft.Json.dll(JSON.NET)对象序列化成json、反序列化json示例教程、c# – 无法反序列化JSON数组到类型 – Json.NET、c# 使用 Newtonsoft.Json 序列化json字符串以及,反序列化对象、fastjson生成和解析json数据，序列化和反序列化数据的相关知识，请在本站搜索。

    本文标签：

    上一篇json格式数据（json格式数据示例）

    下一篇JSON的使用场景及注意事项介绍（json的使用场景及注意事项介绍图片）

    相关文章