【SpringMVC】---学习笔记

【SpringMVC】

一、SpringMVC简介

1、MVC模型

• Module（模型）：Dao、Service
• View（识图）：Jsp
• Controller（控制器）：Serv

2、什么是SpringMVC

官方文档

https://docs.spring.io/spring-framework/docs/current/reference/html/web.html

• Spring Web MVC 是最初建立在 Servlet API 之上的 Web 框架。
• 从一开始就包含在 Spring Framework 中。
• 正式名称“Spring Web MVC”来自其源模块的名称 ( spring-webmvc)，但通常称为“Spring MVC”。

特点：

• 轻量级，简单易学。
• 高效，基于请求响应的MVC框架。
• 与Spring兼容性好，无缝结合。
• 约定优于配置

3、中心控制器

​ Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

​ SpringMVC框架像许多MVC框架一样，以请求为驱动，围绕一个中心Servlet分派请求及提供其他功能，DispacherServlet是一个实际的Servlet（继承于HttpServlet基类

4、原理

​ 当请求发起时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控住器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染结果，将结果返回给中心控制器，再将结果返回给请求者。

二、Hello，SpringMVC

1、新建一个Moudle，添加web的支持！

2、确定导入了SpringMVC的依赖

<!--依赖-->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
            <scope>provided</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

3、配置web.xml，注册DispatcherServlet

<!--1.注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet<servlet-class/>
        <!--关联一个springmvc的配置文件【servlet-name】-servlet.xml-->
        <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>

4、编写SpringMVC的配置文件！

名称：springmvc-servlet.xml：【servletname】-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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    
</beans>
       

5、添加处理映射器

<!--添加处理映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

6、添加处理器适配器

<!--添加处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

7、添加视图解析器

<!--添加视图解析器:DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceView" id="internalResourceView">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

8、编写我们要操作业务Controller

要么实现Controller接口，要么增加注解;需要返回一个 ModelAndView，装数据，封视图

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

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

public class HelloController implements Controller {


    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello");//: /WEB-INF/jsp/hello.jsp

        return mv;
    }
}

9、将自己的类交给SpringIOC容器，注册bean

 <!--Handler-->
    <bean id="/hello" class="com.darkerg.controller.HelloController"/>

10、写要跳转的jsp页面，显示ModelandView存放的数据，以及我们的正常页面。

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

${msg}

</body>
</html>

三、SpringMVC执行原理

四、SpringMVC使用注解配置

1、配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">
    <!--配置DispatcherServlet： 这个是SpringMVC的核心，请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定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>

</web-app>

2、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
        https://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.darkerg.controller"/>
    <!--让Spring MVC不处理静态资源 .css .js .html .mp3 .mp4-->
    <mvc:default-servlet-handler />
    <!--支持mvc注解驱动
        在spring中一般采用@RequestMapping注解完成映射关系， 要想使@RequestMapping注解生效，必须向上下文注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例，这两个实例分别在类级别和方法级别处理， 而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>

3、创建视图

在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

4、创建Controller

编写一个控制类：com.darkerg.controller.HelloController，注意编码规范。

package com.darkerg.controller;

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

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","Hello,SpringMVCAnnotation");

        return "hello"; //会被视图解析器处理；
    }

}

• @Controller是为了让Spring IOC容器初始化时自动扫描到。
• @RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时候应该是/HelloController/hello；
• 方法中声明Model类型的参数是为了把Action中的数据带到视图中。
• 方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp

5、创建视图层

hello.jsp

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

${msg}

</body>
</html>

6、总结

使用SpringMVC必须配置的三大件：

处理器映射器，处理器适配器，视图解析器

通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置。

五、Controller解析

1、控制器Controller

• 控制器复杂提供访问应用程序的行为，通常通过接口定义或者注解定义两字符方法实现。
• 控制器负责解析用户的请求并将其转换为一个模型。
• 在SpringMVC中，一个控制器类可以包含多个方法。
• 在SpringMVC中，对于Controller的配置方式有很多种。

2、使用接口配置控制器

public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello");//: /WEB-INF/jsp/hello.jsp

        return mv;
    }
}

2、使用注解@Contrller配置控制器

@Controller//代表这个类会被Spring接管，被这个注解的类中的所有方法，如果返回值是String，并且具有具体页面可以跳转，那么就会被视图解析器解析。
public class HelloController {

    @RequestMapping("/hello")//配置映射地址
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","Hello,SpringMVCAnnotation");

        return "hello"; //会被视图解析器处理；/WEB-INF/jsp/hello.jsp
    }

}

可以实现视图的复用！！只是里面的数据不一样了！

RequestMapping()也可以加在类上面，和方法上面形成父子的关系。

六、RestFul风格

1、概念

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

2、功能

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

使用传统方式操作资源：通过不同的参数来实现不同的效果！方法单一，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

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

3、学习测试

新建一个类RestFulController

在SpringMVC中可以使用@PathVariable注解，让方法参数的值对应绑定到一个URI模板变量上。

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

@Controller
public class RestFulController {

    //原来的：http://localhost:8080/add?a=1&b=2
    //RestFul：http://localhost:8080/add/a/b
    //eg:http://localhost:8080/add/1/2

    @RequestMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a,@PathVariable int b, Model model){
        int res = a+b;

        model.addAttribute("msg","结果为："+res);

        return "test";
    }

}

还可以限定请求的方式

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

也可以通过下面的方式来实现：

• @GetMapping
• @PostMapping
• @PutMapping
• @DeleteMapping
• @PatchMapping

七、转发和重定向

1、ServletAPI实现

通过设置Servlet API，不需要视图解析器。

• 通过HttpServletResponse进行输出
• 通过HttpServletResponse实现重定向
• 通过HttpServletResponse实现转发

@Controller
public class ModelTest1 {

    @RequestMapping("/m1/t1")
    public String test(HttpServletRequest req,HttpServletRequest resp){

        HttpSession session = req.getSession();
        System.out.println(session.getId());

        return "test";

    }

}

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

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

@Controller
public class ResultSpringMVC {

    @RequestMapping("/rsm/t1")
    public String test1(){
        //转发
        return "/index.jsp";
    }

    @RequestMapping("/rsm/t2")
    public String test2(){
        //转发二
        return "forward:/index.jsp";
    }

    @RequestMapping("/rsm/t3")
    public  String test3(){
        //重定向
        return "redirect:/index.jsp";
    }
}

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

重定向，不需要视图解析器，本质就是重新请求一个新地方，所以注意路径问题。

可以重定向到另外一个请求实现。

@Controller
public class ResultSpringMVC {

    @RequestMapping("/rsm/t1")
    public String test1(){
        //转发
        //默认情况下为转发
        return "test";
    }


    @RequestMapping("/rsm/t2")
    public  String test3(){
        //重定向
        return "redirect:/index.jsp";
        //return "redirect:hello.do;"//hello.do为另一个请求/
       
    }
}

八、SpringMVC数据处理

1、处理提交数据

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

提交数据：

http://localhost:8080/hello?name=darkerg

处理方法：

@RequestMapping("/hello")
public String hello(String name){
    System.out.println(name);
        return "hello";
}

后台输出：darkerg

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

提交数据

http://localhost:8080/hello?username=darkerg

处理方法：

//@RequestParam("username"):username提交的域的名称
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
    System.out.println(name);
    return "hello";
}

3、提交的是一个对象

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

实体类

public class User{
    private int id;
    private String name;
    private int age;
    //构造
    //get/set
    //toString()
}

提交数据

http://localhost:8080/mvc04/user?name=darkerg&id=1&age=18

处理方法：

@RequestMapping("/user")
public String user(User user){
    System.out.println(user);
    return "hello";
}

后台输出：User{id=1,name='darkerg',age=15}

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

2、数据显示到前端

第一种：通过ModelAndView

我们前面一直都是如此，就不过多解释。

public class ControllerTest1 implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello");//: /WEB-INF/jsp/hello.jsp

        return mv;
    }
    
}

第二种：通过ModelMap

ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name,ModelMap model){
    
    //封装要显示到视图中的数据
    //相当于req.setAttribute("name",name);
    model.addAttribute("name",name);
    System.out.println(name);
    
    return "hello";
    
}

第三种：通过Model

Model

@RequestMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a,@PathVariable int b, Model model){
        int res = a+b;

        model.addAttribute("msg","结果为："+res);

        return "test";
    }

使用区别

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

更多的是以后开发中考虑的性能和优化

3、解决乱码问题

测试步骤：

在首页编写一个提交的表单

<form action="/e/t" method"post">
    <input type='text' name="name">
    <input type="submit">
</form>

后台编写对应的处理类

@Controller
public class EncodingController {
    
    @RequestMapping("/e/t")
    public String test(Model model,String name){
        model.addAttribute("msg",name);//获取表单提交的值
        
       return "test";//跳转到test页面显示输入的值
    }
    
}

测试后，可能会出现乱码。

/ 和/的区别*

解决问题---过滤器

import javax.servlet.*;
import java.io.IOException;

public class EncodingFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");

        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {

    }
}

配置web.xml

<filter>
        <filter-name>encoding</filter-name>
        <filter-class>com.darkerg.filter.EncodingFilter</filter-class>
</filter>
<filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
</filter-mapping>

使用SpringMVC的乱码过滤器

在web.xml中配置

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

Tomcat编码的配置

修改tomcat配置文件：设置编码！

tomcat/conf/server.xml

<Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

使用大神的自定义过滤器

九、JSON

JSON的引入
前后端分离：

• 后端部署后端，提供接口，提供数据：写一个方法，前端可以远程的调用。

• Json：

• 前端独立部署，负责渲染后端的数据

1、什么是JSON

• JSON（JavaScript Object Notation，JS对象标记）是一种轻量级的数据交换格式，目前使用特别广泛。
• 采用完全独立与编程语言的文本格式来存储和表示数据。
• 简洁和清晰的层次结构使得JSON成为理想的数据交换语言。
• 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

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

JSON学习：

https://www.runoob.com/json/json-tutorial.html

2、JackSon的使用

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

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

• 配置SpringMVC需要的配置

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">
    <!--配置DispatcherServlet： 这个是SpringMVC的核心，请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定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>

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

• 编写一个实体类

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

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

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

}

• 编写控制器UserController

import com.darkerg.pojo.User;
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;

@Controller
//此处也可以写RestController，这样就都不走视图解析器了。直接返回字符串，就不需要下面的@RespinseBody了
public class UserController {

    //解决乱码问题
    @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")
    @ResponseBody//只要加了ResponseBody，这个方法就不会走视图解析器。会直接返回一个字符串
    public String json1() throws JsonProcessingException {

        //jackson，ObjectMapper
        ObjectMapper mapper = new ObjectMapper();

        //创建一个对象
        User user = new User("darkerg",3,"男");

        //这个方法可以把这个对象转化为一个字符串
        String str = mapper.writeValueAsString(user);

        return str;
    }

}

乱码问题的另外一种解决方案------SpirngMVC配置统一解决

<!--解决json 乱码配置-->
    <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>

3、返回多个对象的情况

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

        //jackson，ObjectMapper
        ObjectMapper mapper = new ObjectMapper();

        List<User> userList = new ArrayList<>();

        //创建一个对象
        User user1 = new User("darkerg1",3,"男");
        User user2 = new User("darkerg2",3,"男");
        User user3 = new User("darkerg3",3,"男");
        User user4 = new User("darkerg4",3,"男");

        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        String str = mapper.writeValueAsString(userList);

        return str;
    }

4、封装JsonUtils工具类

mport 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);

        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        
        return null;

    }
    
}

测试一：修改上面多个对象返回的情况

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

        //jackson，ObjectMapper
        ObjectMapper mapper = new ObjectMapper();

        List<User> userList = new ArrayList<>();

        //创建一个对象
        User user1 = new User("darkerg1",3,"男");
        User user2 = new User("darkerg2",3,"男");
        User user3 = new User("darkerg3",3,"男");
        User user4 = new User("darkerg4",3,"男");

        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);


        return JsonUtils.getJson(userList);
}

测试二：添加日期

@RequestMapping("/j3")
    public String json3(){
        Date date = new Date();

        return JsonUtils.getJson(date,"yyyy-MM-dd HH:mm:ss");
    }

5、FastJson

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

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

        //jackson，ObjectMapper
        ObjectMapper mapper = new ObjectMapper();

        List<User> userList = new ArrayList<>();

        //创建一个对象
        User user1 = new User("darkerg1",3,"男");
        User user2 = new User("darkerg2",3,"男");
        User user3 = new User("darkerg3",3,"男");
        User user4 = new User("darkerg4",3,"男");

        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        String str = JSON.toJSONString(userList);

        return str;

    }