六、Json 数据的交互处理-Toy模板网

这篇具有很好参考价值的文章主要介绍了六、Json 数据的交互处理。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

文章来源地址https://www.toymoban.com/news/detail-685800.html

JSON 概况以及 JAVA 基本操作 JSON 数据的方式

一、JSON 数据的交互处理

1、为什么要使用 JSON

因为现在的项目大多数都是前后端分离的项目，前端和后端都独立开发和部署。

由后端提供接口，前端从接口获取数据，将数据渲染到页面上。前后端数据传输的格式就是 JSON！

2、JSON 和 JavaScript 之间的关系

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

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

3、前端操作 JSON

代码示例

创建一个 HTML 文件，在 < head > 中添加 < script > 标签编写示例代码

注：< script > 必须成对出现，否则不生效

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

    <script type="application/javascript">

		// 创建对象，定义属性并赋值
        var user = {
            name:"姚青",
            age:24,
            sex:"男"
        }
        // 打印 user 对象
        console.log(user);

    </script>
</head>
<body>

</body>
</html>

通过浏览器打开该文件，可以看到打印的对象（对象是可以打开的，字符串不行）

3.1 JavaScript 对象与 JSON 字符串之间的相互转换

在 JavaScript 中默认提供了一个 JSON 的类，这个类中提供了两个方法，可以实现 JSON 和 JavaScript 的相互转换

parse() ：将 JSON 字符串转换为 JavaScript 对象

stringify() ：将 JavaScript 对象转换为 JSON 字符串

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

    <script type="application/javascript">

        var user = {
            name:"姚青",
            age:24,
            sex:"男"
        }
        // 打印正常对象
        console.log(user);

		// 打印对象转换后的JSON
        var json = JSON.stringify(user);
        console.log(json);

		// 打印JSON转换的JavaScript 对象
        var JavaScript = JSON.parse(json);
        console.log(JavaScript);

    </script>
</head>
<body>

</body>
</html>

执行结果

4、JAVA 操作 JSON

4.1 Json 的解析工具（Gson、FastJson、Jackson）

Gson：谷歌公司推出的Json解析工具
- Gson 主要有 toJson 与 fromJson 两个转换方法，通过这两个方法实现 Json 与 Java 对象之间的相互转换
- Gson详解用法

FastJson：阿里巴巴推出的Json解析工具
- FastJson 在复杂类型的 Bean 转换 Json 上会出现一些问题，可能会出现引用的类型，导致 Json 转换出错，需要制定引用。
- FastJson 采用独创的算法，将解析的速度提升到极致，超过所有 json 库。
  - FastJson 依赖包，导入 pom.xml 中即可使用
```
<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>fastjson</artifactId>
   <version>1.2.60</version>
</dependency>
```
- FastJson的使用方法

Jackson：Jackson 是比较著名的一个解析工具
- Jackson 是当前用的比较广泛的，用来序列化和反序列化 json 的 Java 的开源框架
- Jackson 社区相对比较活跃，更新速度也比较快，是最流行的 json 解析器之一
  - Jackson 依赖包，导入 pom.xml 中即可使用
```

<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.8</version>
</dependency>
```
    - ObjectMapper 类
      - ObjectMapper 类(com.fasterxml.jackson.databind.ObjectMapper)是 Jackson 的主要类，它可以帮助我们快速的进行各个类型和Json类型的相互转换。
        
        public String writeValueAsString(Object value): 将 Java 对象转换成 JSON
    ObjectMapper 类详解

区别
- FastJson的性能优于Gson，但是处理复杂类型时可能会出现一些错误，到现在还有很多BUG没修。
- Gson的功能非常的齐全。
- Jakson性能也非常出色，但是将核心功能拆分成三个模块，有Jar依赖。

注：Java工具千千万，处理 json 的工具有很多，大多数都是可以完成数据转换这一过程的，只是不同的工具所呈现的效果不一。所以，选择适合工具即可。

4.2 @ResponseBody 注解、@RestController 注解

@ResponseBody 注解
- 1、概念
  - @ResponseBody 注解，使用在控制层（controller）的方法上。
- 2、作用
  -        将方法的返回值，以特定的格式写入到response的body区域，进而将数据返回给客户端。
    
           当方法上面没有写ResponseBody,底层会将方法的返回值封装为ModelAndView对象。
    
            如果返回值是字符串，那么直接将字符串写到客户端；如果是一个对象，会将对象转化为 json 串，然后返回给客户端。

@RestController 注解
- 1、概念
  - @ResponseBody 注解，使用在控制层（controller）的类上。
- 2、作用
  - @RestController 的作用等同于 @Controller + @ResponseBody。并且改注解的作用域是整个类，当类被该注解标记时，类中所有的方法都会返回 JSON ，不用再每一个方法上都添加 @ResponseBody了。

注：当使用 @ResponseBody 注解和 @RestController 注解时，就不会去走视图解析器了，直接返回一个字符串，

4.3 java 中操作 JSON 的方式：返回值不做处理，返回默认 json

代码示例：

配置 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">

   <!--1.注册servlet-->
   <servlet>
       <servlet-name>SpringMVC</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
       <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>

   <!--所有请求都会被springmvc拦截 -->
   <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>

Spring 配置文件

<?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">

    <!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
    <context:component-scan base-package="com.sys.controller"/>

</beans>

创建实体类

@Data
public class User {

    private String id;
    private String name;
    private int age;
    private String sex;
    private String pass;
    
    public User(String id, String name, int age, String sex, String pass) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.pass = pass;
    }

}

创建 Controller

@Controller
public class UserController {

    @RequestMapping("/json")
    @ResponseBody
    public String getUserJson() {
		return new User("1", "姚青", 999, "男", "123456").toString();
    }
}

启动 tomcat，发现返回的 Json 中数字类型返回正常，中文乱码

六、Json 数据的交互处理,json,交互,mvc,spring

4.3.1 配置乱码过滤器（乱码问题统一解决）

在 Spring 配置文件中配置乱码过滤器

	<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.4 java 中操作 JSON 的方式： Jackson

代码示例1:将Java对象转换成 JSON

创建 controller，引入 Jackson 工具依赖其余内容不变

@RestController
public class JacksonController {

    @RequestMapping("/getJackson")
    public String getJackson(){

		User user = new User("1", "姚青", 999, "男", "123456");

        //创建 jackson 对象映射器，用来解析数据
        ObjectMapper objectMapper = new ObjectMapper();
        String str;
        try {
            // 将 java 对象转换成 json
             str = objectMapper.writeValueAsString(user);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
        return str;
    }
    
}

启动 tomcat，查看结果

代码示例2:返回集合，通过 Jackson 将集合转换成 JSON

在 JacksonController 中新增接口

@RestController
public class JacksonController {

    @RequestMapping("/getJackson")
    public String getJackson() {

        User user = new User("1", "姚青", 999, "男", "123456");

        //创建 jackson 对象映射器，用来解析数据
        ObjectMapper objectMapper = new ObjectMapper();
        String str;
        try {
            // 将 java 对象转换成 json
            str = objectMapper.writeValueAsString(user);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
        return str;
    }


    @RequestMapping("/getJackson2")
    public String getJackson2() {

        User user = new User("1", "姚青", 999, "男", "123456");
        User user2 = new User("2", "姚青2", 998, "男", "123456");
        User user3 = new User("3", "姚青3", 997, "男", "123456");
        User user4 = new User("4", "姚青4", 996, "男", "123456");

        List<User> list = new ArrayList<>();
        Collections.addAll(list, user, user2, user3, user4);

        //创建 jackson 对象映射器，用来解析数据
        ObjectMapper objectMapper = new ObjectMapper();
        String str;
        try {
            // 将 java 对象转换成 json
            str = objectMapper.writeValueAsString(list);
        } catch (JsonProcessingException e) {
            throw new RuntimeException(e);
        }
        return str;
    }

}