JSON介绍

1.什么是JSON?

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它使得人们很容易的进行阅读和编写。同时也方便了机器进行解析和生成。 JSON采用完全独立于程序语言的文本格式。这些特性使JSON成为理想的数据交换语言。

2.JSON基于两种结构：

• “名称/值”对的集合。不同的编程语言中，它被理解为对象，纪录，结构，字典，哈希表，有键列表，或者关联数组。
• 值的有序列表。在大部分语言中，它被实现为数组，矢量，列表，序列。

3.几种表现形式：

a.对象：
{“ID”:1,“Name”:“小王”,“Age”:20}。

b.数组：
[
{“ID”:1,“Name”:“张三”,“CreateTime”:"/Date(1631783963711)/"},{“ID”:2,“Name”:“李四”,“CreateTime”:"/Date(1631783963713)/"},{“ID”:2,“Name”:“王五”,“CreateTime”:null}
]。

c.字符串:任意数量的Unicode字符，使用引号做标记，并使用反斜杠来分隔。例如：var userlist = “{\“ID\”:1,\“Name\”:\“Manas\”,\“Address\”:\“India]\”}” 。

JSON说完了，详见。

4.序列化和反序列化的3中方式：

1.使用JavaScriptSerializer类

2.使用DataContractJsonSerializer类

3.使用Newtonsoft.Json（JSON.NET）类库

1.JavaScriptSerializer类

1.介绍

命名空间:
System.Web.Script.Serialization
程序集:
System.Web.Extensions.dll

2.示例

1.添加一个控制台程序。添加程序集引用，在Program类中引入System.Web.Script.Serialization命名空间。

对于 .NET Framework 4.7.2 及更高版本，请使用命名空间中的 Api System.Text.Json 进行序列化和反序列化。 对于早期版本的 .NET Framework，请使用 Newtonsoft.Js。 此类型旨在为启用了 AJAX 的应用程序提供序列化和反序列化功能。

JavaScriptSerializer类由异步通信层在内部使用，用于序列化和反序列化浏览器与 Web 服务器之间传递的数据。

2.添加一个UserInfo类：

 public class UserInfo
    {
        /// <summary>
        /// 编号
        /// </summary>
        public int ID { get; set; }

        /// <summary>
        /// 名称
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 创建时间
        /// </summary>
        public DateTime? CreateTime { get; set; }


        public UserInfo() { }
        public UserInfo(int id, string name,DateTime? createTime=null)
        {
            this.ID = id;
            this.Name = name;
            this.CreateTime = createTime;
        }
    }

3.Program类代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Script.Serialization;

namespace SerializationDemo
{
    class Program
    {
        static void Main(string[] args)
        {

            List<UserInfo> userList = new List<UserInfo>();
            userList.Add(new UserInfo() { ID = 1, Name = "张三", CreateTime = DateTime.Now });
            userList.Add(new UserInfo() { ID = 2, Name = "李四", CreateTime = DateTime.Now });
            userList.Add(new UserInfo() { ID = 2, Name = "王五" });

            //创建一个JavaScriptSerializer对象
            JavaScriptSerializer serializer = new JavaScriptSerializer();

            //将用户列表序列化成JSON
            string serializedResult = serializer.Serialize(userList);

            Console.WriteLine(serializedResult);
            //将JOSN反序列化成用户列表
            List<UserInfo> deserializeResult = serializer.Deserialize<List<UserInfo>>(serializedResult);
            Console.WriteLine(deserializeResult[0].Name);
            Console.WriteLine(deserializeResult[0].CreateTime.Value.ToString("yyyy-MM-dd"));
            
            Console.ReadLine();

        }
    }
}

4.F5运行，结果如下：

[{“ID”:1,“Name”:“张三”,“CreateTime”:"/Date(1631788856930)/"},{“ID”:2,“Name”:“李四”,“CreateTime”:"/Date(1631788856933)/"},{“ID”:2,“Name”:“王五”,“CreateTime”:null}]
张三
2021-09-16

类详情见官网

2.DataContractJsonSerializer类

1.介绍

DataContractJsonSerializer 类别是 .NET Framework 3.5 的新成员，它可以用来将对象序列化成 JSON 格式的字串，或者执行反序列化，也就是根据 JSON 格式的字串内容来建立对象，并还原对象的状态。它在程序集 System.Runtime.Serialization.dll下的System.Runtime.Serialization.Json命名空间里。

2.示例

1.添加一个控制台程序。添加程序集引用，并引入命名空间。

2.支持自订类型和常用的 .NET 类型，包括：string、int、double、DateTime、bool 等。
为了测试至少三层的巢状序列化，写几个简单的类别，包括 Order（订单）、OrderItem（订单细项）、Product（产品），代码如下：

    [DataContract]
    public class Order
    {
        private List<OrderItem> items;

        public Order()
        {
        }

        public Order(int id, DateTime orderDate, bool useCoupon)
        {
            this.ID = id;
            this.OrderDate = orderDate;
            this.UseCoupon = useCoupon;
            this.items = new List<OrderItem>();
        }

        [DataMember]
        public int ID { get; set; }

        [DataMember]
        public DateTime OrderDate { get; set; }

        [DataMember]
        public bool UseCoupon { get; set; }

        [DataMember]
        public List<OrderItem> Items
        {
            get { return items; }
            set { items = value; }
        }
    }

    [DataContract]
    public class OrderItem
    {
        public OrderItem(Product product, int count)
        {
            this.Product = product;
            this.Count = count;
        }

        [DataMember]
        public Product Product { get; set; }

        [DataMember]
        public int Count { get; set; }
    }

    [DataContract]
    public class Product
    {
        public Product(string name, double price)
        {
            this.Name = name;
            this.Price = price;
        }

        [DataMember]
        public string Name { get; set; }

        [DataMember]
        public double Price { get; set; }
    }

要点：欲序列化的类别需套用 DataContract attribute；同时，欲序列化的类别属性还必须套用 DataMember attribute，否则该属性不会参与序列化／反序列化过程。

3.下面JSONHelper工作类使用泛型，能使你的工作轻松些：

using System;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Text;

namespace DataCJS
{
    public class JsonHelper
    {
        public static string Serialize<T>(T obj)
        {
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
            using (MemoryStream ms = new MemoryStream())
            {
                serializer.WriteObject(ms, obj);
                string retVal = Encoding.UTF8.GetString(ms.ToArray());                    
                return retVal;
            }
        }

        public static T Deserialize<T>(string json) 
        {
            T obj = Activator.CreateInstance<T>();
            MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(json));
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
            obj = (T)serializer.ReadObject(ms);
            ms.Close();
            ms.Dispose();
            return obj;
        }
    }
}

4.控制台代码：

 static void Main(string[] args)
        {
            ///序列化
            Order order = new Order(1, DateTime.Now, true);
            order.Items.Add(new OrderItem(new Product("笔记本", 3000), 2));
            order.Items.Add(new OrderItem(new Product("无线键鼠", 126.9), 2));           
            string jsonStr = JsonHelper.Serialize<Order>(order);

            Console.WriteLine("\r\n序列化得到Json字符串:\r\n");         
            Console.WriteLine(jsonStr);

            ///反序列化
            Order dOrder = JsonHelper.Deserialize<Order>(jsonStr);
            Console.WriteLine("\r\n\r\n反序列化结果:");
            Console.WriteLine("\r\nOrderID: " + dOrder.ID.ToString());
            Console.WriteLine("\r\nOrderDate: " + dOrder.OrderDate.ToString("yyyy/MM/dd HH:mm:ss"));
            Console.WriteLine("\r\nUseCoupon: " + dOrder.UseCoupon.ToString());

            foreach (OrderItem item in dOrder.Items)
            {
                Console.WriteLine("\r\n==========================");
                Console.WriteLine("\r\nProduct name: " + item.Product.Name);
                Console.WriteLine("\r\nPrice: " + item.Product.Price.ToString());
                Console.WriteLine("\r\nCount: " + item.Count.ToString());
            }

            Console.ReadLine();
        }

5.运行结果如下图：

类详情见官网

3.Newtonsoft.Json（JSON.NET）

1.介绍

JSON.NET是一个开源的世界级的Json操作类库，从下面的性能对比就可以看到它的其中之一的性能优点。

齐全的API介绍，使用方式简单

2.示例

1.创建一个控制项目，在包管理器中搜索安装该包，如下图：

2.基本用法
Json.Net是支持序列化和反序列化DataTable,DataSet,Entity Framework和Entity的。下面分别举例说明序列化和反序列化。
DataTable：

 static void Main(string[] args)
        {
            //序列化DataTable
            DataTable dt = new DataTable();
            dt.Columns.Add("Age", Type.GetType("System.Int32"));
            dt.Columns.Add("Name", Type.GetType("System.String"));
            dt.Columns.Add("Sex", Type.GetType("System.String"));
            dt.Columns.Add("IsMarry", Type.GetType("System.Boolean"));
            for (int i = 0; i < 4; i++)
            {
                DataRow dr = dt.NewRow();
                dr["Age"] = i + 1;
                dr["Name"] = "Name" + i;
                dr["Sex"] = i % 2 == 0 ? "男" : "女";
                dr["IsMarry"] = i % 2 > 0 ? true : false;
                dt.Rows.Add(dr);
            }
            string dejsonstr = JsonConvert.SerializeObject(dt);
            Console.WriteLine("\r\n序列化得到Json字符串:\r\n");
            Console.WriteLine(dejsonstr);


            ///反序列化           
            Console.WriteLine("\r\n\r\n反序列化结果:");
            dt = JsonConvert.DeserializeObject<DataTable>(dejsonstr);
            foreach (DataRow dr in dt.Rows)
            {
                Console.WriteLine("{0}\t{1}\t{2}\t{3}\t", dr[0], dr[1], dr[2], dr[3]);
            }

            Console.ReadLine();
        }

运行程序结果如下：

3.高级用法
1.忽略某些属性
2.默认值的处理
3.空值的处理
4.支持非公共成员
5.日期处理
6.自定义序列化的字段名称
7.动态决定属性是否序列化
8.枚举值的自定义格式化问题
9.自定义类型转换
10.全局序列化设置
高级用法详情参考

高级用法代码比较多这里就不贴上来了，
我的学习源代码github地址，仅供学些参考，欢迎多多交流。

1. JSON简介

JSON（JavaScript Object Notation，JavaScript 对象简谱）是一种轻量级的数据交换格式。
JSON是一种语法，用来序列化对象、数组、数值、字符串、布尔值和 null 。（不包含undefined）

JSON可以描述三种格式的数据：

• object（无序的「键-值」集合）
• array（有序的值集合）
• value

具体可参考「每日一题」JSON 是什么？一文，以下语法图均引用自此文。

2. JSON与JS Object区别

JSON基于JavaScript语法，但与之不同：JavaScript不是JSON，JSON也不是JavaScript。

两者没有任何的关联，道格拉斯在发明 JSON 的时候参考了 JS 的对象语法而已。

两者区别可参考：MDN文档：JavaScript Object Notation中所描述的JavaScript 与 JSON 的区别：

3. 对象序列化

序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。

简单来说，对象序列化就是将对象的状态转为字符串形式。

可以使用eavl()函数将JSON的字符串解析成JavaScript对象。由于eavl()函数并不安全。因此尽量不要使用此函数。

JavaScript中JSON对象提供了两种方法：用于解析JSON的parse()方法、用于将对象/值转换为 JSON字符串的stringify()方法。除此之外JSON对象没有其他作用，也不能被调用或作为构造函数。

3.1 JSON序列化

JSON.stringify()方法将一个 JavaScript 对象或值转换为 JSON 字符串，如果指定了一个 replacer 函数，则可以选择性地替换值，或者指定的 replacer 是数组，则可选择性地仅包含数组指定的属性。

语法格式：JSON.stringify(value[, replacer [, space]])

• value：将要序列化成 一个 JSON 字符串的值；
• replacer：如果该参数是一个函数，则在序列化过程中，被序列化的值的每个属性都会经过该函数的转换和处理；如果该参数是一个数组，则只有包含在这个数组中的属性名才会被序列化到最终的 JSON 字符串中；如果该参数为 null 或者未提供，则对象所有的属性都会被序列化。
• space：指定缩进用的空白字符串，用于美化输出（pretty-print）；如果参数是个数字，它代表有多少的空格；上限为10。该值若小于1，则意味着没有空格；如果该参数为字符串（当字符串长度超过10个字母，取其前10个字母），该字符串将被作为空格；如果该参数没有提供（或者为 null），将没有空格。
• 返回值：一个表示给定值的JSON字符串。
• 异常：当在循环引用时会抛出异常TypeError；当尝试去转换 BigInt 类型的值会抛出TypeError；

JSON.stringify({});                        // '{}'
JSON.stringify(true);                      // 'true'
JSON.stringify("foo");                     // '"foo"'
JSON.stringify([1, "false", false]);       // '[1,"false",false]'
JSON.stringify({ x: 5 });                  // '{"x":5}'

JSON.stringify({x: 5, y: 6});
// "{"x":5,"y":6}"

JSON.stringify([new Number(1), new String("false"), new Boolean(false)]);
// '[1,"false",false]'

如果一个被序列化的对象拥有 toJSON 方法，那么该 toJSON 方法就会覆盖该对象默认的序列化行为：不是该对象被序列化，而是调用 toJSON 方法后的返回值会被序列化。

3.2 JSON反序列化

JSON.parse()方法用来解析JSON字符串，构造由字符串描述的JavaScript值或对象。

语法格式：JSON.parse(text[, reviver])

• text：要被解析成 JavaScript 值的字符串；
• reviver：转换器, 如果传入该参数(函数)，可以用来修改解析生成的原始值，调用时机在parse函数返回之前。
• 返回值：Object类型；
• 异常：若传入的字符串不符合 JSON 规范，则会抛出SyntaxError异常。

const json = '{"result":true, "count":42}';
const obj = JSON.parse(json);
console.log(obj.count);        // { result: true, count: 42 }

JSON.parse('{"p": 5}', function (k, v) {
    if(k === '') return v;     // 如果到了最顶层，则直接返回属性值，
    return v * 2;              // 否则将属性值变为原来的 2 倍。
});                            // { p: 10 }

1、什么是json序列化和反序列化？

json序列化：就是JavaBean对象转化为JSON格式的字符串。

反序列化：就是序列化的反方向，将字符串转化为JavaBean。

2、为什么要序列化和反序列化？

现在比较流行前后端分离的项目，前后端分离就离不开传递数据，一种好的数据表示形式让开发者和网站能轻易识别是很重要的，而这个数据表示形式就是json。这时候问题又来了，前端要json字符串，后端要javaBean对象（假设后端采用java语言）怎么办？此时就需要json的序列化和反序列化了。

3、流行的类库

json处理有三个比较流行的类库，分别是阿里巴巴开发的FastJson，谷歌开发的Gosn，和Spring Boot内置的Jackson。

4、简单的json形式

{
	"myAge": 5,
	"myBirth": "2021-01-24 14:19:29 025",
	"myName": "小狗"
}

下边以fastjson为例

JSONField() 注解

@JSONField(ordinal = 1) //指定json序列化的顺序
@JSONField(serialize = false) //json序列化时忽略该字段
@JSONField(deserialize = false) //json反序列化时转成对象将忽略该字段
@JSONField(format = “yyyy-MM-dd HH:mm:ss SSS”) //时间格式转换

常用的方法

JSONObject.toJSONString(value) 将value对象转化成json字符串

JSONObject.parseObject(value,java.class) 将value转化成java对象

JSONObject.parseArray(value,java.class) 将value转化成java对象数组

如果不写java.class，只写value，会转成JSONObject字符串。

代码：

创建一个maven项目，导入fastjson和lombok。

lombok中的注解可以让我们不生产get和set方法

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.70</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.8</version>
    </dependency>

1、创建Animal.java类

import com.alibaba.fastjson.annotation.JSONField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Animal {

    @JSONField(name = "myName")
    private String myName;

    @JSONField(name = "myAge")
    private int myAge;

    @JSONField(name = "myBirth",format = "yyyy-MM-dd HH:mm:ss SSS")
    private Date myBirth;

}

2、创建Persion.java类

import com.alibaba.fastjson.annotation.JSONField;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;


@Data
@AllArgsConstructor
@NoArgsConstructor
public class Persion {

    @JSONField(name = "name")
    private String name;

    @JSONField(name = "age")
    private int age;

    @JSONField(name = "Birth" ,format = "yyyy-MM-dd HH:mm:ss SSS")
    private Date Birth;

}

toJSONString() 的使用

将list集合转化成json

        List<Persion> persions = new ArrayList<Persion>();

        persions.add(new Persion("张三", 16, new Date()));
        persions.add(new Persion("李四", 18, new Date()));
        persions.add(new Persion("王五", 20, new Date()));
        persions.add(new Persion("麻子", 22, new Date()));
        //将list集合转化成json
        String jsonPersion= JSON.toJSONString(persions);
        System.out.println(jsonPersion);

输出结果如下：

[{
	"Birth": "2021-01-24 14:33:43 229",
	"age": 16,
	"name": "张三"
}, {
	"Birth": "2021-01-24 14:33:43 229",
	"age": 18,
	"name": "李四"
}, {
	"Birth": "2021-01-24 14:33:43 229",
	"age": 20,
	"name": "王五"
}, {
	"Birth": "2021-01-24 14:33:43 229",
	"age": 22,
	"name": "麻子"
}]

将map集合转化成json

        Map animal = new HashMap();

        animal.put("宠物狗",new Animal("小狗",5, new Date()));
        animal.put("波斯猫",new Animal("小猫",6, new Date()));
        animal.put("猪",new Animal("小猪",7, new Date()));

        //将list集合转化成json
        String jsonAnimal = JSON.toJSONString(animal);
        System.out.println(jsonAnimal);

输出结果如下：

{
	"宠物狗": {
		"myAge": 5,
		"myBirth": "2021-01-24 14:33:43 370",
		"myName": "小狗"
	},
	"猪": {
		"myAge": 7,
		"myBirth": "2021-01-24 14:33:43 370",
		"myName": "小猪"
	},
	"波斯猫": {
		"myAge": 6,
		"myBirth": "2021-01-24 14:33:43 370",
		"myName": "小猫"
	}
}

多层封装

一般一个请求，都是有请求头和请求体，它们里面又会有各种参数。

现在假如说有一个world世界类，包含了动物Animal类和Persion类，代码如下。

创建一个world.java

@Data
public class World {

    @JSONField(name = "Persion")
    private Persion Persion;

    @JSONField(name = "Animal")
    private Animal Animal;
}

测试

        World world = new World();
        Persion persion = new Persion("张三",18,new Date());

        Animal animal1 = new Animal("小狗",6,new Date());
        world.setPersion(persion);
        world.setAnimal(animal1);

        System.out.println(JSON.toJSONString(world));

输出结果

{
	"Animal": {
		"myAge": 6,
		"myBirth": "2021-01-24 15:32:31 392",
		"myName": "小狗"
	},
	"Persion": {
		"Birth": "2021-01-24 15:32:31 392",
		"age": 18,
		"name": "张三"
	}
}

实际封装的json要比和复杂一些。所以路还是很长的。