原文链接： https://blog.csdn.net/qq_37651267/article/details/91049513

Json是一种轻量级的数据交换格式，采用一种“键：值”对的文本格式来存储和表示数据，在系统交换数据过程中常常被使用，是一种理想的数据交换语言。在使用Java做Web开发时，不可避免的会遇到Json的使用。

JSON形式与语法

JSON对象

我们先来看以下数据：

{
    "ID": 1001,
    "name": "张三",
    "age": 24
}

这个数据就是一个Json对象，观察它的数据形式，可以得出以下语法：

1：数据在花括号中

2：数据以"键：值"对的形式出现（其中键多以字符串形式出现，值可取字符串，数值，甚至其他json对象）

3：每两个"键：值"对以逗号分隔（最后一个"键：值"对省略逗号）

遵守上面3点，便可以形成一个json对象。

JSON对象数组

接下来我们再看第二个数据，观察它的数据形式，可以得出以下语法：

[
    {"ID": 1001, "name": "张三", "age": 24},
    {"ID": 1002, "name": "李四", "age": 25},
    {"ID": 1003, "name": "王五", "age": 22}
]

1：数据在方括号中（可理解为数组）

2：方括号中每个数据以json对象形式出现

3：每两个数据以逗号分隔（最后一个无需逗号）

遵守上面3点，便可形成一个json对象数组（及一个数组中，存储了多个json对象）

理解了上面两种基本的形式，我们就可以得出其他的数据形式，例如下面这个：

{
    "部门名称":"研发部",
    "部门成员":[
    {"ID": 1001, "name": "张三", "age": 24},
    {"ID": 1002, "name": "李四", "age": 25},
    {"ID": 1003, "name": "王五", "age": 22}],
    "部门位置":"xx楼21号"
}

这是上面两个基本形式结合出来的一种变形，通过这种变形，使得数据的封装具有很大的灵活性，能让开发者自由的发挥想象力。

JSON字符串

JSON字符串也是在平时开发中使用较多的，json字符串应满足以下条件：

1：它必须是一个字符串，由" "或者' '包裹数据，支持字符串的各种操作；

2：里面的数据格式应该要满足其中一个格式，可以是json对象，也可以是json对象数组或者是两种基本形式的组合变形。

总结：json可以简单的分为基本形式：json对象，json对象数组。两种基本格式组合变形出其他的形式，但其本质还是json对象或者json对象数组中的一种。

json对象或对象数组可以和json字符串以及集合互相转换，使用于不同的场合。

注意点：在封装json数据的时候，很容易出现错误，比如粗心的在最后一条数据的末尾加上了逗号等等，这里我提供一个在线验证工具，方便大家验证json数据格式的正确性http://www.bejson.com/

FastJson简介

JSON协议使用方便，越来越流行，JSON的处理器有很多，这里我介绍一下FastJson，FastJson是阿里的开源框架，被不少企业使用，是一个极其优秀的Json框架。

----【需要引入 fastjson-1.2.40.jar包】

FastJson的特点

1、FastJson数度快,无论序列化和反序列化,都是当之无愧的fast

2、功能强大(支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum等）

3、零依赖(没有依赖其它任何类库)；

FastJson的简单说明

FastJson对于json格式字符串的解析主要用到了下面三个类：

1、JSON：fastJson的解析器，用于JSON格式字符串与JSON对象及javaBean之间的转换

2、JSONObject：fastJson提供的json对象，继承自JSON。

3、JSONArray：fastJson提供json数组对象，继承自JSON。

基本使用

首先定义三个json格式的字符串

//json字符串-简单对象型
private static final String  JSON_OBJ_STR = "{\"studentName\":\"lily\",\"studentAge\":12}";

//json字符串-数组类型
private static final String  JSON_ARRAY_STR = "[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]";

//复杂格式json字符串
private static final String  COMPLEX_JSON_STR = "{\"teacherName\":\"crystall\",\"teacherAge\":27,\"course\":{\"courseName\":\"english\",\"code\":1270},\"students\":[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]}";

JSON格式字符串与JSON对象之间的转换

1、json字符串-简单对象型与JSONObject之间的转换

// JSON格式字符串 --> JSONObject
JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);
System.out.println("studentName:  " + jsonObject.getString("studentName") + ":" + "  studentAge:  "
            + jsonObject.getInteger("studentAge")); // 可以通过getXxx方法来获取对应键的值


// JSONObject --> JSON格式字符串
// 第一种方式
String jsonString = JSONObject.toJSONString(jsonObject);

// 第二种方式
String jsonString = jsonObject.toJSONString();

2、json数组格式字符串与JSONArray的转换

JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);

// 可以遍历获取JSON数组对象中的每一个JSON对象，其实和普通数组的遍历方式类似
// 遍历方式1
int size = jsonArray.size();
for (int i = 0; i < size; i++) {
    JSONObject jsonObject = jsonArray.getJSONObject(i);
}

// 遍历方式2
for (Object obj : jsonArray) {
    JSONObject jsonObject = (JSONObject) obj;
}


// JSONArray到json字符串-数组类型的转换
// 已知JSONArray,目标要转换为json字符串
JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);
// 第一种方式
String jsonString = JSONArray.toJSONString(jsonArray);

// 第二种方式
String jsonString = jsonArray.toJSONString(jsonArray);

3、复杂json格式字符串与JSONObject之间的转换

/**
 * 复杂json格式字符串到JSONObject的转换
 */
@Test
public void testComplexJSONStrToJSONObject() {
    JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);
    String teacherName = jsonObject.getString("teacherName");
    Integer teacherAge = jsonObject.getInteger("teacherAge");
    System.out.println("teacherName:  " + teacherName + "   teacherAge:  " + teacherAge);
    JSONObject jsonObjectcourse = jsonObject.getJSONObject("course");
     //获取JSONObject中的数据
    String courseName = jsonObjectcourse.getString("courseName");
    Integer code = jsonObjectcourse.getInteger("code");
    System.out.println("courseName:  " + courseName + "   code:  " + code);
    JSONArray jsonArraystudents = jsonObject.getJSONArray("students");
    //遍历JSONArray
    for (Object object : jsonArraystudents) {
        JSONObject jsonObjectone = (JSONObject) object;
        String studentName = jsonObjectone.getString("studentName");
        Integer studentAge = jsonObjectone.getInteger("studentAge");
        System.out.println("studentName:  " + studentName + "   studentAge:  " + studentAge);
    }
}
/**
 * 复杂JSONObject到json格式字符串的转换
 */
@Test
public void testJSONObjectToComplexJSONStr() {
   //复杂JSONObject,目标要转换为json字符串
    JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);
    //第一种方式
    //String jsonString = JSONObject.toJSONString(jsonObject);
    //第二种方式
    String jsonString = jsonObject.toJSONString();
    System.out.println(jsonString);
}

可见JSON对象也是可以直接通过键来获取值的。

JSON格式字符串与javaBean之间的转换

JSON和javaBean对象转换时，关键是结构要对上，一般普通的JSON格式对应普通实体类或者Map，JSON数组格式对应List里面再存放普通实体类或者Map，然后复杂些的就是他们的嵌套。

1、json字符串-简单对象型与javaBean之间的转换

/**
 * json字符串-简单对象到JavaBean之间的转换
 */
@Test
public void testJSONStrToJavaBeanObj() {

    //第一种方式
    JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);

    String studentName = jsonObject.getString("studentName");
    Integer studentAge = jsonObject.getInteger("studentAge");
    Student student = new Student(studentName, studentAge);

    //第二种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    //Student student = JSONObject.parseObject(JSON_OBJ_STR, new TypeReference<Student>() {});

    //第三种方式,使用Gson的思想
    Student student = JSONObject.parseObject(JSON_OBJ_STR, Student.class);

    System.out.println(student);
}

/**
 * JavaBean到json字符串-简单对象的转换
 */
@Test
public void testJavaBeanObjToJSONStr() {

    Student student = new Student("lily", 12);
    String jsonString = JSONObject.toJSONString(student);
    System.out.println(jsonString);
}

2、json字符串-数组类型与javaBean之间的转换

/**
 * json字符串-数组类型到JavaBean_List的转换
 */
@Test
public void testJSONStrToJavaBeanList() {
    //第一种方式
    JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);

    //遍历JSONArray
    List<Student> students = new ArrayList<Student>();
    Student student = null;
    for (Object object : jsonArray) {

        JSONObject jsonObjectone = (JSONObject) object;
        String studentName = jsonObjectone.getString("studentName");
        Integer studentAge = jsonObjectone.getInteger("studentAge");

        student = new Student(studentName,studentAge);
        students.add(student);
    }
    System.out.println("students:  " + students);
    //第二种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    List<Student> studentList = JSONArray.parseObject(JSON_ARRAY_STR, new TypeReference<ArrayList<Student>>() {});
    System.out.println("studentList:  " + studentList);
    //第三种方式,使用Gson的思想
    List<Student> studentList1 = JSONArray.parseArray(JSON_ARRAY_STR, Student.class);
    System.out.println("studentList1:  " + studentList1);
}
/**
 * JavaBean_List到json字符串-数组类型的转换
 */
@Test
public void testJavaBeanListToJSONStr() {
    Student student = new Student("lily", 12);
    Student studenttwo = new Student("lucy", 15);
    List<Student> students = new ArrayList<Student>();
    students.add(student);
    students.add(studenttwo);
    String jsonString = JSONArray.toJSONString(students);
    System.out.println(jsonString);
}

3、复杂json格式字符串与与javaBean之间的转换

/**
 * 复杂json格式字符串到JavaBean_obj的转换
 */
@Test
public void testComplexJSONStrToJavaBean(){

    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    Teacher teacher = JSONObject.parseObject(COMPLEX_JSON_STR, new TypeReference<Teacher>() {});
    System.out.println(teacher);

    //第二种方式,使用Gson思想
    Teacher teacher1 = JSONObject.parseObject(COMPLEX_JSON_STR, Teacher.class);
    System.out.println(teacher1);
}

/**
 * 复杂JavaBean_obj到json格式字符串的转换
 */
@Test
public void testJavaBeanToComplexJSONStr(){

    //已知复杂JavaBean_obj
    Teacher teacher = JSONObject.parseObject(COMPLEX_JSON_STR, new TypeReference<Teacher>() {});
    String jsonString = JSONObject.toJSONString(teacher);
    System.out.println(jsonString);
}

原理都是一样的，总之记住要结构对得上，从上面可以看出，parseObject()和parseArray()方法，如果不指定Xxx.class，就默认转成对应的JSON对象，如果指定了Xxx.class，就会转成对应的javaBean对象。

javaBean与json对象间的之间的转换

1、简单javaBean与json对象之间的转换

/**
 * 简单JavaBean_obj到json对象的转换
 */
@Test
public void testJavaBeanToJSONObject(){

    //已知简单JavaBean_obj
    Student student = new Student("lily", 12);

    //方式一
    String jsonString = JSONObject.toJSONString(student);
    JSONObject jsonObject = JSONObject.parseObject(jsonString);
    System.out.println(jsonObject);

    //方式二
    JSONObject jsonObject1 = (JSONObject) JSONObject.toJSON(student);
    System.out.println(jsonObject1);
}

/**
 * 简单json对象到JavaBean_obj的转换
 */
@Test
public void testJSONObjectToJavaBean(){

    //已知简单json对象
    JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);

    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    Student student = JSONObject.parseObject(jsonObject.toJSONString(), new TypeReference<Student>() {});
    System.out.println(student);

    //第二种方式,使用Gson的思想
    Student student1 = JSONObject.parseObject(jsonObject.toJSONString(), Student.class);
    System.out.println(student1);
}

2、JavaList与JsonArray之间的转换

/**
 * JavaList到JsonArray的转换
 */
@Test
public void testJavaListToJsonArray() {

    //已知JavaList
    Student student = new Student("lily", 12);
    Student studenttwo = new Student("lucy", 15);

    List<Student> students = new ArrayList<Student>();
    students.add(student);
    students.add(studenttwo);

    //方式一
    String jsonString = JSONArray.toJSONString(students);
    JSONArray jsonArray = JSONArray.parseArray(jsonString);
    System.out.println(jsonArray);

    //方式二
    JSONArray jsonArray1 = (JSONArray) JSONArray.toJSON(students);
    System.out.println(jsonArray1);
}

/**
 * JsonArray到JavaList的转换
 */
@Test
public void testJsonArrayToJavaList() {

    //已知JsonArray
    JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);

    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    ArrayList<Student> students = JSONArray.parseObject(jsonArray.toJSONString(),
            new TypeReference<ArrayList<Student>>() {});

    System.out.println(students);
    //第二种方式,使用Gson的思想
    List<Student> students1 = JSONArray.parseArray(jsonArray.toJSONString(), Student.class);
    System.out.println(students1);
}

3、复杂JavaBean_obj与json对象之间的转换

/**
 * 复杂JavaBean_obj到json对象的转换
 */
@Test
public void testComplexJavaBeanToJSONObject() {
    //已知复杂JavaBean_obj
    Student student = new Student("lily", 12);
    Student studenttwo = new Student("lucy", 15);

    List<Student> students = new ArrayList<Student>();
    students.add(student);
    students.add(studenttwo);
    Course course = new Course("english", 1270);

    Teacher teacher = new Teacher("crystall", 27, course, students);

    //方式一
    String jsonString = JSONObject.toJSONString(teacher);
    JSONObject jsonObject = JSONObject.parseObject(jsonString);
    System.out.println(jsonObject);

    //方式二
    JSONObject jsonObject1 = (JSONObject) JSONObject.toJSON(teacher);
    System.out.println(jsonObject1);
}

/**
 * 复杂json对象到JavaBean_obj的转换
 */
@Test
public void testComplexJSONObjectToJavaBean() {
    //已知复杂json对象
    JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);

    //第一种方式,使用TypeReference<T>类,由于其构造方法使用protected进行修饰,故创建其子类
    Teacher teacher = JSONObject.parseObject(jsonObject.toJSONString(), new TypeReference<Teacher>() {});
    System.out.println(teacher);
    //第二种方式,使用Gson的思想
    Teacher teacher1 = JSONObject.parseObject(jsonObject.toJSONString(), Teacher.class);
    System.out.println(teacher1);
}

Jackson

使用jackson需要引入以下第三方jar包：
在这里插入图片描述
代码：

package Exercise1_jackson;
 
import java.io.IOException;
import java.util.List;
 
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
 
/**
 * @author huangxinyi
 * jackson实现对象和json,集合和json之间的互相转换
 * 
 */
public class Test {
	
	private ObjectMapper objectMapper = new ObjectMapper();
	
	@org.junit.Test
	public void test(){
		String jsonArr = "[{\"brand\":\"联想\",\"type\":\"电脑\",\"color\":\"白色\",\"price\":\"3000\"},"+
                "{\"brand\":\"小米\",\"type\":\"手机\",\"color\":\"黑色\",\"price\":\"2500\"},"+
                "{\"brand\":\"华为\",\"type\":\"手机\",\"color\":\"白色\",\"price\":\"2000\"},"+
                "{\"brand\":\"戴尔\",\"type\":\"电脑\",\"color\":\"蓝色\",\"price\":\"4000\"},"+
                "{\"brand\":\"苹果\",\"type\":\"手机\",\"color\":\"红色\",\"price\":\"5000\"}]";
			
		try {
			//json转集合
			List<Product> plist = objectMapper.readValue(jsonArr, new TypeReference<List<Product>>(){});
			System.out.println(plist);
			
			//json转对象
			Product p = objectMapper.readValue("{\"brand\":\"小米\",\"type\":\"手机\",\"color\":\"黑色\",\"price\":\"2500\"}", Product.class);
			System.out.println(p);
			
			//对象转json
			String json_p = objectMapper.writeValueAsString(new Product("小米","手机","黑色",2500));
			System.out.println(json_p);
			
			//集合转json
			String json_list = objectMapper.writeValueAsString(plist);
			System.out.println(json_list);
			
		} catch (JsonParseException e) {
			e.printStackTrace();
		} catch (JsonMappingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

JSON技术的补充

json-lib

json-lib最开始的也是应用最广泛的json解析工具，json-lib 不好的地方确实是依赖于很多第三方包，包括commons-beanutils.jar，commons-collections-3.2.jar，commons-lang-2.6.jar，commons-logging-1.1.1.jar，ezmorph-1.0.6.jar，对于复杂类型的转换，json-lib对于json转换成bean还有缺陷，比如一个类里面会出现另一个类的list或者map集合，json-lib从json到bean的转换就会出现问题。
json-lib在功能和性能上面都不能满足现在互联网化的需求。

开源的Jackson

相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。而且Jackson社区相对比较活跃，更新速度也比较快。Jackson对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。
Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式。

阿里巴巴的FastJson

Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。无依赖，不需要例外额外的jar，能够直接跑在JDK上。FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。
FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库。

Google的Gson

Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，但自从在2008年五月公开发布第一版后已被许多公司或用户应用。Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将JSON字符串成功转换成相对应的对象。类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。

Gson在功能上面无可挑剔，但是性能上面比FastJson有所差距。

综上4种Json技术的比较，在项目选型的时候可以使用Google的Gson和阿里巴巴的FastJson两种并行使用，如果只是功能要求，没有性能要求，可以使用google的Gson，如果有性能上面的要求可以使用Gson将bean转换json确保数据的正确，使用FastJson将Json转换Bean。

选用的方便性和性能

调用方便性而言：

FastJSON提供了大量静态方法，调用简洁方便

Jackson须实例化类，调用相对繁琐，可通过封装成JSON工具类简化调用

性能而言：

FastJSON反序列化的性能略差，对于256k的json字符串，平均700ms

Jackson 的 data binding反序列化的性能稍好，对于256k的json字符串，平均600ms

两者的序列化性能基本相同，对于256k的json字符串，平均140ms

相对data binding方式（ObjectMapper.writeValueAsString()），Jackson的流输出方式（JsonGenerator.writeObject()）性能稍好，平均130ms

FASTJSON和JACKSON基本使用