Java29：Spring MVC

一：Springmvc简介

1.简介：

Spring Web MVC 是基于Servlet API构建的原始Web框架，从一开始就包含在Spring Framework中。正式名称"Spring Web MVC" 来自其源模块名称（spring-webmvc）但它通常被称为"Spring Mvc"

在控制层框架历经 Strust ,WebWork,Strust2等诸多产品的历代更迭之后，目前业界普遍选择了Spring MVC 作为JavaEE 项目表述层开发的首先方案。

优势：

》Spring 家族的原生产品，与IOC容器等基础设施无缝对接

》表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案

》代码清新简洁，大幅度提升开发效率

》 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可

》性能卓著，尤其适合现代大型/超大型互联网项目要求

2.作用：

3.核心组件：

1.DispatcherServlet:SpringMVC提供，我们需要使用web.xml配置使其生效，它式整个流程处理的核心，所有请求都经过它的处理和分发

2.HandlerMapping：SpringMVC提供，我们需要进行Ioc配置使其假如Ioc容器方可生效，它内部缓存handler和handler访问路径数据，被DispatcherServlet调用，用于查找路径对应的handler！

3.HandlerAdapter：SpringMVC提供，我们需要进行Ioc配置使其假如Ioc容器方可生效，它可以

处理请求参数和处理响应数据，每次DispatcherServlet都是通过HandlerAdapter间接调用handler,它是handler和DispatcherServlet之间的适配器

4.Handler：handler又称为处理器，它是Controller类内部方法的简称，是由我们自己定义，用来接收参数，向后调用业务，最终返回响应结果！

5.ViewResovler： SpringMVC提供，我们需要进行Ioc配置使其假如Ioc容器方可生效，视图解析器主要作用简化模板视图页面查找的，但是需要注意，前后端分离项目，后端只返回JSON数据，不返回界面，那就不需要视图解析器，相对其他组件不是必须的。

二：快速入门程序

步骤1：创建项目并导入依赖：

<dependency>
    <groupId>jakarta.platform</groupId>
    <artifactId>jakarta.jakartaee-web-api</artifactId>
    <version>9.1.0</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.0.6</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>6.0.6</version>
</dependency>

步骤2：创建控制层处理器并添加注解

@Controller

public class HelloHandler {
    @RequestMapping("spring/hello")//配置访问路径
    @ResponseBody //返回前端字符串，不调用视图解析器
    public String hello(){
        System.out.println("hello handler");
        return "hello springmvc";
    }
}

步骤3：创建配置类

@Configuration
@ComponentScan("com.cn.handler")
public class MyConfig {


    @Bean
    public  RequestMappingHandlerMapping  getRequestMapping(){

        RequestMappingHandlerMapping requestMappingHandlerMapping = new RequestMappingHandlerMapping();
        return requestMappingHandlerMapping;

    }
    @Bean
    public RequestMappingHandlerAdapter getRequestMappingHandlerAdapter(){

        RequestMappingHandlerAdapter requestMappingHandlerAdapter = new RequestMappingHandlerAdapter();
        return requestMappingHandlerAdapter;
    }


}

步骤4：加载配置类并初始化容器

package com.cn.config;

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.server.adapter.AbstractReactiveWebInitializer;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class SpringMvcInit extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }
    //指定配置类
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{MyConfig.class};
    }
  //设置DispatcherServlet的处理路径，一般情况下 /代表处理所有请求
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

步骤5：工程设置为web工程，并部署到tomcat（10.0以上版本）

1. 工程右键-选择JBLJavaToWeb 把工程设置为web工程

2.把工程部署到tomcat，并重启服务

3.浏览器地址输入：http://localhost:8080/spring/hello

4.浏览器显示：hello springmvc 表示程序运行成功

三：Spring MVC接收数据

1.访问路径设置：

@RequestMapping注解的作用就是将请求的URL地址和处理请求的方式（handler 方法）关联起来，建立映射关系。

SpringMVC接收到指定的请求，就会来找到在映射关系中对应的方法来处理这个请求。@RequestMapping(不用必须使用/开头) user/login

1.精准地址【1个|多个】/user/login {"地址1"，"地址2"}

2.支持模糊 * 任意一层字符串| **任意层任意字符串

/user/* -> /user/a user/aaaa 可以， /user/a/b 不行

/user/** -> /user/a /user/a/a/a/a

3.类上和方法上添加@RequestMapping的区别

类上提取通用的访问地址

方法上时具体的handler地址

访问： 类地址+方法地址即可

4.请求方式指定

客户端-> http(get|post|put|delete)->ds->handler

默认情况：@RequestMapping("login")主要地址正确，任何请求方式都可以访问

指定请求方式：method={RequestMethod.GET,RequestMethod.POST}

不符合请求方式：会出现405异常！

5注解进阶：

get @GetMapping ==@RequestMapping(xxx,method=GET);

post@PostMapping ==@RequestMapping(xxx,method=POST);

put@PUTMapping ==@RequestMapping(xxx,method=PUT);

delete@DeleteMapping ==@RequestMapping(xxx,method=DELETE);

2.参数接收：

2.1 param和json参数比较

在http请求中，我们可以选择不同的参数类型，如 param 类型和JSon类型。下面对这两种参数类型进行区别和对比：

1.参数编码：

param 类型的参数被编码为ASCII码。JSON类型会被编码为UTF-8

2.参数顺序：

param类型的参数没有顺序限制。但是，JSON类型的参数是有序的。JSON采用键值对的形式进行传递，其中键值对是有序排列的

3.数据类型：

param类型的参数仅支持字符串类型，数值类型和布尔类型等简单数据类型。而JSON类型的参数则支持更复杂的数据类型，如数组，对象等。

4.嵌套性：

param类型的参数不支持嵌套。但是，JSON类型的参数支持嵌套，可以传递更为复杂的数据结构。

5.可读性：

param 类型的参数格式比JSON类型的参数更加简单，易读。但是JSON格式在传递嵌套数据结构时更加清晰易懂。

总的来说，param类型的参数适用于单一的数据传递，而JSON类型的参数则更适用于更复杂的数据结构传递。根据具体的业务需求，需要选择合适的参数类型。在实际开发中，常见的做法是：在GET请求中采用param类型的参数，而在POST请求中采用JSON类型的参数传递。

2.2 param接收参数：

@Controller
@RequestMapping("user")
public class MyHandler {
     /*
     * 1 直接接收
     * /user/login?name=root&age=18
     * 形参列表，填写对应名称的参数即可！请求参数名=形参参数名即可！
     * 1）名称相同
     * 2）可以不传递，不报错
     *
     * */

    @RequestMapping("/login")
    @ResponseBody
    public String login(String name,int age){
        System.out.println("name = " + name + ", age = " + age);

        return "name = " + name + ", age = " + age;
    }

    /*
     * 2 注解指定
     * 指定任意的请求参数名，要求必须传递  ，要求不必须传递，给一个默认值
     * /user/login?account=root&age=18
     * account必须传递 ，page可以必须传递，如果不传递默认值就是1
         @RequestParam-> 形参列表 指定请求参数名 或者是否必须传递，或者非必须传递设置默认值
         用法：@RequestParam(value="指定请求参数名，如果形参名和请求参数名一致，可以省略！",
         required=false 前端是否必须传递此参数，默认是必须，不传400异常！,
         * defaultValue="1" 当非必须传递false，可以设置默认值)
     *
     * */
    @RequestMapping("/login2")
    @ResponseBody
    public String login2(@RequestParam("account")String name, @RequestParam(required = false,defaultValue = "10") int age){
        System.out.println("name = " + name + ", age = " + age);

        return "name = " + name + ", age = " + age;
    }
    /*
     * 3 特殊值
     * /user/login3?hbs=吃&hbs=喝
     * 不加注解@RequestParam 将hbs对应的一个字符串直接赋值给集合！ 类型异常！
     * 加了注解，会将集合加入对应的字符串
     * */
    @RequestMapping("/login3")
    @ResponseBody
    public String login3(@RequestParam  List<String> hbs){
        System.out.println(hbs);

        return hbs.toString();
    }
    /*
     * 4 使用实体对象接值
     * /user/login4?name=tom&age=10  准备一个对应属性和get|set 方法的实体类即可，
     * 形参列表声明对象参数即可！
     * */

    @RequestMapping("/login4")
    @ResponseBody
    public String login3(User user){
        System.out.println("name = " + user.getName() + ", age = " + user.getAge());

        return "name = " + user.getName() + ", age = " + user.getAge();
    }

}

2.3 路径传参：

@Controller
@RequestMapping("path")
@ResponseBody
public class PathHandler {
      // path/用户名/密码
     //动态路径设计{key}
    //必须使用 注解@PathVariable
    @RequestMapping("{name}/{password}")
    public String  hello(@PathVariable String name , @PathVariable String password){

        System.out.println("name = " + name + ", password = " + password);
     return "name = " + name + ", password = " + password;

    }
}

2.4 JSON数据接收（重点）：

前端传递JSON数据时，SpringMVC 框架可以使用@RequestBody 注解 来将JSON

数据转换为Java对象，@RequestBody 注解表示当前方法参数的值应该从请求体中获取，并且需要指定value 属性来指示请求体应该映射到哪个参数上，其使用方式和示类代码如下：

步骤1 .前端发送JSON数据（使用postman）

{"name":"zhangsan","age":18,"gender":"男"}

步骤2.定义一个用于接收JSON数据的Java 类

@Data
public class Person {
    private String name;
    private int age;
    private String gender;
}

步骤3.在控制器中使用@RequestBody注解来接收JSON数据，并将器转换为Java对象：

@Controller
@RequestMapping("json")
@ResponseBody
public class JsonHandler {

    @PostMapping("data")
    public String data(@RequestBody Person person){
        System.out.println("person = " + person);
        return person.toString();
    }

}

步骤4：添加JSON解析依赖：

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

步骤5：在配置类添加注解：@EnableWebMvc，给SpringMVC HandlerAdpater配置JSON转换器

@EnableWebMvc
@Configuration
@ComponentScan("com.cn.json")
public class MyConfig {}

步骤6：测试并查看响应数据：

Person(name=zhangsan, age=18, gender=nan)

2.5 cookie和Header接收：

1.使用@CookieValue 注解获取cookie数据

存取cookie

@GetMapping("save")
public String save(HttpServletResponse httpResponse){
    Cookie  cookie = new Cookie("cookieName","cookieValue");
    httpResponse.addCookie(cookie);
    return "ok";
}

获取cookie

 @RequestMapping("data")
public String data(@CookieValue(name="cookieName") String value){
    System.out.println("value = " + value);

    return value;
}

2.使用注解@RequestHeader 获取header信息

@Controller
@ResponseBody
@RequestMapping("header")
public class HeaderController {
    @GetMapping("data")
    public String  data(@RequestHeader(value = "Host") String host){
        System.out.println("host = " + host);
        return host;
    }

}

2.6 接收数据总结：

四：Spring MVC响应数据

1.开发模式介绍:

在Web开发中，有两种主要的开发模式：前后端分离和混合开发

前后端分离模式（重点）

指将前端的界面和后端的业务逻辑通过接口分离开发的一种方式。开发人员使用不同的

技术和框架，前端开发人员主要负责界面的呈现和用户交互，后端开发人员主要

负责业务逻辑和数据存储。前后端通信通过API接口完成，数据格式一般使用JSON

或XML。前后端分离模式可以提高开发效率，同时也有助于代码重用和维护。

混合开发模式：

指将前端和后端的代码集成在同一个项目中，共享相同的技术栈和框架。这种模式在

小型项目中比较常见，可以减少学习成本和部署难度。但是，在大型项目中，这种模式

会导致代码耦合性很高，维护和升级难度较大。

2.快速返回逻辑视图：

1.创建项目并添加依赖：

<dependency>
    <groupId>jakarta.servlet.jsp.jstl</groupId>
    <artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
    <version>3.0.0</version>
</dependency>

2. 在WEB-INF下创建视图目录和jsp文件：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
 <font color="red">${data}</font>
</body>
</html>

3. 在配置类下配置视图解析器

@Configuration
@ComponentScan("com.cn.controller")
@EnableWebMvc
public class Myconfig  implements WebMvcConfigurer {
// 视图解析器，指定前后缀
public  void configureViewResolvers(ViewResolverRegistry registry) {
        registry.jsp("/WEB-INF/views/",".jsp");
    }

}

4.创建handler

@Controller
@RequestMapping("jsp")
public class JspHandler {

    /*
    * 快速查找视图方法
    * 1.方法的返回值是字符串类型
    * 2.不能添加ResponseBody,直接返回字符串给浏览器，不找视图，不走视图解析器
    * 3.返回值 对应中间的视图名称即可
   
    * */
    @GetMapping("index")
    public String  data(HttpServletRequest request){
      request.setAttribute("data","hello jsp!");
        return "index";
    }
}

5.创建初始化接口

import com.cn.config.Myconfig;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class SpringMvcInit  extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{Myconfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

6.转换为web项目部署到服务器 并测试：

浏览器输入：http://localhost:8080/jsp/index

3.转发重定向：

@Controller
@RequestMapping("jsp")
public class JspHandler {

    /*
    * 快速查找视图方法
    * 1.方法的返回值是字符串类型
    * 2.不能添加ResponseBody,直接返回字符串给浏览器，不找视图，不走视图解析器
    * 3.返回值 对应中间的视图名称即可
    *
    *
    * */
    @GetMapping("index")
    public String  data(HttpServletRequest request){
      request.setAttribute("data","hello jsp!");
        return "index";
    }
  /*
  * 转发：只能是项目下的资源
  * 1.方法的返回值写成字符串
  * 2.不能添加ResponseBody注解
  * 3.返回的字符串前 forward：+/转发地址
  *
  * */

    @GetMapping("forward")
    public String forward(){

        System.out.println("jsp forward");
        return "forward:/jsp/index";

    }
    /*
     * 重定向：即可以是项目下的资源，也可以是项目外的资源
     * 1.方法的返回值写成字符串
     * 2.不能添加ResponseBody注解
     * 3.返回的字符串前 redirect：+/转发地址
     *
     * */

    @GetMapping("redirect")
    public String redirect(){

        System.out.println("jsp redirect");
        return "redirect:/jsp/index";

    }



    @GetMapping("redirect/baidu")
    public String redirectbaidu(){

        System.out.println("jsp redirect");
        return "redirect:http://www.baidu.com";

    }

}

4.返回JSON数据（重点）：

步骤1：新建项目并导入依赖：

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

步骤2：创建配置类

@Configuration
@ComponentScan("com.cn.handler")
@EnableWebMvc
public class MyConfig {
}

步骤3：创建SpringMvc初始化类

package com.cn.init;

import com.cn.config.MyConfig;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class SpringMvcInit  extends AbstractAnnotationConfigDispatcherServletInitializer {


    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{MyConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

步骤4：创建 返回的json对应的实体类

import lombok.Data;

@Data
public class User {

    private String name;
    private String gender;
    private int age;
}

步骤5：创建Handler

@Controller
@RequestMapping("json")
@ResponseBody//返回json的注解，不找视图
public class JsonHandler {

    //返回单个实体类的json数据
    @GetMapping("data")
    public User data(){
        User user =new User();
        user.setName("zhangsan");
        user.setAge(18);
        user.setGender("man");
        return  user;
    }


    //返回集合对应的json数据
        @GetMapping("data2")
        public List<User> data2(){

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

            User user1 =new User();
            user1.setName("zhangsan");
            user1.setAge(18);
            user1.setGender("man");
            User user2 =new User();
            user2.setName("lisi");
            user2.setAge(20);
            user2.setGender("woman");
            list.add(user1);
            list.add(user2);
            return  list;
        }
}

步骤6：部署并测试：

浏览器输入地址：http://localhost:8080/json/data

返回结果：

{"name":"zhangsan","gender":"man","age":18}

浏览器输入地址：http://localhost:8080/json/data2

[{"name":"zhangsan","gender":"man","age":18},{"name":"lisi","gender":"woman","age":20}]

5.访问静态资源：

在配置类中重写方法，开启静态资源查找

@Configuration
@ComponentScan("com.cn.handler")
@EnableWebMvc
public class MyConfig  implements WebMvcConfigurer {


    /*
    开启静态资源查找
    dispatcherServlet->handlerMapping 找有没有对应的handler->没有，找有没有静态资源
    * */
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}

五：其他扩展功能

1.restful 介绍和理解：

1）简介：

2）设计规范：

3）实战

1.需求

2.设计

3.实现：

package com.cn.controller;


import com.cn.pojo.User;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("user")
public class UserController {
     //分页查询
    @GetMapping
    public List<User> page(@RequestParam(required = false,defaultValue = "1") int page ,@RequestParam(required = false,defaultValue = "10") int size){
        return null;
    }
    //用户添加
@PostMapping
    public User save(@RequestBody  User user){

        return user;
    }
    //用户详情
    @GetMapping("{id}")
    public User  detail(@PathVariable int id){
        return null;

    }
    //用户更新
    @PutMapping()
    public User update(@RequestBody User user){
        return user;
    }
 //用户删除
@DeleteMapping("{id}")
    public int delete(@PathVariable  int id){
        return 0;
}
    //用户模糊
public  List<User> search(String keyword,@RequestParam(required = false,defaultValue = "1") int page,@RequestParam(required = false,defaultValue = "10") int size){
        return null;
    }
}

2.全局处理异常：

1.异常处理的方式:

2全局异常处理步骤：

步骤1：声明全局异常处理类并添加注解@RestControllerAdvice

步骤2：在该类中通过添加注解@ExceptionHandler(指定异常.class) 声明handler方法，处理异常

步骤3：在配置类中扫描类中把该包加进去

3.实战：

1）产生异常的handler

@RestController
@RequestMapping("user")
public class UserHandler {

    @GetMapping("data")
    public String data(){
        String s1=null;
        int length = s1.length();//java.lang.NullPointerException
        return "ok";

    }
    @GetMapping("data1")
    public String data1(){
   int i= 10/0;//   java.lang.ArithmeticException: / by zero
        return "ok2";

    }

}

2）全局处理异常的类

package com.cn.excption;

import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@RestControllerAdvice
public class GlobelExceptionHandler {
// 发生异常->ControllerAdvice 注解的类型-》  @ExceptionHandler(指定异常类型）-》handler
   @ExceptionHandler(NullPointerException.class)
    public  Object  PowerPointHandler(NullPointerException e){
       String message = e.getMessage();

      return message;


   }


    @ExceptionHandler(Exception.class)
    public  Object OtherHandler(Exception e){
        String message = e.getMessage();

        return message;


    }
}

3）把异常处理类添加到配置类扫描中，初始化类省略（SpringMvcInit）

@Configuration
@ComponentScan({"com.cn.handler","com.cn.excption"})
@EnableWebMvc
public class Myconfig {
}

3.拦截器：

1.拦截器和过滤器区别：

2.拦截器使用：

步骤1：创建拦截器：

public class MyInterceptor  implements HandlerInterceptor {

    @Override

    //在处理请求的目标handler方法前执行
    //一般用于编码格式设置，登录保护，权限处理
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("preHandle------------------");
        //返回true 放行，返回false：不放行
        return true;
    }

    @Override
    //在目标handler方法之后，handler报错不执行！
    //此方法只有在preHandle返回true后才执行， 对结果处理，敏感词汇检查   
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle------------------");
    }

    @Override
    //渲染视图之后执行，一定执行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion------------------");

    }
}

步骤2：在配置类中开启拦截器，并设置拦截路径

@Configuration
@ComponentScan("com.cn.handler")
@EnableWebMvc
public class MyConfig implements WebMvcConfigurer {


    @Override
    //开启拦截器
    public void addInterceptors(InterceptorRegistry registry) {
        //拦截所有
      // registry.addInterceptor(new MyInterceptor());
       //拦截指定地址
       registry.addInterceptor(new MyInterceptor()).addPathPatterns("/user/data1");
    }
}

4.参数校验注解jsr303：

1.校验概述：

jsr303 是java为Bean数据合法性校验提供的标准框架，他已经包含在JAVAEE6.0标准中，jsr303通过在Bean属性上标注类似于@NotNull，@Max等标准的注解指定校验规则，并通过标准的接口对Bean进行验证。

2.校验实现：

步骤1：导入jar包

    <dependency>
        <groupId>org.hibernate.validator</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>8.0.0.Final</version>
    </dependency>
    
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-validator-annotation-processor</artifactId>
        <version>8.0.0.Final</version>
    </dependency>
</dependencies>

步骤2：在实体类添加校验注解

@Data
public class User {
    /*
    1.name 不为null和空字符串
    字符串@NotBlank 集合@NotEmpty 包装类@NotNull
    2.password长度大于6
    3.age必须》=1
    4.email 邮件格式的字符串
    5.birthday过去实际
    *
    *
    * */
    @NotBlank
    private String name;
    @Length(min = 6)
    private String password;
    @Min(1)
    private int age;
    @Email
    private String email;
    @Past
    private Date birthday;
}

步骤3：handler 添加注解@Validated，如果自定义返回异常，添加BindingResult，获取错误信息

@RestController
@RequestMapping("user")
public class RegisterHandler {

    /*
    * 步骤1：实体类添加校验注解
    * 步骤2：handler(@Validated 实体类 对象)
    * 细节：param|json校验都有效果
    *      json参数-@RequestBody
    * 如果不符合校验规则，直接向前端抛出异常
    * 接收绑定错误信息，自定义返回结果，约定参数错误-》{code：400}
    *
    * 捕捉绑定信息
    * 1.handler（校验对象，BindingResult result）要求：BindingResult必须紧挨着校验对象
    * 2.BindingResult获取绑定错误
    *
    * */
    @PostMapping("register")

        public Object  register(@Validated @RequestBody User user){
 // 自定义返回异常代码       
//    public Object  register(@Validated @RequestBody User user, BindingResult result){
//        if(result.hasErrors()){
//            Map map = new HashMap();
//            map.put("code",400);
//            map.put("msg","参数校验异常");
//            return map;
//
//        }

        return user;
    }
}

步骤4：测试

1）正常情况：

2）自定义异常：