JSON数据格式
什么是JSON
JSON（JavaScript Object Notation, JS对象简谱）是一种轻量级的数据交换格式。它基于 ECMAScript（European Computer Manufacturers Association, 欧洲计算机协会制定的js规范）的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
JSON数组格式
Json的数据本身是数组，中括号包裹，数组的元素之间逗号分开，数组元素的数据类型没有限制。
var jsonArray=["元素1","元素2","元素3"];//定义数组格式json
console.log(jsonArray[0]);//访问json元素
for(var i=0 ; i<jsonArray.length;i++){
console.log(jsonArray[i]) //遍历数组，访问每一个元素
}测试
jsonArray.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script type="text/javascript">
/**
* 定义json的数组格式
*中括号包裹，数组的元素的数据类型没有限制
*元素之间，逗号分开
**/
var jsonArray=["k1","k2",100,9,true];
//访问数组元素，通过索引访问
console.log(jsonArray[1]);
//遍历数组，取出数组中的元素
for (var i=0;i< jsonArray.length;i++) {
console.log(jsonArray[i]);
}
</script>
</head>
<body>
</body>
</html>对象格式
json的数据本身是对象，大括号包裹1，对象采用键值对形式进行存储，健固定为字符串类型，值是任意类型的数据，健和值使用冒号分开
例如
var jsonObject={"k1":"v1","k2":"v2","k3":100,"k4":9.9,"k5":true};//定义对象格式json
console.log(jsonObject.k1);//取出键k1对应的值测试jsonObject.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script type="text/javascript">
/**
* 定义json的对象格式
* 大括号包裹，定义键值对，健必须是字符串类型，值的数据类型不限制
* 键值对之间，是冒号分开
* 每个键值对之间，逗号分开
**/
var jsonObject={"k1":"v1","k2":"v2","k3":100,"k4":9.9,"k5":true};
//取出键值对,健找值的方式
console.log(jsonObject.k1);
console.log(jsonObject.k2);
console.log(jsonObject.k3);
console.log(jsonObject.k4);
console.log(jsonObject.k5);
</script>
</head>
<body>
</body>
</html> 数组对象相互嵌套
1.数组的元素是对象
jectArrayObject.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script type="text/javascript">
/**
* json数组的元素是对象
*数组定义2个元素，每个元素是对象
*对象是键值对形式
**/
var jsonArray=[
{"name":"张三","age":20},
{"name":"李四","age":22}
];
//取出需要的数据李四22
console.log(jsonArray[1],name+"=="+jsonArray[1].age);
//遍历数组，取出数组中的元素
for (var i=0;i< jsonArray.length;i++) {
console.log(jsonArray[i],name+"=="+jsonArray[i].age);
}
</script>
</head>
<body>
</body>
</html>2.对象中的值是数组
jectObjectArray.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script type="text/javascript">
/**
* json数据是对象
*数组定义2个元素，每个元素是对象
*对象是键值对形式
**/
var jsonObject=
{
"k1":["北京","天津","上海"],
"k2":["中国","美国","英国"]
};
//取出上海
console.log(jsonObject.k1[2]);
//分别取出k1和k2的数组,遍历
for (var i=0;i< jsonObject.k1.length;i++) {
console.log(jsonObject.k1[i]);
}
console.log("=================");
for (var i=0;i< jsonObject.k2.length;i++) {
console.log(jsonObject.k2[i]);
}
</script>
</head>
<body>3.你中有我我中有你
json.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<script type="text/javascript">
/**
* json的数据嵌套,你中有我，我中有你
* json的数据本质上是对象
* 对象的健是字符串，对象的值是数组
* 数组的元素是对象
**/
var json={
//健是k1,值是数组，数组的元素是对象
"k1":[
//数组的元素是2个元素
{"name":"张三","age":20},
{"name":"李四","age":22}
] ,
"k2":[
//数组的元素是2个元素
{"name":"王五","age":24},
{"name":"赵六","age":26}
]
};
//取出数据李四22
console.log(json.k1[1].name+"=="+json.k1[1].age);
//遍历k2对应的数组
for (var i=0;i< json.k2.length;i++) {
console.log(json.k2[i].name+"=="+json.k2[i].age);
}
</script>
</body>
</html>Fastjson介绍
fastjson是阿里巴巴的开源JSON解析库,它可以解析JSON格式的字符串,支持将Java Bean序列化为JSON字符串,也可以从JSON字符串反序列化到JavaBean。
fastjson的优点
速度快
fastjson相对其他JSON库的特点是快，从2011年fastjson发布1.1.x版本之后，其性能从未被其他Java实现的JSON库超越。
使用广泛
fastjson在阿里巴巴大规模使用，在数万台服务器上部署，fastjson在业界被广泛接受。在2012年被开源中国评选为最受欢迎的国产开源软件之一。
测试完备
fastjson有非常多的testcase，在1.2.11版本中，testcase超过3321个。每次发布都会进行回归测试，保证质量稳定。
使用简单
fastjson的API十分简洁。
String text = JSON.toJSONString(obj); //序列化
VO vo = JSON.parseObject("{...}", VO.class); //反序列化
功能完备
支持泛型，支持流处理超大文本，支持枚举，支持序列化和反序列化扩展。
FastJson序列化Api
序列号:是指将java对象转成json格式化的过程javaBean对象List集合对象,Map集合，为应用最广泛。
JSON.toJSONString
序列化Java对象
pom.xml
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.83</version>
</dependency>最新
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.1</version>
</dependency>序列化
对象转JSON
String json = JSON.toJSONString(user); //序列化
List转JSON
String jsonString = JSON.toJSONString(list);
Map转JSON
JSONObject jsonObject = JSONObject.parseObject(JSON.toJSONString(maps)); 或者 String jsonString = JSON.toJSONString(map);
对象转JsonObject
//student对象,转为Object格式字符串
//调用静态方法,传递要转换的对象
JSONObject jsonObject=(JSONObject)JSON.toJSON(student);
//查看参数
jsonObject.getIntValue("id");
jsonObject.getString("name");
System.out.println(jsonObject);
System.out.println(jsonObject.getIntValue("id"));
System.out.println(jsonObject.getString("name"));反序列化
JSON 字符串转换为 Java 对象
User user =JSON.parseObject(json,User.class); //反序列化
JSON数组转List
//反序列化
//JSON类的静态对象parseObject
//传递要反序列化的JSON对象，传递转换后的集合的泛型的class对象
List<Student> listMaps = JSONArray.parseArray(JSON.toJSONString(list),Student.class);
List<Student> mapsList = JSONObject.parseArray(JSON.toJSONString(list), Student.class);
System.out.println(listMaps);
System.out.println(mapsList);
for (Student map : listMaps) {
System.out.println(map);
}
for (Student map : mapsList) {
System.out.println(map);
}JSON转Map
//反序列化1
Map<String,Object> maps = JSONObject.parseObject(jsonString,Map.class);
for (String key1 : maps.keySet()) {
System.out.println(key1+"::"+map.get(key1));
}
//JSON类的静态方法,parseObject
//直接进行反序列化,Map集合没有泛型的，泛型没有是不安全的集合
//转后的集合，必须有泛型
//调用parseObject传递参数TypeReference类型在TypeReference类的泛型传递转后的Map集合
Map<String, Student> map1 = JSON.parseObject(jsonString, new TypeReference<Map<String, Student>>() {
});
for (String key : map1.keySet()) {
System.out.println(key+"::"+map.get(key));
}JsonObject转对象
//反序列化
Student student1=JSON.toJavaObject(jsonObject, Student.class);
System.out.println(student1);扩展
JsonObject转JsonString(JSON)
String jsonString1=JSON.toJSONString(jsonObject);
JsonString转JsonObject
JSONObject jsonObject=JSON.parseObject(jsonString);
#查询
jsonObject.getString("Name");
JsonString转JsonArray
JSONArray jArray=JSON.parseArray(JSON.toJSONString(list));
JSONArray转String
String jsonString = jsonArray.toString();
fastjson2的使用
序列化
对象转JSON
String json = JSON.toJSONString(user); //序列化
List转JSON
String jsonString = JSON.toJSONString(list);
Map转JSON
JSONObject jsonObject = JSONObject.parseObject(JSON.toJSONString(maps)); 或者 String jsonString = JSON.toJSONString(map);
对象转JsonObject
//student对象,转为Object格式字符串
//调用静态方法,传递要转换的对象
JSONObject jsonObject=(JSONObject)JSON.toJSON(student);
//查看参数
jsonObject.getIntValue("id");
jsonObject.getString("name");
System.out.println(jsonObject);
System.out.println(jsonObject.getIntValue("id"));
System.out.println(jsonObject.getString("name"));反序列化
JSON 字符串转换为 Java 对象
User user =JSON.parseObject(json,User.class); //反序列化
JSON转Map
//JSON类的静态方法,parseObject
//直接进行反序列化,Map集合没有泛型的，泛型没有是不安全的集合
//转后的集合，必须有泛型
//调用parseObject传递参数TypeReference类型在TypeReference类的泛型传递转后的Map集合
JSONObject map1 = JSON.parseObject(jsonString);
for (String key : map1.keySet()) {
System.out.println(key+"::"+map.get(key));
}JsonObject转对象
//反序列化
Student student1=JSON.toJavaObject(jsonObject, Student.class);
System.out.println(student1);实体类
import lombok.Data;
import java.util.Date;
@Data
public class Student {
private Integer id;
private String name;
private Integer age;
private String email;
private Date birthday;
} 测试类
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.lianxi.cs.pojo.Student;
import org.junit.jupiter.api.Test;
import java.util.*;
public class TestFastJson {
public Date getDate(){
Date date = new Date();
return date;
}
@Test
//Java中的集合Map,序列化为Json格式字符串
void testMapToJson(){
//创建Map集合,健为字符串，值为Student对象
HashMap<String, Student> map = new HashMap<>();
Student student1 = new Student();
student1.setId(1);
student1.setName("张三");
student1.setAge(20);
student1.setEmail("[email protected]");
student1.setBirthday(getDate());
Student student2 = new Student();
student2.setId(2);
student2.setName("李四");
student2.setAge(25);
student2.setEmail("[email protected]");
student2.setBirthday(getDate());
//Student存到Map中
map.put("student",student1);
map.put("student2",student2);
JSONObject jsonObject = JSONObject.parseObject(JSON.toJSONString(map));
System.out.println(jsonObject);
String jsonString = JSON.toJSONString(map);
System.out.println(jsonString);
//jsonObject转jsonString
String jsonString1=JSON.toJSONString(jsonObject);
//json格式字符串是对象,对象中有两个健，健对应的值是Student对象
//反序列化1
Map<String,Object> maps = JSONObject.parseObject(jsonString1,Map.class);
for (String key1 : maps.keySet()) {
System.out.println(key1+"::"+map.get(key1));
}
//JSON类的静态方法,parseObject
//直接进行反序列化,Map集合没有泛型的，泛型没有是不安全的集合
//转后的集合，必须有泛型
//调用parseObject传递参数TypeReference类型在TypeReference类的泛型传递转后的Map集合
Map<String, Student> map1 = JSON.parseObject(jsonString, new TypeReference<Map<String, Student>>() {
});
for (String key : map1.keySet()) {
System.out.println(key+"::"+map.get(key));
}
}
@Test
//Java中的集合List,序列号为JSON格式字符串
void testListJson(){
//集合List，存储Student对象
ArrayList<Student> list = new ArrayList<>();
Student student1 = new Student();
student1.setId(1);
student1.setName("张三");
student1.setAge(20);
student1.setEmail("[email protected]");
student1.setBirthday(getDate());
Student student2 = new Student();
student2.setId(2);
student2.setName("李四");
student2.setAge(25);
student2.setEmail("[email protected]");
student2.setBirthday(getDate());
//Student存到List中
list.add(student1);
list.add(student2);
//List集合，序列化为Json格式字符串
String jsonString = JSON.toJSONString(list);
System.out.println(jsonString);
//反序列化
//JSON类的静态对象parseObject
//传递要反序列化的JSON对象，传递转换后的集合的泛型的class对象
List<Student> listMaps = JSONArray.parseArray(JSON.toJSONString(list),Student.class);
List<Student> mapsList = JSONObject.parseArray(JSON.toJSONString(list), Student.class);
System.out.println(listMaps);
System.out.println(mapsList);
for (Student map : listMaps) {
System.out.println(map);
}
for (Student map : mapsList) {
System.out.println(map);
}
List<Student> list1 = JSONObject.parseArray(jsonString, Student.class);
for (Student student : list1) {
System.out.println(student);
}
System.out.println(list1);
}
@Test
//Java中的对象，Student对象,序列化为JSON格式字符串
public void testObjectToJson(){
Student student = new Student();
student.setId(1);
student.setName("张三");
student.setAge(20);
student.setEmail("[email protected]");
student.setBirthday(getDate());
//student对象,转为JSON格式字符串
//调用静态方法,传递要转换的对象
String jsonString = JSON.toJSONString(student);
System.out.println(jsonString);
//{"age":20,"birthday":1657462817623,"email":"[email protected]","id":1,"name":"张三"}
//反序列化
//JSON类的静态对象parseObject
//传递要反序列化的JSON对象，传递JAVA对象的class对象
Student student1 =JSON.parseObject(jsonString,Student.class);
System.out.println(student1);
}
@Test
//Java中的对象，Student对象,序列化为Object格式字符串
public void testObjectToObject(){
Student student = new Student();
student.setId(1);
student.setName("张三");
student.setAge(20);
student.setEmail("[email protected]");
student.setBirthday(getDate());
//student对象,转为Object格式字符串
//调用静态方法,传递要转换的对象
JSONObject jsonObject=(JSONObject)JSON.toJSON(student);
//查看参数
jsonObject.getIntValue("id");
jsonObject.getString("name");
System.out.println(jsonObject);
System.out.println(jsonObject.getIntValue("id"));
System.out.println(jsonObject.getString("name"));
//反序列化
Student student1=JSON.toJavaObject(jsonObject, Student.class);
System.out.println(student1);
}
}SerializerFeature枚举
TestFastJson2
package com.lianxi.cs;
/*
* SerializerFeature枚举:进行序列化时候，可以自己定义特殊需求
* JSON静态方法:toJSONString()
* 方法的参数:第一个是要序列化的对象
* 方法的参数:第二个参数 枚举类型的可变参数
* SerializerFeature枚举的常量,做序列化的个性需求
* */
public class TestFastJson2 {
}枚举常量WriteMapNullValue序列化为null的字段
//方法的参数上，添加枚举类型
String jsonString = JSON.toJSONString(student, SerializerFeature.WriteMapNullValue);
枚举常量WriteNullStringAsEmpty字段为null序列化为""
String jsonString = JSON.toJSONString(student, SerializerFeature.WriteNullStringAsEmpty);
枚举常量WriteNullNumberAsZero字段为null序列化为0
String jsonString = JSON.toJSONString(student, SerializerFeature.WriteNullNumberAsZero);
枚举常量WriteNullBooleanAsFalse字段null输出false
String jsonString = JSON.toJSONString(student, SerializerFeature.WriteNullBooleanAsFalse);
枚举常量WriteDateUseDateFormat格式化日期格式
String jsonString = JSON.toJSONString(student, SerializerFeature.WriteDateUseDateFormat);
枚举常量PrettyFormat格式化输出
String jsonString = JSON.toJSONString(student, SerializerFeature.PrettyFormat);
JSonFieId注解的使用
/**
*@JSonFleId注解
*该注解作用于方法上,字段上和参数上，可在序列化和反序列化时候进行特性功能定制
*JSONFieId注解属性name,指定序列化后的名字
*注解属性ordina序列化后的顺序 值越小属性越靠前
*注解属性format序列化后的格式
*注解属性serialize是否序列化该字段
*注解属性deserialize是否反序列化该字段
*注解属性SerialzeFeatures序列化时的特性定义
**/
//JSONFieId注解属性name,指定序列化后的名字
@JSONFieId(name="studentName")
private String name;
输入后字段为studentName
//注解属性format序列化后的格式
@JSONFieId(format="yyyy-MM-dd")
private Date birthday;
//注解属性serialize是否反序列化该字段
@JSONFieId(serialize="true")
private String email;
//注解属性deserialize是否反序列化该字段
@JSONFieId(deserialize="true")
private String email;JsonType注解
/**
*@JSonType注解
*改注解作用于类上，对该类的字段进行序列化和反序列化时的特性功能定制
*注解属性:include要被序列化的字段
*注解属性:orders序列化后的顺序
*注解属性:serialzeFeatures序列化时候的特性定义
*
*
*
**/
@JSONType(includes={"id","name","age","address"},orders={"name","age","id","address"})JSONArray转List对象
List<DataLastEntity> dataArr = JSONArray.parseArray(arr, DataLastEntity.class);
实体类如下:
