Jackson、FastJson快速入门(整合SpringMVC)

蔚落 2022-12-04 02:22 211阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70]

### 目录 ###

*  1. 什么是 JSON
 *  2. JSON 语法规则
 *  3. JSON 与 JS 对象的关系
 *  4. JSON 和 JS 对象互转
 *  5. Jackson—数据格式转换
 *   *   *  1. 环境搭建
         *  2. 对象转json
         *  3. 代码优化
         *  4. 多对象转json
         *  5. 日期对象转json
     *  6. FastJson—数据格式转换
     *   *  1. 导入依赖
         *  2. 三个主要的类
         *  3. 代码测试
         *  4. 常用方法

--------------------

# 1. 什么是 JSON #

> `JSON`（JavaScript Object Notation, JS 对象标记）

*  是一种轻量级的数据交换格式
 *  采用完全独立于编程语言的`文本格式`来存储和表示数据。
 *  简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
 *  易于人阅读和编写，也易于机器解析和生成，并有效地提升网络传输效率。

在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。

--------------------

# 2. JSON 语法规则 #

*  `键值对`表示对象，数据由逗号分隔
 *  `花括号`保存对象
 *  `方括号`保存数组

**JSON 键值对** 是用来保存 JavaScript 对象的一种方式

*  由`花括号`括起来的`逗号`分割的成员构成
 *  键值对组合中的键名写在前面并用双引号`""`包裹，使用冒号 `:`分隔，然后紧接着值

{ "name": "zsr","age": "20","sex": "男"}

--------------------

# 3. JSON 与 JS 对象的关系 #

> JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

var obj = { a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
    var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

--------------------

# 4. JSON 和 JS 对象互转 #

> 编写一个html页面进行测试

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>test</title>
    </head>
    <body>
    <script type="text/javascript"> var user = { name: "zsr", age: 20, sex: "男" }; console.log(user); //将js对象转换为json对象 var json = JSON.stringify(user); console.log(json); //将json对象转换为js对象 var obj = JSON.parse(json); console.log(obj); </script>
    </body>
    </html>

运行测试，查看控制台信息：

*  `JSON`就是一个字符串，不能展开
 *  `JavaScript`是一个对象，可以展开  
    ![image-20200904144448667][]

--------------------

# 5. Jackson—数据格式转换 #

> `Jackson` 是一个 Java 的用来处理 `JSON` 格式数据的类库，性能非常好

当然不止这一个类库，比如还有阿里巴巴的 `fastjson` 等等。  
![image-20200905104915847][]

> 接下来我们简单介绍一下SpringMVC中`Jackson`的使用

### 1. 环境搭建 ###

1️⃣ **导入Jackson的jar包**

<dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.11.2</version>
    </dependency>

2️⃣ **配置web.xml**：配置SpringMVC需要的配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0">
    
       
       <servlet>
           <servlet-name>SpringMVC</servlet-name>
           <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
           
           <init-param>
               <param-name>contextConfigLocation</param-name>
               <param-value>classpath:springmvc-servlet.xml</param-value>
           </init-param>
           
           <load-on-startup>1</load-on-startup>
       </servlet>
    
       
       <servlet-mapping>
           <servlet-name>SpringMVC</servlet-name>
           <url-pattern>/</url-pattern>
       </servlet-mapping>
    
       
       <filter>
           <filter-name>encoding</filter-name>
           <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
           <init-param>
               <param-name>encoding</param-name>
               <param-value>utf-8</param-value>
           </init-param>
       </filter>
       <filter-mapping>
           <filter-name>encoding</filter-name>
           <url-pattern>/</url-pattern>
       </filter-mapping>
    </web-app>

3️⃣ **编写SpringMVC配置文件**`springmvc-servlet.xml`

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        
        <context:component-scan base-package="controller"/>
    
        
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
            
            <property name="prefix" value="/WEB-INF/jsp/" />
            
            <property name="suffix" value=".jsp" />
        </bean>
    
    </beans>

4️⃣ **编写实体类 (lombok)**

> 编写一个User的实体类，然后我们去编写我们的测试Controller；

package pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User { 
        private String name;
        private int age;
        private String sex;
    }

5️⃣ **编写Controller**

@Controller
    public class UserController { 
        @RequestMapping("/j1")
        @ResponseBody //它不会走视图解析器,会直接返回一个字符串
        public String json1() { 
            //创建一个对象
            User user = new User("zsr", 20, "男");
            return user.toString();
        }
    }

6️⃣ **运行测试**

配置Tomcat，点击运行，访问`http://localhost:8080/j1`，结果如下  
![image-20200904183028618][]

我们并没有通过视图解析器，而是直接返回了字符串

### 2. 对象转json ###

我们修改上述Controller，通过`objectMapper`对象来转换为json格式

@Controller
    public class UserController { 
        @RequestMapping("/j1")
        @ResponseBody //它不会走视图解析器,会直接返回一个字符串
        public String json1() throws JsonProcessingException { 
            //创建jackson的对象映射器，用来解析数据
            ObjectMapper mapper = new ObjectMapper();
            //创建一个对象
            User user = new User("zsr", 20, "男");
            //将对象转换成json格式
            String str = mapper.writeValueAsString(user);
            //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
            return str;
        }
    }

重新运行测试，同行访问`http://localhost:8080/j1`，成功以json的格式进行显示！  
![image-20200904184738015][]  
但是还存在**乱码问题**，我们需要设置一下他的编码格式为utf-8，以及它返回的类型；

这里可以通过`@RequestMapping`的`produces`属性来实现，修改下代码

//produces:指定响应体返回类型和编码
    @RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

再次测试，乱码问题得到解决  
![image-20200904184901266][]

### 3. 代码优化 ###

1️⃣ **乱码问题**

> 上述设置`@RequestMapping`中`produces`属性值的方式比较麻烦，如果项目中有多个`controller`则每一个都要添加，可以通过Spring配置统一指定，在SpringMVC配置文件中加入如下代码即可

<mvc:annotation-driven>
       <mvc:message-converters register-defaults="true">
           <bean class="org.springframework.http.converter.StringHttpMessageConverter">
               <constructor-arg value="UTF-8"/>
           </bean>
           <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
               <property name="objectMapper">
                   <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                       <property name="failOnEmptyBeans" value="false"/>
                   </bean>
               </property>
           </bean>
       </mvc:message-converters>
    </mvc:annotation-driven>

4️⃣ **返回json字符串统一解决**

*  上述使用了`@ResponseBody`\+`@Controller`注解，可以使不走视图解析器，而是直接返回一个字符串
 *  也可将`@Controller`替换为`@RestController`，就不需要`@ResponseBody`注解了

@RestController
    public class UserController { 
       @RequestMapping(value = "/json1")
       public String json1() throws JsonProcessingException { 
           //创建一个jackson的对象映射器，用来解析数据
           ObjectMapper mapper = new ObjectMapper();
           //创建一个对象
           User user = new User("zsr", 20, "男");
           //将我们的对象解析成为json格式
           String str = mapper.writeValueAsString(user);
           //由于@RestController注解，这里会将str转成json格式返回；十分方便
           return str;
      }
    }

### 4. 多对象转json ###

> 多个对象的情况下，我们会将其放在一个集合中一起转换为json格式输出

@RequestMapping(value = "/j2")
    public String json2() throws JsonProcessingException { 
        //创建jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建容器
        List<User> list = new ArrayList<User>();
        //创建多个对象
        User user1 = new User("zsr1", 20, "男");
        User user2 = new User("zsr2", 20, "男");
        User user3 = new User("zsr3", 20, "男");
        User user4 = new User("zsr4", 20, "男");
        User user5 = new User("zsr5", 20, "男");
        //将所有对象存入容器
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        list.add(user5);
        //将对象转换成json格式
        String str = mapper.writeValueAsString(list);
        //由于@RequestMapping注解，这里会将str转成json格式返回；十分方便
        return str;
    }

运行测试，成功将所有对象的信息都以json的形式显示出来  
![image-20200904190432165][]

### 5. 日期对象转json ###

> 增加一个新的方法，测试日期对象的输出

@RequestMapping(value = "/j3")
    public String json3() throws JsonProcessingException { 
        //创建jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个日期对象
        Date date = new Date();
        //将对象转换为json格式
        String str = mapper.writeValueAsString(date);
        //ObjectMapper对时间解析后的默认格式为:Timestamp(时间戳)
        return str;
    }

运行测试，访问`http://localhost:8080/j3`，手动刷新，可以看到这个数字增长很快  
![image-20200904191448018][]

*  默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！
 *  Jackson 默认是会把时间转成timestamps形式

如果我们不想以时间戳的方式显示呢？

**方式一：自定义日期的格式**

@RequestMapping(value = "/j4")
    public String json4() throws JsonProcessingException { 
        //创建jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个日期对象
        Date date = new Date();
        //自定义日期格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy-mm-dd hh:mm:ss");
        //将对象转换为json格式
        String str = mapper.writeValueAsString(simpleDateFormat.format(date));
        return str;
    }

运行测试：访问`http://localhost:8080/j4`，成功按我们规定的格式输出  
![image-20200904214159311][]

**方式二：取消timestamps形式 ， 自定义时间格式**

@RequestMapping(value = "/j5")
    public String json5() throws JsonProcessingException { 
        //创建jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定义日期格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy-mm-dd hh:mm:ss");
        //指定日期格式
        mapper.setDateFormat(simpleDateFormat);
        //创建一个日期对象
        Date date = new Date();
        //将对象转换为json格式
        String str = mapper.writeValueAsString(date);
        return str;
    }

运行测试：访问`http://localhost:8080/j5`，同样成功按我们规定的格式输出  
![image-20200904214821030][]

> 抽取为工具类

**如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中**

package utils;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;
    
    import java.text.SimpleDateFormat;
    
    public class JsonUtils { 
       
       public static String getJson(Object object) { 
           return getJson(object,"yyyy-MM-dd HH:mm:ss");
      }
    
       public static String getJson(Object object,String dateFormat) { 
           ObjectMapper mapper = new ObjectMapper();
           //不使用时间差的方式
           mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
           //自定义日期格式对象
           SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
           //指定日期格式
           mapper.setDateFormat(sdf);
           try { 
               return mapper.writeValueAsString(object);
          } catch (JsonProcessingException e) { 
               e.printStackTrace();
          }
           return null;
      }
    }

我们使用工具类，上述代码就更加简洁了！

@RequestMapping("/j5")
    public String json5() throws JsonProcessingException { 
       Date date = new Date();
       String json = JsonUtils.getJson(date);
       return json;
    }

--------------------

## 6. FastJson—数据格式转换 ##

> `fastjson.jar`是阿里开发的一款专门Java处理JSON开发的包

*  Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。
 *  Fastjson 可以操作任何 Java 对象，即使是一些预先存在的没有源码的对象。

**菜鸟教程**：[https://www.runoob.com/w3cnote/fastjson-intro.html][https_www.runoob.com_w3cnote_fastjson-intro.html]

**Fastjson 源码地址**：[https://github.com/alibaba/fastjson  
][https_github.com_alibaba_fastjson]

**Fastjson 中文 Wiki**：[https://github.com/alibaba/fastjson/wiki/Quick-Start-CN][https_github.com_alibaba_fastjson]  
![image-20200905111922434][]

> 接下来我们简单介绍一下SpringMVC中`fastjson`的使用

### 1. 导入依赖 ###

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.73</version>
    </dependency>

### 2. 三个主要的类 ###

1️⃣ **JSONObject**：代表 `json对象`

*  JSONObject 对应 json对象，通过各种形式的 get() 方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取键值对的个数和判断是否为空。
 *  JSONObject 实现了Map接口，其本质是通过实现Map接口并调用接口中的方法完成的。

--------------------

2️⃣ **JSONArray**：代表 `json对象数组`

*  内部是有List接口中的方法来完成操作的

--------------------

3️⃣ **JSON**：代表 `JSONObject` 和 `JSONArray` 的转化

*  JSON类源码分析与使用
 *  仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

### 3. 代码测试 ###

> 新建一个方法，利用fastjson的方法返回json字符串：

@RequestMapping(value = "/j6")
    public String json6() throws JsonProcessingException { 
        //创建容器
        List<User> list = new ArrayList<User>();
        //创建多个对象
        User user1 = new User("zsr1", 20, "男");
        User user2 = new User("zsr2", 20, "男");
        User user3 = new User("zsr3", 20, "男");
        User user4 = new User("zsr4", 20, "男");
        User user5 = new User("zsr5", 20, "男");
        //将所有对象存入容器
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        list.add(user5);
        return JSON.toJSONString(list);
    }

运行测试：同样正确显示了结果  
![image-20200904220624489][]

### 4. 常用方法 ###

> 这种工具类，我们只需知道了解即可，在使用的时候在根据具体的业务去找对应的实现即可

接下来是几种常用的方法（更多的方法在具体的业务时查找使用即可）

public static void main(String[] args) { 
        //创建容器
        List<User> list = new ArrayList<User>();
        //创建多个对象
        User user1 = new User("zsr1", 20, "男");
        User user2 = new User("zsr2", 20, "男");
        User user3 = new User("zsr3", 20, "男");
        User user4 = new User("zsr4", 20, "男");
        User user5 = new User("zsr5", 20, "男");
        //将所有对象存入容器
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);
        list.add(user5);
        
    	//常用代码测试
        System.out.println("Java对象集合转化为JSON字符串: "
                           + JSON.toJSONString(list));
    
        System.out.println("Java对象user1转化为JSON字符串: "
                           + JSON.toJSONString(user1));
    
        System.out.println("JSON字符串转化为Java对象user1: "
                           + JSON.parseObject(JSON.toJSONString(user1), User.class));
    
        System.out.println("Java对象user1转化为JSON对象: "
                           + JSON.toJSON(user1));
    
        System.out.println("JSON对象转化为Java对象user1: "
                           + JSON.toJavaObject((JSON) JSON.toJSON(user1), User.class));
    }

运行结果：  
![image-20200905112935322][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTczNDA0_size_16_color_FFFFFF_t_70]: /images/20221123/3b632884ee694fcaae6c1f265db8d6b2.png
[image-20200904144448667]: /images/20221123/c15e50bc74f543248f6dc3218d3ada7e.png
[image-20200905104915847]: /images/20221123/aa5969a9eab44569bdbf6387fc22926a.png
[image-20200904183028618]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200904183028618.png
[image-20200904184738015]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200904184738015.png
[image-20200904184901266]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200904184901266.png
[image-20200904190432165]: /images/20221123/4b62b8d33dfe4e01a0a7e1571d688613.png
[image-20200904191448018]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200904191448018.png
[image-20200904214159311]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200904214159311.png
[image-20200904214821030]: https://gitee.com/zhong_siru/images/raw/master//img/image-20200904214821030.png
[https_www.runoob.com_w3cnote_fastjson-intro.html]: https://www.runoob.com/w3cnote/fastjson-intro.html
[https_github.com_alibaba_fastjson]: https://github.com/alibaba/fastjson
[image-20200905111922434]: /images/20221123/d46501835ef04b2aa297ce9127871060.png
[image-20200904220624489]: /images/20221123/eae47764779647a9815a4ce94f818ec6.png
[image-20200905112935322]: /images/20221123/f202069c73cb458b843b2c1e3f42f1ea.png