JSON在Java中的使用

目录

• 第一章、快速了解JSON
• • 1.1）JSON是什么
  • 1.2）json的语法格式
  • • ①键值对、字符串、数字、布尔值、数组、对象
    • ②嵌套的格式
    • 1.3）为什么使用JSON
    • 第二章、发送和接收JSON格式数据
    • • 2.1）postman发送JSON格式数据
      • 2.2）Java后端接收数据
      • • 2.2.1）后端不写任何注解情况下接收参数
        • 情况A:后端不写注解postman发出get请求
        • 情况B:后端不写注解postman发出post请求
        • • 2.2.2）后端写@RequestParam注解接收参数
          • 情况A:postman发出post请求
          • 情况B:postman发出get请求
          • • 2.2.3）后端写@RequestBody注解接收参数
            • 情况A:postman发出post请求
            • 情况B:postman发出get请求
            • • • @RequestParam和@RequestBody总结
                • 第三章、JSON与其他格式数据的互相转换
                • • 3.1）JSON使用的第三方包：Jackson
                  • 3.2）其他数据转为JSON格式数据（生成JSON）
                  • • ①对象转json，比如我有一个user对象
                    • 3.3）JSON格式数据转为其他数据(解析JSON)
                    • • ①json字符串信息 写入（转为） 对象
                      • ②将JSON文件转为对象
                      • ③字节输入流读取json文件后，再转为对象
                      • ④JSON字符串 转为 Map
                      • ⑤复杂JSON（json数组中有多个对象） 转为 对象数组
                      • ⑤复杂JSON（json数组中有多个对象） 转为List
                      • 3.4）忽略不存在的字段
                      • 3.5）使用jackson进行日期格式化
                      • 3.6）Jackson注解
                      • • ①@JsonIgnore
                        • ②@JsonGetter
                        • ③@JsonSetter

                          友情提醒:

                          先看文章目录，大致了解文章知识点结构，点击文章目录可直接跳转到文章指定位置。

                          第一章、快速了解JSON

                          1.1）JSON是什么

                          ①JSON简单介绍

                          一种轻量级的数据交换格式，采用键值对的方式表示数据。常用于 Web 应用程序中的数据传输。

                          PS：JSON格式可以使用一些转义字符。

                          ②json格式：

                          在这六个构造字符的前或后允许存在无意义的空白符

                          [ 左方括号{ 左大括号] 右方括号} 右大括号: 冒号, 逗号

                          ③JSON的键和值

                          1、JSON 的键是一个 String 类型的字符串。字符串必须使用双引号""

                          2、值（value）：值可以是对象、数组、数字、字符串、布尔值或null。JSON支持复杂的数据结构，可以嵌套对象和数组。

                          1.2）json的语法格式

                          ①键值对、字符串、数字、布尔值、数组、对象

                          {"name":"John"}   //键值对"Hello, World!"   //字符串123或3.14   //数字：整数或浮点数true或false       //布尔值[1, 2, 3, 4, 5]   //数组结构{"name": "John","age": 30,"city": "New York"}   //对象结构

                          ②嵌套的格式

                          1、对象中有对象

                          {"name": "John","age": 30,"address": {"street": "123 Main St","city": "New York"}}

                          传输测试：

                          2、多个对象在数组中

                          [{"name": "John","age": 30},{"name": "Jane","age": 25}]

                          传输测试

                          3、对象中包含数组结构，和对象属性

                          {    "id":1,    "name":"张三",    "age":18,    "job":{        "jobName":"Java开发",        "company":"某知名大厂"    },    "nickName":[        "张三",        "法外狂徒",        "传奇人物"    ]}

                          传输测试

                          1.3）为什么使用JSON

                          ①为什么使用

                          JSON具有简洁性，可读性，跨语言支持，数据结构灵活，数据传输效率高的特点。

                          ②使用场景

                          ①前后端数据交互：将服务器端的数据以 JSON 格式发送给前端，前端再使用 JavaScript 解析JSON数据后再展示和处理。

                          ②API接口设计：使用 JSON 作为数据交换格式。通过将数据以 JSON 格式发送到 API 接口，可以实现数据的传输和交互。

                          ③数据存储：将数据序列化为 JSON 格式后存储在文件或数据库中，并在需要时重新解析为对象。

                          ④日志记录：将复杂的结构化数据以 JSON 格式记录下来。

                          ⑤配置文件：JSON可以用于表示配置文件，例如Web应用程序的配置信息。

                          第二章、发送和接收JSON格式数据

                          2.1）postman发送JSON格式数据

                          比较简单直接查看这个文章就好了：

                          postman的下载安装和使用

                          2.2）Java后端接收数据

                          注意：后端接收参数大概四种情况：

                          ①不写任何注解

                          ②写@RequestParam注解，多个@RequestParam注解

                          ③写@RequestBody

                          ④写@RequestParam注解同时又写@RequestBody

                          2.2.1）后端不写任何注解情况下接收参数

                          情况A:后端不写注解postman发出get请求

                          ①后端参数类型为Integer，发送参数String “1”，结论接收成功

                          ②后端参数类型为String，发送参数为String “1”，结论接收成功

                          ③后端参数类型为一个Integer，一个String。发送参数方式为form-data 为key(pid) value(1)，key(eid) value(“1”)，结论接收成功

                          ④后端参数类型为一个Integer，一个String，发送参数方式为JSON{“eid”:“1”,“pid”:1} ，结论接受到的俩个值为NULL值

                          postman页面

                          ⑤后端参数类型为一个数组，接收多个同名参数，结论接收成功

                          postman页面

                          ⑥后端参数类型为map，接收多个不同名参数，结论失败

                          postmanye页面

                          ⑦后端参数类型为一个实体类，发送参数方式为JSON{“eid”:“1”,“pid”:1} ，结论对象参数的属性值为null

                          postman页面

                          情况B:后端不写注解postman发出post请求

                          ①后端参数类型为Integer，发送参数为String “1”，结论接收成功

                          ②后端参数类型为String，发送参数为String “1”，结论接收成功

                          ③后端参数类型为一个Integer，一个String。发送参数方式为form-data 为key(pid) value(1)，key(eid) value(“1”)，结论接收成功

                          ④后端参数类型为一个Integer，一个String，发送参数方式为JSON{“eid”:“1”,“pid”:1} ，结论失败，两个值为NULL值

                          ⑤后端参数类型为一个数组，接收多个同名参数，结论接收成功

                          ⑥后端参数类型为map，接收多个不同名参数，结论失败

                          ⑦后端参数类型为一个实体类，发送参数方式为JSON{“eid”:“1”,“pid”:1} ，结论失败，对象参数的属性值为null

                          2.2.2）后端写@RequestParam注解接收参数

                          情况A:postman发出post请求

                          ①后端参数类型为Integer，发送参数为String “1”，结论接收成功

                          ②后端参数类型为String，发送参数为String “1”，结论接收成功

                          ③后端参数类型为一个Integer，一个String。发送参数方式为form-data 为key(pid) value(1)，key(eid) value(“1”)，结论接收成功

                          ④后端参数类型为一个Integer，一个String，发送参数方式为JSON{“eid”:“1”,“pid”:1} ，结论失败bad request

                          ⑤后端参数类型为一个数组，接收多个同名参数，结论接收成功

                          注意：不同名的不会存入

                          请求：

                          如果传递的三个参数有两个与数组参数同名会存入数组，不同名的则不会被存入数组

                          传参：两个与数组参数同名，一个不同名

                          ⑥使用Map去接收请求参数，接收成功

                          postman请求：

                          ⑦后端参数类型为一个实体类，发送参数方式为JSON{“eid”:“1”,“pid”:1} ，结论失败，Bad Request

                          @RequestParam不能注解实体类参数

                          postman页面

                          情况B:postman发出get请求

                          ①后端参数类型为Integer，发送参数为String “1”，结论接收成功

                          ②后端参数类型为String，发送参数为String “1”，结论接收成功

                          ③后端参数类型为一个Integer，一个String。发送参数方式为form-data 为key(pid) value(1)，key(eid) value(“1”)，结论接收成功

                          ④后端参数类型为一个Integer，一个String，发送参数方式为JSON{“eid”:“1”,“pid”:1} ，结论失败bad request

                          ⑤后端参数类型为一个数组，接收多个同名参数，结论接收成功

                          不同名的不会存入

                          ⑥后端参数类型为map，接收多个不同名参数，结论成功

                          ⑦后端参数类型为一个实体类，发送参数方式为JSON{“eid”:“1”,“pid”:1} ，结论失败，Bad Request

                          @RequestParam不能注解实体类参数

                          2.2.3）后端写@RequestBody注解接收参数

                          @RequestBody（只能接收JSON字符串）

                          情况A:postman发出post请求

                          ①后端参数是Integer，传参数是数字 1 ，结论成功。

                          json的value为" " ：后端对应属性是String类型的，那么接受到的就是" "，如果后端属性的类型是Integer、Double等，那么接收到的就是null。

                          json的value为null：后端对应收到的就是null。

                          ②后端参数是String，传参数是字符串 1，结论成功

                          ③后端参数是Integer，传参数是json {“eid”:1}，结论失败 bad request

                          ④后端参数是一个简单对象，发送参数方式为JSON{“eid”:“1”,“pid”:1}

                          会根据json字符串中的key来匹配对应实体类的属性，如果匹配一致且key对应的值符合实体类对应属性的类型要求时,会调用实体类的setter方法将值赋给该属性。

                          postman页面

                          ⑥@RequestBody与@RequestParam()同时使用：

                          Controller：

                          postman页面：

                          情况B:postman发出get请求

                          @RequestBody主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的)；而最常用的使用请求体传参的无疑是POST请求了，所以使用@RequestBody接收数据时，一般都用POST方式进行提交。

                          @RequestParam和@RequestBody总结

                          ①@RequestParam用来绑定查询参数(也就是在URL上的参数)和from data(也就是请求体，对应postman中的 from-data)。发起请求时在URL上和使用from data传参都可以使用 @RequestParam来接收。

                          ②@RequestParam将接收到的字符串自动转化为对应的类型

                          ③@RequestParam不支持直接传递实体类的方式，可接收Map和数组，可接收单个参数。

                          ④@RequestParam注解的属性

                          1、如果参数前写了@RequestParam(xxx)，那么前端发送的请求路径中必须有对应的xxx参数才行

                          2、value：请求中传入参数的名称，如果不设置后台接口的value值，则会默认为该变量名。

                          3、name:作用同value相同

                          4、required：表示请求中一定要传入对应的参数，如果设置为false时，当请求中没有此参数，将会默认为null

                          5、defaultValue：参数的默认值，如果请求中没有同名的参数时，该变量默认为此值。注意默认值可以使用SpEL表达式，如"#{systemProperties[‘java.vm.version’]}"

                          @RequestParam(value = "参数名",required = false,defaultValue = "12")

                          ⑤一个请求中@RequestBody最多只能有一个，而@RequestParam()可以有多个。它们可以同时使用。

                          ⑥@RequestParam指定接收的参数可以是普通元素、数组、集合、对象等等，@RequestBody接收的是请求体里面的数据

                          ⑦如果参数是放在请求体中，以application/json的格式传入后台接口，那么后台要@RequestBody才能接收到；如果不是放在请求体中的话要用@RequestParam来接收，或者在形参前不贴@RequestParam注解也能接收。

                          ⑧feign或者openfeign远程调用服务时，如果参数前什么也不写，那么会被默认是@RequestBody。

                          第三章、JSON与其他格式数据的互相转换

                          3.1）JSON使用的第三方包：Jackson

                          将不同的数据格式与JSON格式进行转换需要依赖第三方包

                          JSON      //json官方提供的FastJson  //阿里巴巴提供Jackson   //springboot启动包自带GSON      //Google提供的hutool json   //hutool 工具

                          第三方包有很多，选择一种就好了，这里选择Jackson

                          ①导入依赖

                          Jackson 解析JSON，SpringMVC内置的解析器就是这个

                          spring-boot-starter-web启动包内嵌了Jackson 依赖

                                org.springframework.boot      spring-boot-starter-web      2.7.16    

                          或者也可以自己导入依赖包

                          maven依赖:

                            com.fasterxml.jackson.core  jackson-core  2.9.6  com.fasterxml.jackson.core  jackson-annotations  2.9.6  com.fasterxml.jackson.core  jackson-databind  2.9.6

                          ②Jackson包中ObjectMapper类介绍

                          1、常用方法1：readValue() 方法可以进行 JSON 的反序列化操作，就是将其他格式数转为Java对象

                          2、常用方法2：writeValue() 方法可以进行 JSON 的序列化操作，就是将 Java 对象转换成 JSON 字符串

                          ③转义字符介绍介绍

                          Java中看到的JSON字符经常带有斜杠，其实是转义符，例如：

                          \r  将光标定位到当前行的开头，不会跳到下一行。\n  换到下一行的开头。\t  制表符，将光标移到下一个制表符的位置，就像在文档中用Tab键一样。\  表示反斜杠字符，由于在Java代码中的反斜杠（＼）是转义字符，多加一个反斜杠就代表其本身

                          \"表示双引号字符，Java代码中双引号表示字符串的开始和结束，包含在字符串中的双引号需要使用 \ 进行转义

                          String str = "{\"name\":\"bbb\",\"id\":\"1234\"}"其实是 str = {"name":"bbb","id":"1234"}

                          3.2）其他数据转为JSON格式数据（生成JSON）

                          首先我有个User类

                          package com.test.springboot.model;public class User {        private String name;        private int age;        private List skillsList;//省略getter setter toString

                          ①对象转json，比如我有一个user对象

                          使用方法：objectMapper.writeValueAsString(类名);

                              public static void objectToJson() {        User user = new User();        user.setName("bbb");        user.setAge(18);        user.setSkillsList(Arrays.asList("java", "python"));        // 创建ObjectMapper对象        ObjectMapper objectMapper = new ObjectMapper();        String json = null;        try {            // 将对象转换为JSON字符串            json = objectMapper.writeValueAsString(user);        } catch (JsonProcessingException e) {            e.printStackTrace();        }        //{"name":"bbb","age":18,"skillsList":["java","python"]}        System.out.println(json);    }

                          3.3）JSON格式数据转为其他数据(解析JSON)

                          ①json字符串信息 写入（转为） 对象

                          首先我有个User类

                          package com.test.springboot.model;public class User {        private String name;        private int age;        private List skillsList;//省略getter setter toString

                          使用objectMapper.readValue(json, User.class);方法，前面传入json字符串，后面是类

                           //json字符串信息 写入（转为） 对象    public static void jsonToObject(){        String json = "{\"name\":\"bbb\",\"age\":18,\"skillsList\":[\"java\",\"python\",\"php\"]}";        ObjectMapper objectMapper = new ObjectMapper();        User user = null;        try {            user = objectMapper.readValue(json, User.class);        } catch (JsonProcessingException e) {            e.printStackTrace();        }        //User(name=bbb, age=18, skillsList=[java, python, php])        System.out.println(user);        //{"name":"bbb","age":18,"skillsList":["java","python","php"]}        System.out.println(json);    }

                          ②将JSON文件转为对象

                          001-test/src下新建json文件，内容如下

                          {  "name" : "bbb",  "age" : 18,  "skillsList" : [    "java",    "python"  ]}

                          如图：

                          使用readValue方法

                          public static void jsonFileToObject() {        File file = new File("001-test/src/test.json");        ObjectMapper objectMapper = new ObjectMapper();        User user = null;        try {            user = objectMapper.readValue(file, User.class);        } catch (IOException e) {            e.printStackTrace();        }        //User(name=bbb, age=18, skillsList=[java, python])        System.out.println(user);    }

                          ③字节输入流读取json文件后，再转为对象

                              //通过字节输入流FileInputStream 读取json文件后，再转为对象    public static void jsonFileInputStrToObject() {        FileInputStream input = null;        try {            input = new FileInputStream("001-test/src/test.json");        } catch (FileNotFoundException e) {            e.printStackTrace();        }        ObjectMapper objectMapper = new ObjectMapper();        User user = null;        try {            user = objectMapper.readValue(input, User.class);        } catch (IOException e) {            e.printStackTrace();        }        //User{name='bbb', age=18, skillsList=[java, python]}        System.out.println(user);    }

                          ④JSON字符串 转为 Map

                             //JSON字符串 转为 Map    public static void jsonToMap() {        String json = "{\"name\":\"bbb\",\"age\":18,\"skillsList\":[\"java\",\"python\",\"php\"]}";        ObjectMapper objectMapper = new ObjectMapper();        Map objectMap = null;        try {            objectMap = objectMapper.readValue(json, new TypeReference() {            });        } catch (JsonProcessingException e) {            e.printStackTrace();        }        //{name=bbb, age=18, skillsList=[java, python, php]}        System.out.println(objectMap);        //bbb        System.out.println(objectMap.get("name"));    }

                          ⑤复杂JSON（json数组中有多个对象） 转为 对象数组

                          readValue方法

                              public static void jsonArrToObject() {        String json = "[{\"name\":\"bbb\",\"age\":18,\"skillsList\":[\"java\",\"python\"]}," +                "{\"name\":\"aaa\",\"age\":15,\"skillsList\":[\"唱跳\",\"rap\"]}]";        ObjectMapper objectMapper = new ObjectMapper();        User[] user = new User[0];        try {            user = objectMapper.readValue(json, User[].class);        } catch (JsonProcessingException e) {            e.printStackTrace();        }        //User{name='bbb', age=18, skillsList=[java, python]}        //User{name='aaa', age=15, skillsList=[唱跳, rap]}        for (User user1 : user) {            System.out.println(user1);        }    }

                          ⑤复杂JSON（json数组中有多个对象） 转为List

                          readValue方法

                              public static void jsonListToList() {        String json = "[{\"name\":\"bbb\",\"age\":18,\"skillsList\":[\"java\",\"python\"]}," +                       "{\"name\":\"aaa\",\"age\":15,\"skillsList\":[\"唱跳\",\"rap\"]},"+                       "{\"name\":\"ccc\",\"age\":10,\"skillsList\":[\"biu\",\"pon\"]}]";        ObjectMapper objectMapper = new ObjectMapper();        List list = null;        try {            list = objectMapper.readValue(json, new TypeReference(){        });        } catch (JsonProcessingException e) {            e.printStackTrace();        }       // User{name='bbb', age=18, skillsList=[java, python]}      //  User{name='aaa', age=15, skillsList=[唱跳, rap]}      //  User{name='ccc', age=10, skillsList=[biu, pon]}        for (User user1 : list) {            System.out.println(user1);        }    }

                          3.4）忽略不存在的字段

                          如果 JSON出现了 Java 类中不存在的属性，转 Java 对象时会报com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException 异常。

                          使用configure方法，设置false来忽略

                              public static void jsonIgn() {        String json = "{\"需要忽略的\":\"需要忽略\",\"name\":\"bbb\",\"age\":18,\"skillsList\":[\"java\",\"python\"]}";        ObjectMapper objectMapper = new ObjectMapper();        //忽略字段设置        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);        User user=null;        try {            user = objectMapper.readValue(json, User.class);        } catch (JsonProcessingException e) {            e.printStackTrace();        }        //User{name='bbb', age=18, skillsList=[java, python]}        System.out.println(user);    }

                          3.5）使用jackson进行日期格式化

                          ①添加数据绑定支持包依赖

                              com.fasterxml.jackson.datatype    jackson-datatype-jsr310    2.13.3

                          ②在类中使用注解@JsonFormat

                          @Data@AllArgsConstructor@NoArgsConstructorpublic class Order {    private Integer id;    @JsonFormat(pattern = "yyyy年MM月dd日 HH时mm分ss秒",timezone = "Asia/Shanghai")    private Date date;    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "Asia/Shanghai")    private LocalDateTime localDateTime;}

                          ③定义 ObjectMapper 时通过 findAndRegisterModules() 方法来注册依赖。然后再互相转换

                          //Jackson 日期格式化public class JsonToJava9 {    public static void main(String[] args) throws IOException {        ObjectMapper objectMapper = new ObjectMapper().findAndRegisterModules();        Order order = new Order();        order.setId(1);        order.setDate(new Date());        order.setLocalDateTime(LocalDateTime.now());        //将java转换成json字符串        String json = objectMapper.writeValueAsString(order);        //{"id":1,"date":"2023年07月28日 15时14分01秒","localDateTime":"2023-07-28 15:14:01"}        System.out.println(json);        //将json字符串转换成java对象        Order orderObject = objectMapper.readValue(json, Order.class);        //Order(id=1, date=Fri Jul 28 15:15:59 CST 2023, localDateTime=2023-07-28T15:15:59)        System.out.println(orderObject);    }}

                          3.6）Jackson注解

                          ①@JsonIgnore

                          使用 @JsonIgnore可以忽略某个 Java 对象中的属性，它将不参与 JSON 的序列化与反序列化

                          ②@JsonGetter

                          使用 @JsonGetter可以在对 Java 对象进行 JSON 序列化时自定义属性名称。写在getter方法上

                           @JsonGetter(value = "catName")    public String getName() {        return name;    }

                          输出结果，name 已经设置成了 catName：

                          {"age":2,"catName":"Tom"}

                          ③@JsonSetter

                          使用 @JsonSetter可以在对 JSON 进行反序列化时设置 JSON 中的 key 与 Java 属性的映射关系。用在属性上

                          比如我json中是这样catName

                          String json = "{\"age\":2,\"catName\":\"Tom\"}";

                          为了我这个name能对应上json内容，把 private String name;通过注解设置成catName

                           @JsonSetter(value = "catName")    private String name;

                          参考资料：

                          https://zhuanlan.zhihu.com/p/646744855