Json介绍

1. 什么是 JSON？

JSON:JavaScript Object Notation(JavaScript 对象标记法)。

JSON是一种轻量级的数据交换格式，具有自我描述性且易于理解,等同于Java对象,Java的对象就是自我描述性,例如:id,name,age,gender这些属性用于描述学生；JSON独立于语言,它不属于任何一门编程语言,它是独立的。

JSON是一种存储和交换数据的语法，JSON格式是纯文本的，主要用来进行交换数据，当数据在浏览器与服务器之间进行数据交换时,这些交换的数据只能是文本，JSON文本可被任何编程语言作为数据来读取和使用

JSON属于文本,并且我们能够把任何Java对象转换为JSON字符串,然后将JSON字符串数据发送到浏览器,或其他应用服务器程序

2. JSON语法格式

JSON语法格式非常严格,支持的数据类型也比较多,例如:字符串,数值,布尔等待,JSON是没有注释的
JSON中的语法符号分别为:双引号,冒号,逗号,中括号,大括号这些符号不可省略不可替换
JSON的格式是key:value,key值必须带有双引号,value值如果是数值或布尔则可以不使用
JSON的格式分为两大类:1. 大括号代表对象类型,2. 中括号代表数组集合类型,这两种类型可以组合使用

1. 表示对象的大括号`{}`:用于表示某个对象,值为`key:value`格式
{
    "key1":value1,
    "key2":value2,
    "key3":value3,
    "key4":value4
}
2. 表示数组集合的中括号`[]`:用于表示某个对象的集合或数据集合,值为`大括号对象或普通数据集`
[
    {
        "key1":value1,
        "key2":value2,
        "key3":value3,
        "key4":value4
    },
    {
        "key1":value1,
        "key2":value2,
        "key3":value3,
        "key4":value4
    },
    {
        "key1":value1,
        "key2":value2,
        "key3":value3,
        "key4":value4
    }
]
[
    value1,
    value2,
    value3,
    value4
]
3. 对象与数组集合混合使用:对象中可以包含数组集合,同样数组集合也可以包含对象类型,以及数组集合与对象类型相互嵌套
[
    {
        "key1":value1,
        "key2":value2,
        "key3":value3,
        "key4":[
                  "key1":value1,
        		  "key2":value2,
        	 	  "key3":value3,
        		  "key4":value4
                ]
    },
    {
        "key1":value1,
        "key2":value2,
        "key3":value3,
        "key4":[
                    "value1",
                    "value2",
                    "value3",
                    "value4"
                ]
    }
]
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

3. JSON在Java中的用途

JSON在Java中的作用就是用于数据格式的交换,例如Javaweb中的前后端数据的交互,并且JSON在任何一门编程语言中都是用于数据格式的交换的,他以轻量级以及简单易理解著名，除了在Javaweb中交互还可以与其他语言交互,使用JSON作为数据交换格式,例如:Java与C语言或C++或Python等等进行交互，JSON在Java中属于纯文本(字符串),但是也可被称为JSON对象或JSON字符串。

JSON解析是指在Java中将对象序列化为JSON字符串,或将JSON字符串反序列化为Java对象,也就是对于Java和JSON的互换，JSON解析同样需要使用第三方jar包,jar包有很多种类型,例如:阿里巴巴的FastJson,Apache的Jackson,谷歌的GSON等等。

3.1 FastJSON

1. FastJSON概述与下载

JSON解析之FastJSON是阿里巴巴提供的,目前有两个版本,1.x版本与2.x版本
maven地址:https://mvnrepository.com/
FastJSON下载地址1.x版本:https://repo1.maven.org/maven2/com/alibaba/fastjson/1.2.83/fastjson-1.2.83.jar
FastJSON下载地址2.x版本:https://repo1.maven.org/maven2/com/alibaba/fastjson2/fastjson2/2.0.21/fastjson2-2.0.21.jar
将下载好的jar包导入到idea中,并Add as Library解压

2. FastJSON常用方法

FastJSON提供固定工具类JSON类,类中定义了简单的静态方法,用于将Java对象转JSON字符串,以及将JSON字符串转Java对象

1. public static String toJSONString(Object object):将Java对象转为JSON字符串,返回JSON字符串
   1. object:需要转换的Java对象
2. public static <T> T parseObject(String text, Class<T> clazz):将JSON字符串转为Java对象,返回Java对象
   1. text:JSON字符串
   2. clazz:Java对象类型,类名.class
3. public static <T> List<T> parseArray(String text, Class<T> clazz):将JSON数组集合转为Java集合对象,返回Java集合对象
   1. text:JSON字符串
   2. clazz:Java对象类型,类名.class

 public static void main(String[] args) throws IOException {
        Student student = new Student("张三", "男", 18);
        String json = JSON.toJSONString(student);
        System.out.println("对象转json:"+json);
        FileOutputStream fos = new FileOutputStream("demo.json");
        fos.write(json.getBytes());
        Student parse =JSON.parseObject(json,Student.class);
        System.out.println("json转对象:"+parse);
        System.out.println(parse.getName());
        System.out.println("================");
        ArrayList<Object> list = new ArrayList<>();
        list.add(new Student("张三","男",19));
        list.add(new Student("张","男",20));
        list.add(new Student("三","男",21));
        list.add(new Student("章","男",22));
        String jsonString = JSON.toJSONString(list);
        System.out.println("列表对象转Json："+jsonString);
        fos.write(jsonString.getBytes());
        List<Student> parseObject = JSON.parseArray(jsonString, Student.class);
        System.out.println("Json转列表:"+parseObject.get(3));
        System.out.println("Json转列表:"+parseObject.get(3).getName());
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3. JSONObject获取Json中的指定字符

  HashMap<String, Object> zhangsan = new HashMap<>();
        zhangsan.put("name", "张三");
        zhangsan.put("age", 18.4);
        zhangsan.put("birthday", "1900-20-03");
        zhangsan.put("null", null);
        zhangsan.put("house", false);
        JSONObject jsonObject = new JSONObject(zhangsan);
        System.out.println(jsonObject);
        System.out.println(jsonObject.getString("age"));
1
2
3
4
5
6
7
8
9

3.2. Jackson

Jackson是Apache软件基金会(致力于服务万千程序)正在维护的开源的JSON解析工具包
Jackson的使用较为复杂,但是Jackson更加安全,也是目前较为广泛的解析工具
Jackson是后期SpringMVC框架中推荐使用的JSON解析工具包(默认使用的也是Jackson)

1. Jackson下载与使用

Jackson一共分为三个jar包而且必须全部下载,其中带有依赖项,如果缺少会造成程序的报错
jackson-core:https://repo1.maven.org/maven2/com/fasterxml/jackson/core/jackson-core/2.14.1/jackson-core-2.14.1.jar
jackson-databind:https://repo1.maven.org/maven2/com/fasterxml/jackson/core/jackson-databind/2.14.1/jackson-databind-2.14.1.jar
jackson-annotation:https://repo1.maven.org/maven2/com/fasterxml/jackson/core/jackson-annotations/2.14.1/jackson-annotations-2.14.1.jar
将下载好的三个包导入到idea的lib目录并Add as Library

2. Jackson常用类与方法

Jackson中使用Java与JSON互转需要使用的类ObjectMapper类,其中提供了N多操作JSON的方法
ObjectMapper类不是静态的,所以需要创建对象.

public ObjectMapper():用于创建ObjectMapper对象

3. ObjectMapper类常用方法

1. public String writeValueAsString(Object value):将Java对象转为JSON字符串
2. public <T> T readValue(String content, Class<T> valueType):将JSON字符串转为Java对象
3. public void writeValue(File resultFile, Object value):将Java对象转为JSON字符串并写入到文件
4. public <T> T readValue(File src, Class<T> valueType):读取文件中的JSON字符串转为Java对象
5. public void writeValue(Writer w, Object value):将Java对象转为JSON字符串并写入到文件
6. public <T> T readValue(Reader src, Class<T> valueType):读取文件中的JSON字符串转为Java对象
7. public void writeValue(OutputStream out, Object value):将Java对象转为JSON字符串并写入到文件
8. public <T> T readValue(InputStream src, Class<T> valueType):读取文件中的JSON字符串转为Java对象

    public static void main(String[] args) throws JsonProcessingException {
        // 创建Student对象
        Student student = new Student( "彭于晏", "男", 18);
        // 创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        // 将Java对象转为JSON字符串
        String jsonString = mapper.writeValueAsString(student);
        System.out.println("jsonString = " + jsonString);
        // 将JSON字符串转为Java对象
        Student student1 = mapper.readValue(jsonString,Student.class);
        System.out.println("student1 = " + student1);
        System.out.println(student1.getName());

        // 创建List集合转换
        // 创建集合对象
        List<Student> students = new ArrayList<>();
        // 添加数据
        students.add(new Student("彭于晏1", "男", 18));
        students.add(new Student( "彭于晏2", "男", 18));
        students.add(new Student( "彭于晏3", "男", 18));
        students.add(new Student("彭于晏4", "男", 18));
        students.add(new Student( "彭于晏5", "男", 18));
        // List集合转为JSON字符串
        jsonString = mapper.writeValueAsString(students);
        System.out.println("jsonString = " + jsonString);

        // 将JSON数字集合转为Java对象,可以转为数组
        Student[] students1 = mapper.readValue(jsonString, Student[].class);
        System.out.println("Arrays.toString(students1) = " + Arrays.toString(students1));
        // 转为Java集合对象
        List<Student> students2 = mapper.readValue(jsonString, new TypeReference<List<Student>>() {
        });
        System.out.println("students2 = " + students2);
        System.out.println(students2.get(0));
        System.out.println(students2.get(0).getName());
    }
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