JavaEE中级.20190614.JSON.解析方式.

一.JSON

          1.JSON 是一种轻量级易与解析的数据格式，它按照 js 的对象和数组的字面量格式来书写。 现在 JSON 的光环已经逐渐超越了 XML，各大网站提供的数据接口一般都是 JSON。

          下面的代码是用 JSON 编写的用户列表：

[
    {
        "name": "john",
        "age": 15
    },
    {
        "name": "wall",
        "age": 22
    },
    {
        "name": "ben",
        "age": 8
    }
]

          jquery 1.4 以后对 json 格式变严格了,也就是说必须要这种格式的{"键":"值","键":"值 "};像原来的{键:值，键:值}和{'键':'值','键':'值'}这种都是错误的，不合标准，所以 jquery 返回 error 如"{\"success\":true,\"msg\":\"success\"}"，如果说是
boolean 类型，则不用加 引号，其它的键/值都需要加引号。

       2.JSON三种类型

           1）基本类型

{
    "name":"张三",
    "age":18,
    "sex":true
}

          2)数组类型

[
    {
        "name":"张三",
        "age":18,
        "sex":true
    },
    {
        
        "name":"李四",
        "age":19,
        "sex":false
    }
]

           3)对象嵌套

{
	"name": "teacher",
	"computer": {
		"CPU": "intel7",
		"disk": "512G"
	},
	"students": [
		{
			"name": "张三",
			"age": 18,
			"sex": true
		},
		{
			"name": "李四",
			"age": 19,
			"sex": false
		}
	]
}

       3.JSON格式 

            1）两种构造结构

                   ①对象:“名称/值”对的集合(A collection of name/value pairs)

                       不同的语言中，它被理解为对象（object），记录（record），结构(struct)，字典 (dictionary)，哈希表（hash table），有键列表(keyed list)，或者关联数组(associative array)。

                   ②数组:值的有序列表(An ordered list of values)

                       在大多数语言中，它被理解为数组(array)、矢量(vector), 列表(list)或者序列 (sequence)。
经过对象、数组 2 种结构就可以组合成复杂的数据结构了。

             2）具体形式

                      Json 以 key－value 的形式存储数据
                      Key 的取值 为 String 类型;
                      Value 的取值 为 String,boolean,Number,数组,Object,null;
                      Json串以{开始,以}结尾;
                      Json 串中数组是以[开始,以]结尾;
                      Json 串中Object是以{开始,以}结尾;

         a)、对象是一个无序的“名称/值”对集合。一个对象以”{”开始，“}”结束。每个名称后跟一个“:”；“名称/值 ”对之间使用“,”分隔。

                    

         b)、数组是值的有序集合。一个数组以“[”开始，“]”结束。各值间使用“,”分隔。

                    

二.解析方式

       1. 使用 gson 处理
                 Gson是一个Google提供的一个Java库,可用于将Java对象转换为JSON表示。它也可以被用来将JSON字符串转换成一个等效的Java对象。
                 提供易于使用的机制如toString()和构造函数(工厂方法)将Java转换为JSON,反之亦然。允许自定义表示对象，支持任意复杂的对象，生成紧凑和可读性的JSON输出
          1) 转为 Json 字符串
               I)、获得需要的对象: 

Student stu = new Student();
stu.setName("张三");
stu.setAge(18);

               II)、格式化为字符串

Gson gson = new Gson();
//将 对象 转化成 json 字符串
String json = gson.toJson(stu)

           2) 解析成 java 对象

               I)、Gson 的 节点对象: JsonElement : 所有的节点 都是 JsonElement 对象. JsonPrimitive : 基本的 数据类型的 节点 对象， JsonElement 的子类. JsonNull : 代表 空节点 对象，即 有 key，value 为空，JsonElement 的子类. JsonObject : 对象 数据类型的 节点 对象, JsonElement 的 子类. JsonArray : 数组 数据类型的 节点 对象, JsonElement 的 子类.
               II)、JsonElement 的取值: JsonPrimitive : value 的 取值对应 java 的 int,double,float,long,short,boolean,char,byte,String,BigDecimal,BigI nteger,Number JsonObject : value 的取值对应 java 的 Object 对象. JsonArray : value 的取值对应 java 的 List 及其子类对象.

              III)、解析对象

                      Json 解析成 java 对象

{“name”:”张三”,”age”:18,”sex”:true}
Gson gson = new Gson();
// 将 json 转化成 java 对象
Student stu = gson.fromJson(json, Student.class);

                     Json 解析 成 List

[
{"name":"a","age":18,"sex":true},
{"name":"b","age":19,"sex":false},
{"name":"c","age":20,"sex":true},
{"name":"d","age":21,"sex":false},
{"name":"e","age":22,"sex":true}
]
Gson gson = new Gson();
// 将 json 转化 成 List 泛型
List<Student> stus = gson.fromJson(json, new TypeToken<List<Student>>()
{}.getType());

                   Json 解析 成 map

{
	"a": {
		"name": "a",
		"age": 20,
		"sex": true
	},
	"b": {
		"name": "b",
		"age": 21,
		"sex": false
	},
	"c": {
		"name": "c",
		"age": 22,
		"sex": true
	},
	"d": {
		"name": "d",
		"age": 18,
		"sex": true
	},
	"e": {
		"name": "e","age":19,"sex":false
}
	Gson gson = new Gson();
	// 将 json 转化成 Map 泛型了 TypeToken，它是 gson 提供的数据类型转换器
	Map<String,Student> map = gson.fromJson(json, new TypeToken<Map<String,Student>>()
	{}.getType());
	
	
	

              Json 节点解析

{
	"flag": true,
	"data": {
		"name": "张三",
		"age": 18,
		"sex":
	}
}

               解析步骤

解析步骤 :
	①获得解析器
		JsonParser parser = new JsonParser();
	②获得根节点元素
		JsonElement element = parser.parse(json);
	③根据文档判断根节点属于什么类型的 Gson 节点对象
		// 假如文档 显示 根节点 为对象类型
		// 获得 根节点 的实际 节点类型
		JsonObject root = element.getAsJsonObject();
	④取得节点下的某个节点的 value
		// 获得 flag 节点的值, flag 节点为基本数据节点
		JsonPrimitive flagJson = root.getAsJsonPrimitive("flag");
		// 基本节点取值
		boolean flag = flagJson.getAsBoolean();
		// 获得 data 节点的值，data 节点为 Object 数据节点
		JsonObject dataJson = root.getAsJsonObject("data");
		// 将节点上的数据转换为对象
		Student stu = new Gson().fromJson(dataJson,Student.class);

       2. 使用 fastjson 处理

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

                1) 转为 json 字符串

String jsonString = JSON.toJSONString(object);

               2) 解析成对象

1). JavaBean ： Person person = JSON.parseObject(jsonString, Person.class);
2). List ： List listPerson =JSON.parseArray(jsonString, Person.class);
3). List:List listString = JSON.parseArray(jsonString, String.class);
4). List<Map> List<Map> listMap = JSON.parseObject(jsonString, new TypeReference<List<Map>>(){});

               3) 实例

package com.shsxt.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.shsxt.model.User;

public class FastJsonTest {

	/**
	 * 将java对象转换成json格式的字符串
	 */
	@Test
	public void testJavaToJson() {
		
		// JavaBean对象
		User user = new User(1, "zhangsan", "123456", 18, "上海");
		String json1 = JSON.toJSONString(user);
		System.out.println(json1);
		
		
		// List集合
		List<String> list = new ArrayList<String>();
		list.add("zhangsan");
		list.add("lisi");
		list.add("wangwu");
		String json2 = JSON.toJSONString(list);
		System.out.println(json2);
		
		// JavaBean List
		List<User> userList = new ArrayList<>();
		User user2 = new User(2, "lisi", "123124", 19, "北京");
		User user3 = new User(3, "wangwu", "111111", 20, "杭州");
		userList.add(user);
		userList.add(user2);
		userList.add(user3);
		String json3 = JSON.toJSONString(userList);
		System.out.println(json3);
		
		
		// Map
		Map<String, Object> map = new HashMap<>();
		map.put("name","zhansgan");
		map.put("sex",true);
		map.put("user", user);
		map.put("userList", userList);
		String json4 = JSON.toJSONString(map);
		System.out.println(json4);
		
		
		Map<String, Object> map2 = new HashMap<>();
		map2.put("user1", user);
		map2.put("user2", user2);
		map2.put("user3", user3);
		String json5 = JSON.toJSONString(map2);
		System.out.println(json5);
		
		
		List<Map<String,String>> listMap = new ArrayList<>();
		Map<String, String> m1 = new HashMap<>();
		m1.put("user1", "aa");
		m1.put("user2", "bb");
		m1.put("user3", "cc");
		Map<String, String> m2 = new HashMap<>();
		m2.put("user4", "dd");
		m2.put("user5", "ee");
		m2.put("user6", "ff");
		listMap.add(m1);
		listMap.add(m2);
		String json6 = JSON.toJSONString(listMap);
		System.out.println(json6);
		
	}
	
	
	/**
	 * 将json字符串转换成java对象
	 */
	@Test
	public void testJsonTtoJava() {
		// 转JavaBean
		String json1 = "{\"userId\":1,\"userName\":\"zhangsan\",\"userPwd\":\"123456\",\"userAge\":18,\"address\":\"上海\"}";
		User user = JSON.parseObject(json1, User.class);
		System.out.println(user);
		
		// 转List
		String json2 = "[\"zhangsan\",\"lisi\",\"wangwu\"]";
		List<String> list = JSON.parseArray(json2,String.class);
		System.out.println(list);
		
		String json3 = "[{\"userId\":1,\"userName\":\"zhangsan\",\"userPwd\":\"123456\",\"userAge\":18,\"address\":\"上海\"},{\"userId\":2,\"userName\":\"lisi\",\"userPwd\":\"123124\",\"userAge\":19,\"address\":\"北京\"},{\"userId\":3,\"userName\":\"wangwu\",\"userPwd\":\"111111\",\"userAge\":20,\"address\":\"杭州\"}]";
		List<User> userList = JSON.parseArray(json3,User.class);	
		System.out.println(userList);
		
		String json4 = "[{\"user1\":\"aa\",\"user2\":\"bb\",\"user3\":\"cc\"},{\"user4\":\"dd\",\"user5\":\"ee\",\"user6\":\"ff\"}]";
		List<Map<String,String>> listMap =  JSON.parseObject(json4, new TypeReference<List<Map<String,String>>>(){});
		System.out.println(listMap);
			
	}

}