一.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);
}
}