FastJson入门学习

JSON数据格式

什么是JSON

JSON（JavaScript Object Notation, JS对象简谱）是一种轻量级的数据交换格式。它基于 ECMAScript（European Computer Manufacturers Association, 欧洲计算机协会制定的js规范）的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

JSON数组格式

Json的数据本身是数组，中括号包裹，数组的元素之间逗号分开，数组元素的数据类型没有限制。

?
1
2
3
4
5
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　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<!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，对象采用键值对形式进行存储，健固定为字符串类型，值是任意类型的数据，健和值使用冒号分开

例如

?
1
2
var jsonObject={"k1":"v1","k2":"v2","k3":100,"k4":9.9,"k5":true};//定义对象格式json
       console.log(jsonObject.k1);//取出键k1对应的值

　 测试jsonObject.html

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<!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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<!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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<!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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<!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十分简洁。

?
1
2
String text = JSON.toJSONString(obj); //序列化
VO vo = JSON.parseObject("{...}", VO.class); //反序列化
 功能完备

支持泛型，支持流处理超大文本，支持枚举，支持序列化和反序列化扩展。

FastJson序列化Api

序列号:是指将java对象转成json格式化的过程javaBean对象List集合对象,Map集合，为应用最广泛。

JSON.toJSONString

序列化Java对象

pom.xml

?
1
2
3
4
5
<dependency>
         <groupId>com.alibaba</groupId>
         <artifactId>fastjson</artifactId>
         <version>1.2.83</version>
     </dependency>

最新

?
1
2
3
4
5
<dependency>
 <groupId>com.alibaba.fastjson2</groupId>
 <artifactId>fastjson2</artifactId>
 <version>2.0.1</version>
</dependency>

序列化

对象转JSON
?
1
String json = JSON.toJSONString(user); //序列化　　
List转JSON
?
1
String jsonString = JSON.toJSONString(list);
Map转JSON　　
?
1
JSONObject jsonObject = JSONObject.parseObject(JSON.toJSONString(maps));<br>或者<br>String jsonString = JSON.toJSONString(map);
对象转JsonObject
?
1
2
3
4
5
6
7
8
9
//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 对象
?
1
User user =JSON.parseObject(json,User.class); //反序列化
　JSON数组转List
?
1
2
3
4
5
6
7
8
9
10
11
12
13
//反序列化
//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
2
3
4
5
6
7
8
9
10
11
12
13
14
//反序列化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转对象
?
1
2
3
//反序列化
Student student1=JSON.toJavaObject(jsonObject, Student.class);
System.out.println(student1);

　扩展

　JsonObject转JsonString(JSON)
?
1
String jsonString1=JSON.toJSONString(jsonObject);
JsonString转JsonObject
?
1
2
3
JSONObject jsonObject=JSON.parseObject(jsonString);
#查询
jsonObject.getString("Name");
JsonString转JsonArray
?
1
JSONArray jArray=JSON.parseArray(JSON.toJSONString(list));
JSONArray转String 　
?
1
String jsonString = jsonArray.toString();

fastjson2的使用　

序列化

对象转JSON
?
1
String json = JSON.toJSONString(user); //序列化　　
List转JSON
?
1
String jsonString = JSON.toJSONString(list);
Map转JSON　　
?
1
JSONObject jsonObject = JSONObject.parseObject(JSON.toJSONString(maps));<br>或者<br>String jsonString = JSON.toJSONString(map);
对象转JsonObject
?
1
2
3
4
5
6
7
8
9
//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 对象
?
1
User user =JSON.parseObject(json,User.class); //反序列化
　JSON转Map　
?
1
2
3
4
5
6
7
8
//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转对象
?
1
2
3
//反序列化
Student student1=JSON.toJavaObject(jsonObject, Student.class);
System.out.println(student1);

实体类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
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;
 
}　
?
1
测试类
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
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("zs@163.com");
        student1.setBirthday(getDate());
        Student student2 = new Student();
        student2.setId(2);
        student2.setName("李四");
        student2.setAge(25);
        student2.setEmail("ls@163.com");
        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("zs@163.com");
        student1.setBirthday(getDate());
        Student student2 = new Student();
        student2.setId(2);
        student2.setName("李四");
        student2.setAge(25);
        student2.setEmail("ls@163.com");
        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("zs@163.com");
        student.setBirthday(getDate());
        //student对象,转为JSON格式字符串
        //调用静态方法,传递要转换的对象
        String jsonString = JSON.toJSONString(student);
        System.out.println(jsonString);
        //{"age":20,"birthday":1657462817623,"email":"zs@163.com","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("zs@163.com");
        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
?
1
2
3
4
5
6
7
8
9
10
11
package com.lianxi.cs;
 
/*
* SerializerFeature枚举:进行序列化时候，可以自己定义特殊需求
* JSON静态方法:toJSONString()
* 方法的参数:第一个是要序列化的对象
* 方法的参数:第二个参数 枚举类型的可变参数
* SerializerFeature枚举的常量,做序列化的个性需求
* */
public class TestFastJson2 {
}

枚举常量WriteMapNullValue序列化为null的字段

?
1
2
//方法的参数上，添加枚举类型
     String jsonString = JSON.toJSONString(student, SerializerFeature.WriteMapNullValue);

枚举常量WriteNullStringAsEmpty字段为null序列化为""

?
1
String jsonString = JSON.toJSONString(student, SerializerFeature.WriteNullStringAsEmpty);

枚举常量WriteNullNumberAsZero字段为null序列化为0

?
1
String jsonString = JSON.toJSONString(student, SerializerFeature.WriteNullNumberAsZero);

 

枚举常量WriteNullBooleanAsFalse字段null输出false

?
1
String jsonString = JSON.toJSONString(student, SerializerFeature.WriteNullBooleanAsFalse);

枚举常量WriteDateUseDateFormat格式化日期格式

?
1
String jsonString = JSON.toJSONString(student, SerializerFeature.WriteDateUseDateFormat);

枚举常量PrettyFormat格式化输出

?
1
String jsonString = JSON.toJSONString(student, SerializerFeature.PrettyFormat);

JSonFieId注解的使用　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
*@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;
<br>//注解属性serialize是否反序列化该字段
@JSONFieId(serialize="true")
private String email;<br>
//注解属性deserialize是否反序列化该字段
@JSONFieId(deserialize="true")
private String email;

JsonType注解

?
1
2
3
4
5
6
7
8
9
10
/**
*@JSonType注解
*改注解作用于类上，对该类的字段进行序列化和反序列化时的特性功能定制
*注解属性:include要被序列化的字段
*注解属性:orders序列化后的顺序
*注解属性:serialzeFeatures序列化时候的特性定义
*
*
*
**/<br>@JSONType(includes={"id","name","age","address"},orders={"name","age","id","address"})

　　

　　

 

 

 

 

 

 

 

 

 

 

 

　　

　　

　

 

 

 

 

 

　　

 

posted @   永远爱芒果  阅读(211)  评论(0)  编辑  收藏  举报
相关博文：
·  Redis入门学习(二)的reids基本类型的学习
·  redis学习(三)之Jedis操作CRUD
·  fastjson
·  java FastJson的使用总结
·  Json基础--FastJson常用几个方法和枚举类
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 【译】Visual Studio 中新的强大生产力特性
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
点击右上角即可分享
微信分享提示
SQL AI 助手