八、SpringMVC（2）

Daniel521-Spark

已于 2022-07-29 10:24:39 修改

阅读量331

点赞数

分类专栏： # 计算机（Java中级）中级阶段文章标签： restful java spring mvc 后端

于 2022-07-29 08:54:56 首次发布

本文链接：https://blog.csdn.net/weixin_42171159/article/details/125993812

版权

计算机（Java中级）中级阶段专栏收录该内容

31 篇文章 2 订阅

订阅专栏

一、RestFul 风格

1.1 RestFul的概述

1.1.1 什么是 RestFul ？

在这里插入图片描述

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

1.1.2 为什么要学习 RestFul ？

因为基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

1.1.3 RestFul 的功能

资源：互联网所有的事物都可以被抽象为资源
资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
分别对应添加、删除、修改、查询。

（1）传统方式操作资源 ：

通过不同的参数来实现不同的效果！方法单一，post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查询,GET

http://127.0.0.1/item/saveItem.action 新增,POST

http://127.0.0.1/item/updateItem.action 更新,POST

http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

（2）使用RESTful操作资源 ：

可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询,GET

http://127.0.0.1/item 新增,POST

http://127.0.0.1/item 更新,PUT

http://127.0.0.1/item/1 删除,DELETE

1.2 测试案例

在上一节的工程下创建一个子工程 springmvc-05-restfulController

在这里插入图片描述
2. 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>
    </servlet>

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

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="com.zql.controller"/>

    <!--驱动注解-->
    <mvc:annotation-driven/>
    <!--资源过滤器-->
    <mvc:default-servlet-handler/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

RestfulController.java

package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * @Author:Daniel
 * @Version 1.0
 */

@Controller
public class RestfulController  {

    @RequestMapping(value = "/hollow/{a}/{b}")

    //@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。PathVariable:路径变量
    public String  restful(@PathVariable int a, @PathVariable int b, Model model){

        int result = a+b;

        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg","result = "+result);
        //返回视图位置
        return "hollow";
    }
}

WEB-INF/jsp/hollow.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

    ${msg}

</body>
</html>

测试请求查看 http://localhost:8080/hollow/2/3

在这里插入图片描述
思考：使用路径变量的好处？

使路径变得更加简洁；
获得参数更加方便，框架会自动进行类型转换。
通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/hollow/1/a，则路径与方法不匹配，而不会是参数转换失败。👇🏾👇🏾

在这里插入图片描述
7. 修改下对应的参数类型，再次测试 http://localhost:8080/hollow/1/sara

    @RequestMapping(value = "/hollow/{a}/{b}")

    //@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。PathVariable:路径变量
    public String  restful(@PathVariable int a, @PathVariable String b, Model model){

        String result = a+b;

        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg","result = "+result);
        //返回视图位置
        return "hollow";
    }

在这里插入图片描述
使用method属性指定请求类型

用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等。

    @RequestMapping(value = "/hollow/{a}/{b}",method = RequestMethod.POST)

    //@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。PathVariable:路径变量
    public String  restful(@PathVariable int a, @PathVariable String b, Model model){

        String result = a+b;

        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg","result = "+result);
        //返回视图位置
        return "hollow";
    }

我们使用浏览器地址栏进行访问默认是Get请求，会报错405： http://localhost:8080/hollow/1/sara

在这里插入图片描述

如果将POST修改为GET则正常了； http://localhost:8080/hollow/1/sara

    @RequestMapping(value = "/hollow/{a}/{b}",method = RequestMethod.GET)

    //@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。PathVariable:路径变量
    public String  restful(@PathVariable int a, @PathVariable String b, Model model){

        String result = a+b;

        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg","result = "+result);
        //返回视图位置
        return "hollow";
    }

在这里插入图片描述
小结：

Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的地址栏请求默认都会是 HTTP GET 类型的。

方法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

@GetMapping 是一个组合注解，平时使用的会比较多！
它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。

二、结果跳转方式

2.1 通过SpringMVC来实现转发和重定向 - 无需视图解析器

测试前，需要将视图解析器注释掉

package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author:Daniel
 * @Version 1.0
 */

@Controller
public class ModelTest1 {

    @RequestMapping("a/hollow")
    public String test1(Model model){

        model.addAttribute("msg","ModelTest1");

        //return "hollow";

        //转发方式一
        return  "/WEB-INF/jsp/hollow.jsp";
        //转发方式二
        return "forward:/WEB-INF/jsp/hollow.jsp";
        //重定向
        return "redirect:/index.jsp";
    }
}

测试访问入口：http://localhost:8080/a/hollow

转发& 重定向 👇🏾👇🏾

在这里插入图片描述

2.2 通过SpringMVC来实现转发和重定向 - 有视图解析器

重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方嘛 , 所以注意路径问题.
可以重定向到另外一个请求实现 .

package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author:Daniel
 * @Version 1.0
 */

@Controller
public class ModelTest1 {

    @RequestMapping("a/hollow")
    public String test1(Model model){

        model.addAttribute("msg","ModelTest1");

        return "hollow";

        //重定向
        return "redirect:/index.jsp";
    }
}

测试访问入口：http://localhost:8080/a/hollow
在这里插入图片描述

三、数据处理

3.1 处理提交数据

案例结构：

在这里插入图片描述

创建 User.java

package com.zql.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {

    private int id;

    private String name;

    private String age;
}

创建UserController.java

package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/t1")
    public String test1(Model model){
        //1.接收前端传过来的数据

        //2.将返回的结果传递给前端
        model.addAttribute("msg","");
        //3.视图跳转
        return "hollow";

    }
}

http://localhost:8080/user/t1

在这里插入图片描述

3.1.1 提交的域名称和处理方法的参数名一致

提交数据：http://localhost:8080/user/t1?name=Daniel
处理方法：👇🏾👇🏾

package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/t1")
    public String test1(String name, Model model){
        //1.接收前端传过来的数据
        System.out.println("前端传过来的数据"+name);
        //2.将返回的结果传递给前端
        model.addAttribute("msg",name);
        //3.视图跳转
        return "hollow";

    }
}

前后台输出：👇🏾👇🏾

在这里插入图片描述

3.1.2 提交的域名称和处理方法的参数名不一致

提交数据：http://localhost:8080/user/t1?username=Daniel
处理方法：👇🏾👇🏾

package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/t1")
    
    public String test1(@RequestParam("username") String name, Model model){
        //@RequestParam("username") : username提交的域的名称 
        //1.接收前端传过来的数据
        System.out.println("传过来的数据是："+name);
        //2.将返回的结果传递给前端
        model.addAttribute("msg",name);
        //3.视图跳转
        return "hollow";

    }
}

前后台输出：👇🏾👇🏾

在这里插入图片描述

3.1.3 提交的是一个对象

要求提交的表单域和对象的属性名一致 , 参数使用对象即可

提交数据：http://localhost:8080/user/t1?id=521&name=Daniel&age=18
处理方法：👇🏾👇🏾
2.1 参考上述3.1>2 (User.java)
2.2 👇🏾👇🏾

package com.zql.controller;

import com.zql.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/t1")

    public String test1(User user){

        //1.接收前端传过来的数据
        System.out.println("传过来的数据是："+user);
        //2.将返回的结果传递给前端

        //3.视图跳转
        return "hollow";

    }
}

前后台输出：👇🏾👇🏾

在这里插入图片描述

说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

3.2 数据显示到前端

3.2.1 第一种 : 通过ModelAndView

创建 TestController.java

package com.zql.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class TestController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {

        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView();

        mv.addObject("msg","day day study,day day up!");

        mv.setViewName("hollow");

        return mv;
    }
}

一定记得注入到spring容器中springmvc-servlet.xml

<bean id="/hollow" class="com.zql.controller.TestController"/>

访问：http://localhost:8080/hollow

3.2.2 第二种 : 通过ModelMap

package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class ModelMapController {

    @RequestMapping("/t2")
    public String test(ModelMap map){

        //封装要显示到视图中的数据
        //相当于req.setAttribute("name",name);
        map.addAttribute("msg","Daniel521");

        return "hollow";
    }
}

访问：http://localhost:8080/user/t2

在这里插入图片描述

3.2.3 第三种 : 通过Model

package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class ModelMapController {

    @RequestMapping("/t2")
    public String test(Model model){

        //封装要显示到视图中的数据
        //相当于req.setAttribute("name",name);
        model.addAttribute("msg","Jenny311");

        return "hollow";
    }
}

访问：http://localhost:8080/user/t2

在这里插入图片描述
总结对比：👇🏾👇🏾

就对于新手而言简单来说使用区别就是：

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；
ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

在开发中考虑更多的是性能和优化，就不能单单仅限于此的了解。

请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间学点英文，框架的官方文档永远是最好的教程。

四、乱码问题(四种方案)

案例结构

在这里插入图片描述

创建 WEB-INF/form.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="/e/t" method="post">
        <input type="text" name="name">
        <input type="submit">
    </form>
</body>
</html>

创建 EncodingController.java

package com.zql.controller;

import org.springframework.http.HttpRequest;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.context.support.HttpRequestHandlerServlet;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
public class EncodingController {

   @RequestMapping(value = "/e/t",method = RequestMethod.POST)
    public String encoding(String name, Model model)  {

        model.addAttribute("msg",name); //获取表单提交的值

        return "hollow";//跳转到test页面显示输入的值
    }
}

运行：http://localhost:8080/form.jsp

在这里插入图片描述

出现乱码 👇🏾👇🏾（需求）：

解决办法一： 👇🏾👇🏾

创建 Encoding.java

package com.zql.filter;

import javax.servlet.*;
import java.io.IOException;
import java.util.logging.LogRecord;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class Encoding implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        //解决请求和响应乱码问题(可移动到过滤其中统一处理)
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=utf-8");

        filterChain.doFilter(request,response);
    }

    @Override
    public void destroy() {

    }
}

web.xml导入配置

<!--过滤器-->
<filter>
    <filter-name>encoding</filter-name>
    <filter-class>com.zql.filter.Encoding</filter-class>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

测试：👉🏾👉🏾 http://localhost:8080/form.jsp

解决办法二： 👇🏾👇🏾

不得不说，乱码问题是在我们开发中十分常见的问题，也是让我们程序猿比较头大的问题！
以前乱码问题通过过滤器解决(解决办法一) , 而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置 .修改了xml 文件需要重启服务器！

<!--springmvc提供-->
<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>

解决办法三： 👇🏾👇🏾

但是我们发现 , 有些极端情况下.这个spring提供的对get的支持也不友好 .，看办法三 👇🏾👇🏾

1、修改tomcat配置文件(\apache-tomcat-8.5.29\conf\server.xml) ：设置编码！

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
          connectionTimeout="20000"
          redirectPort="8443" />

解决办法四： 👇🏾👇🏾

自定义过滤器

创建 GenericEncodingFilter.java

package com.zql.filter;
/**
 * @Author:Daniel
 * @Version 1.0
 */
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
 * 解决get和post请求 全部乱码的过滤器
 */
public class GenericEncodingFilter implements Filter {

    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //处理response的字符编码
        HttpServletResponse myResponse=(HttpServletResponse) response;
        myResponse.setContentType("text/html;charset=UTF-8");

        // 转型为与协议相关对象
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        // 对request包装增强
        HttpServletRequest myrequest = new MyRequest(httpServletRequest);
        chain.doFilter(myrequest, response);
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

}

//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {

    private HttpServletRequest request;
    //是否编码的标记
    private boolean hasEncode;
    //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    public MyRequest(HttpServletRequest request) {
        super(request);// super必须写
        this.request = request;
    }

    // 对需要增强方法 进行覆盖
    @Override
    public Map getParameterMap() {
        // 先获得请求方式
        String method = request.getMethod();
        if (method.equalsIgnoreCase("post")) {
            // post请求
            try {
                // 处理post乱码
                request.setCharacterEncoding("utf-8");
                return request.getParameterMap();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        } else if (method.equalsIgnoreCase("get")) {
            // get请求
            Map<String, String[]> parameterMap = request.getParameterMap();
            if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                for (String parameterName : parameterMap.keySet()) {
                    String[] values = parameterMap.get(parameterName);
                    if (values != null) {
                        for (int i = 0; i < values.length; i++) {
                            try {
                                // 处理get乱码
                                values[i] = new String(values[i]
                                        .getBytes("ISO-8859-1"), "utf-8");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
                hasEncode = true;
            }
            return parameterMap;
        }
        return super.getParameterMap();
    }

    //取一个值
    @Override
    public String getParameter(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        if (values == null) {
            return null;
        }
        return values[0]; // 取回参数的第一个值
    }

    //取所有值
    @Override
    public String[] getParameterValues(String name) {
        Map<String, String[]> parameterMap = getParameterMap();
        String[] values = parameterMap.get(name);
        return values;
    }
}

web.xml 配置引入

<!--自定义过滤-->
<filter>
    <filter-name>encoding</filter-name>
    <filter-class>com.zql.filter.GenericEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

最终解决：👇🏾👇🏾 http://localhost:8080/form.jsp

在这里插入图片描述

总结：

一般情况下，SpringMVC默认的乱码处理就已经能够很好的解决了！
乱码问题，需要平时多注意，在尽可能能设置编码的地方，都设置为统一编码 UTF-8！

五、JSON

👉🏾👉🏾 之前都总结过

前后端分离时代：

在这里插入图片描述

5.1 什么是JSON？

在这里插入图片描述

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

对象表示为键值对，数据由逗号分隔

花括号保存对象

方括号保存数组

JSON 键值对是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔，然后紧接着值：

{"name": "Daniel"}
{"age": "3"}
{"sex": "男"}

很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解：

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

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

5.2 JSON 和 JavaScript 对象互转

创建一个html👉🏾👉🏾 web/jsonTest.html

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

    <script type="text/javascript">

        var user = {

            name:"Daniel",
            age:11,
            sex:"男"
        };
        /*js*/
        console.log(user);
    </script>
</head>
<body>

</body>
</html>

在这里插入图片描述

1. 要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法

var json = JSON.stringify(user)
console.log(json);//输出为：{"name":"Daniel","age":11,"sex":"男"}

在这里插入图片描述

2. 要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：

前提是将js已经转成了json

var js = JSON.parse(json) //输出看截图
console.log(js)

在这里插入图片描述

上述完整代码(创建一个html👉🏾👉🏾 web/jsonTest.html)：👇🏾👇🏾

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

    <script type="text/javascript">

        var user = {

            name:"Daniel",
            age:11,
            sex:"男"
        };
        /*js*/
        console.log(user);
        /*1. 要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法*/
        var json = JSON.stringify(user)
        console.log(json);//输出为：{"name":"Daniel","age":11,"sex":"男"}
        /*2. 要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：*/
        var js = JSON.parse(json) //输出看截图
        console.log(js)

    </script>
</head>
<body>

</body>
</html>

在IDEA中使用浏览器打开，查看控制台(F12)输出！

在这里插入图片描述

5.3 Controller返回JSON数据

Jackson应该是目前比较好的json解析工具了
当然工具不止这一个，比如还有阿里巴巴的 fastjson 等等。
我们这里使用Jackson，使用它需要导入它的jar包；

案例

创建一个子工程 springmvc-06-json
引入json对应的依赖 pom.xml

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.3</version>
</dependency>

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>

创建springmvc-servlet.xml

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

User.java

package com.zql.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @Author:Daniel
 * @Version 1.0
 */
//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {

        private String name;
        private int age;
        private String sex;

}

UserController.java

package com.zql.controller;

import com.zql.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
public class UserController {

        @ResponseBody //不走视图解析器，直接返回（字符串）
        @RequestMapping("/json1")
        public String json1(){

            User user = new User("安卓",12,"男");

            return user.toString();
        }
}

在这里插入图片描述

发现出现了乱码问题，我们需要设置一下他的编码格式为utf-8，以及它返回的类型；
通过@RequestMaping的produces属性来实现，修改下代码

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

再次测试， http://localhost:8080/json1 ，乱码问题OK！

在这里插入图片描述
乱码统一解决 👇🏾👇🏾

上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过Spring配置统一指定，这样就不用每次都去处理了！
我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置！

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

(1) 返回json字符串统一解决

在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody ！我们在前后端分离开发中，一般都使用 @RestController ，十分便捷！

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

启动tomcat测试，结果都正常输出！http://localhost:8080/json2

在这里插入图片描述

(2)测试集合输出 http://localhost:8080/json3

 @RequestMapping(value = "/json3")
 public String json3() throws JsonProcessingException {
     //创建一个jackson的对象映射器，用来解析数据
     ObjectMapper mapper = new ObjectMapper();
     //创建对象
     User user1 = new User("安卓1",12,"男1");
     User user2 = new User("安卓2",12,"男2");
     User user3 = new User("安卓3",12,"男3");
     User user4 = new User("安卓4",12,"男4");
     List<User> list = new ArrayList<>();
     list.add(user1);
     list.add(user2);
     list.add(user3);
     list.add(user4);
     //将我们的对象解析成为json格式
     String str = mapper.writeValueAsString(list);
     //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
     return str;
 }

在这里插入图片描述

(3) 输出时间对象 http://localhost:8080/json4

@RequestMapping(value = "/json4")
public String json4() throws JsonProcessingException {
    //创建一个jackson的对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //创建时间一个对象，java.util.Date
    Date date = new Date();
    //将我们的对象解析成为json格式
    String str = mapper.writeValueAsString(date);
    //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
    return str;
}

在这里插入图片描述

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

解决方案：取消timestamps(时间戳)形式，自定义时间格式 👇🏾👇🏾 http://localhost:8080/json4

@RequestMapping(value = "/json4")
public String json4() throws JsonProcessingException {
    //创建一个jackson的对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
    //不使用时间戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    //自定义日期格式对象
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //创建时间一个对象，java.util.Date
    Date date = new Date();
    mapper.setDateFormat(sdf);
    //将我们的对象解析成为json格式
    String str = mapper.writeValueAsString(date);
    //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
    return str;
}

在这里插入图片描述

抽取为工具类

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

创建JsonUtils.java

package com.zql.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class JsonUtils {

    public static String getJson(Object object) throws JsonProcessingException {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object,String dateFormat ) throws JsonProcessingException {

        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();

        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);

        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);

        Date date = new Date();

        mapper.setDateFormat(sdf);

        return mapper.writeValueAsString(object);
    }
}

优化：json4

@RequestMapping(value = "/json5")
public String json5() throws JsonProcessingException {

    Date date = new Date();

    return JsonUtils.getJson(date);
}

优化：json3

 @RequestMapping(value = "/json3")
 public String json3() throws JsonProcessingException {
     //创建对象
     User user1 = new User("安卓1",12,"男1");
     User user2 = new User("安卓2",12,"男2");
     User user3 = new User("安卓3",12,"男3");
     User user4 = new User("安卓4",12,"男4");
     List<User> list = new ArrayList<>();
     list.add(user1);
     list.add(user2);
     list.add(user3);
     list.add(user4);
     String json = JsonUtils.getJson(list);
     //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
     return json;
 }

5.4 FastJson(阿里开发包)

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。

fastjson 的 pom依赖！

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.10</version>
</dependency>

fastjson 三个主要的类：

(1) JSONObject 代表 json 对象

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

(2) JSONArray 代表 json 对象数组

内部是有List接口中的方法来完成操作的。
JSON代表 JSONObject和JSONArray的转化

(3) JSON类源码分析与使用

仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

代码测试，创建一个FastJsonController.java

(1) http://localhost:8080/fastJson

package com.zql.controller;

import com.alibaba.fastjson2.JSON;
import com.zql.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@RestController
public class FastJsonController {

@RequestMapping("/fastJson")
public String fastJson(){
    //创建对象
    User user1 = new User("安卓1",12,"男1");
    User user2 = new User("安卓2",12,"男2");
    User user3 = new User("安卓3",12,"男3");
    User user4 = new User("安卓4",12,"男4");
    List<User> list = new ArrayList<>();
    list.add(user1);
    list.add(user2);
    list.add(user3);
    list.add(user4);

    String fast = JSON.toJSONString(list);

    return fast;
}
}

在这里插入图片描述
(2) http://localhost:8080/fastJson2

@RequestMapping("/fastJson2")
public String fastJson2(){
//创建对象
User user1 = new User("安卓1",12,"男1");
User user2 = new User("安卓2",12,"男2");
User user3 = new User("安卓3",12,"男3");
User user4 = new User("安卓4",12,"男4");
List<User> list = new ArrayList<>();
list.add(user1);
list.add(user2);
list.add(user3);
list.add(user4);

String fast = JSON.toJSONString(list);

System.out.println("*******Java对象 转 JSON字符串*******");
String str1 = JSON.toJSONString(list);
System.out.println("JSON.toJSONString(list)==>"+str1);
String str2 = JSON.toJSONString(user1);
System.out.println("JSON.toJSONString(user1)==>"+str2);

System.out.println("\n****** JSON字符串 转 Java对象*******");
User jp_user1=JSON.parseObject(str2,User.class);
System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

System.out.println("\n****** Java对象 转 JSON对象 ******");
JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

System.out.println("\n****** JSON对象 转 Java对象 ******");
User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);

return  fast;
}