SpringMVC04：JSON的使用

最新推荐文章于 2022-10-15 08:30:38 发布

是志明呀

最新推荐文章于 2022-10-15 08:30:38 发布

阅读量1.6k

点赞数 1

分类专栏： Java EE 文章标签： json java springmvc

本文链接：https://blog.csdn.net/weixin_44262126/article/details/121248298

版权

Java EE 专栏收录该内容

29 篇文章 5 订阅

订阅专栏

本文为 SSM 框架系列之 SpringMVC 第四部分：JSON的使用
其它内容的链接如下：
1. 传统 MVC
2. Hello SpringMVC
3. 配置解析
4. JSON的使用
5. AJAX 的使用
6. 拦截器

1 JSON 的定义

1.1 JSON 的定义

JSON，即 JS 对象标记（JavaScript Object Notation），是一种轻量级的数据交换格式，它本质上是一种文本文件。它的语法要求为：

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

如：

[{"name": "sharm", "sex": "男"}, {"name": "jack", "sex": "男"}]

1.2 JSON 的特点

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

1.3 JSON 和 JavaScript 对象的区别

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

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

1.4 JSON 的作用

前后端分离时代，前端负责渲染后端的数据；而后端负责生成接口，提供数据。而两者之间就通过 JSON 来进行联系。

2 JavaScript 对象与 JSON 的互换

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>JavaScript 对象与 JSON 的互换</title>
</head>
<body>
<!-- script 标签只能双闭合 -->
<script type="text/javascript">
    //编写一个 js 的对象
    var user = {
        name: "sharm",
        age: 24,
        sex: "男"
    };

    //将 js 对象转换成 json 字符串
    var str = JSON.stringify(user);
    console.log(str);

    //将 json 字符串转换为 js 对象
    var user2 = JSON.parse(str);
    console.log(user2.name, user2.age, user2.sex);
</script>

</body>
</html>

在 IDEA 中使用浏览器打开，F12 进入开发者模式，查看控制台输出：
请添加图片描述

3 后端怎么返回 JSON 文件

再次介绍完整的步骤：

1 新建一个 Module，配置 Web 框架；

① 右键 module，add Web Application Frameworks Support；

② 请添加图片描述
③：

2 配置 pom.xml 文件；

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springmvc</artifactId>
        <groupId>sharm</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springmvc-json</artifactId>

    <!-- 经过实践证明，这段代码确实是必须要写的 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>11</java.version>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

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

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
    
    <!-- 静态资源导出 -->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
</project>

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

    <!-- 配置 DispatchServlet：这是 SpringMVC 的核心，请求分发器，前端控制器 -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- DispatchServlet 要绑定 Spring 的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 设置启动级别为 1 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- Spring 自带的过滤器 -->
    <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>

4 配置 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="sharm.controller"/>
    <!-- 默认：让 Spring MVC 不处理 html、css 等静态资源，防止资源占用 -->
    <mvc:default-servlet-handler />
    <!-- 默认：支持mvc注解驱动，这样就不需要写处理器映射器和处理器适配器，
         而 annotation-driven 配置帮助我们自动完成上述两个实例的注入。-->
    <mvc:annotation-driven />

    <!-- 只需要修改：视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

5 书写 User 实体类（也就是需要返回的 JSON 对象）；

package sharm.pojo;

public class User {
    private String name;
    private int age;
    private String sex;

    public User() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

6 书写 Controller 控制器；

package sharm.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import sharm.pojo.User;

@Controller
// @RestController
public class JSONController {
    // 其中 produces 是为了设置返回的编码类型，防止乱码
    @RequestMapping(value = "/jsonTest", produces = "application/json;charset=utf-8")
    @ResponseBody
    public String jsonTest() throws JsonProcessingException {
        // 一：创建一个 jackson 的对象映射器，用来解析数据
        ObjectMapper objectMapper = new ObjectMapper();
        // 二：创建一个用于转换成 JSON 文件的 Java 对象
        User sharm = new User("Sharm", 24, "男");
        // 三：将对象解析成 JSON 格式
        String str = objectMapper.writeValueAsString(sharm);
        // 四：由于 @ResponseBody 注解，这里会直接返回字符串，而无需走视图解析器，当然为了方便起见也可以不使用 @ResponseBody 注解，而使用给类定义一个 @RestController 注解来达到目的
        // 如果是前后端分离的情况，那肯定不走视图解析器了，只要返回 json 即可
        return str;
    }
}

7 前端返回；

请添加图片描述

4 JSON 转换时的乱码问题怎么解决

只需在 springmvc 的配置文件上添加一段消息StringHttpMessageConverter转换配置，而无需在控制器的每个方法上都设置一个 utf-8 的参数注解：

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

5 源码思维

5.1 利用 JSON 返回 Java 集合

@RestController
public class JSONController {
    // 其中 produces 是为了设置返回的编码类型，防止乱码
    @RequestMapping(value = "/jsonTest", produces = "application/json;charset=utf-8")
    public String jsonTest() throws JsonProcessingException {

        ObjectMapper objectMapper = new ObjectMapper();

        User sharm = new User("sharm", 24, "男");
        User jack = new User("jack", 24, "男");
        User luma = new User("luma", 24, "男");
        User loro = new User("lora", 24, "男");

        List<User> list = new ArrayList<User>();
        list.add(sharm);
        list.add(jack);
        list.add(luma);
        list.add(loro);
        String listStr = objectMapper.writeValueAsString(list);

        return listStr;
    }
}

浏览器返回如下：

请添加图片描述

5.2 利用 JSON 返回时间对象

@RequestMapping("/jsonTimeTest")
public String jsonTimeTest() throws JsonProcessingException {
    // 自定义日期格式对象
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    // 指定日期格式
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    mapper.setDateFormat(sdf);

    Date date = new Date();
    String str = mapper.writeValueAsString(date);

    return str;
}

浏览器返回如下：

请添加图片描述

5.3 源码思维（代码复用）

从上述两个例子中可以看出，不同的方法中有很多代码是相同的，在实际开发中我们可以使用复用、重载的方法来提高代码的复用性。

首先可以发现，以上两个例子都会共用 ObjectMapper对象，那么整理得到一个工具类为：

package sharm.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;
    }
}

那么原 5.1 的代码可以改写为：

// 其中 produces 是为了设置返回的编码类型，防止乱码
@RequestMapping(value = "/jsonTest", produces = "application/json;charset=utf-8")
public String jsonTest() throws JsonProcessingException {

    User sharm = new User("sharm", 24, "男");
    User jack = new User("jack", 24, "男");
    User luma = new User("luma", 24, "男");
    User loro = new User("lora", 24, "男");

    List<User> list = new ArrayList<User>();
    list.add(sharm);
    list.add(jack);
    list.add(luma);
    list.add(loro);

    String listStr = JsonUtils.getJson(list);

    return listStr;
}

原 5.2 的代码可以改写为：

@RequestMapping("/jsonTimeTest")
public String jsonTimeTest() throws JsonProcessingException {
    Date date = new Date();
    String str = JsonUtils.getJson(date);

    return str;
}

That’s OK!

是志明呀

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
SpringMVC04：JSON的使用

本文为 SSM 框架系列之 SpringMVC 第四部分：JSON的使用其它内容的链接如下：【1】MyBatis01：初识 MyBatis 与第一个 MyBaits 程序【2】MyBatis02：CRUD 操作【3】MyBatis03：配置解析【4】MyBatis04：作用域和生命周期【5】MyBatis05：分页【6】MyBatis06：日志【7】MyBatis07：使用注解开发【8】MyBatis08：ResultMap 的结果集映射【9】MyBatis09：动态 SQL 与缓存.
复制链接

扫一扫