• SSM - Springboot - MyBatis-Plus 全栈体系（十九）

    第四章 SpringMVC

    二、SpringMVC 接收数据

    1. 访问路径设置

    • @RequestMapping 注解的作用就是将请求的 URL 地址和处理请求的方式（handler 方法）关联起来，建立映射关系。
    • SpringMVC 接收到指定的请求，就会来找到在映射关系中对应的方法来处理这个请求。
    1.1 精准路径匹配
    • 在@RequestMapping 注解指定 URL 地址时，不使用任何通配符，按照请求地址进行精确匹配。
    @Controller
public class UserController {

    /**
     * 精准设置访问地址 /user/login
     */
    @RequestMapping(value = {"/user/login"})
    @ResponseBody
    public String login(){
        System.out.println("UserController.login");
        return "login success!!";
    }

    /**
     * 精准设置访问地址 /user/register
     */
    @RequestMapping(value = {"/user/register"})
    @ResponseBody
    public String register(){
        System.out.println("UserController.register");
        return "register success!!";
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    1.2 模糊路径匹配
    • 在@RequestMapping 注解指定 URL 地址时，通过使用通配符，匹配多个类似的地址。
    @Controller
public class ProductController {

    /**
     *  路径设置为 /product/*
     *    /* 为单层任意字符串  /product/a  /product/aaa 可以访问此handler
     *    /product/a/a 不可以
     *  路径设置为 /product/**
     *   /** 为任意层任意字符串  /product/a  /product/aaa 可以访问此handler
     *   /product/a/a 也可以访问
     */
    @RequestMapping("/product/*")
    @ResponseBody
    public String show(){
        System.out.println("ProductController.show");
        return "product show!";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    单层匹配和多层匹配：
	/*：只能匹配URL地址中的一层，如果想准确匹配两层，那么就写“/*/*”以此类推。
	/**：可以匹配URL地址中的多层。

其中所谓的一层或多层是指一个URL地址字符串被“/”划分出来的各个层次
这个知识点虽然对于@RequestMapping注解来说实用性不大，但是将来配置拦截器的时候也遵循这个规则。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    1.3 类和方法级别区别
    • @RequestMapping 注解可以用于类级别和方法级别，它们之间的区别如下：
      • 设置到类级别：@RequestMapping 注解可以设置在控制器类上，用于映射整个控制器的通用请求路径。这样，如果控制器中的多个方法都需要映射同一请求路径，就不需要在每个方法上都添加映射路径。
      • 设置到方法级别：@RequestMapping 注解也可以单独设置在控制器方法上，用于更细粒度地映射请求路径和处理方法。当多个方法处理同一个路径的不同操作时，可以使用方法级别的 @RequestMapping 注解进行更精细的映射。
    //1.标记到handler方法
@RequestMapping("/user/login")
@RequestMapping("/user/register")
@RequestMapping("/user/logout")

//2.优化标记类+handler方法
//类上
@RequestMapping("/user")
//handler方法上
@RequestMapping("/login")
@RequestMapping("/register")
@RequestMapping("/logout")

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    1.4 附带请求方式限制
    • HTTP 协议定义了八种请求方式，在 SpringMVC 中封装到了下面这个枚举类：
    public enum RequestMethod {
  GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE
}

    • 1
    • 2
    • 3
    • 默认情况下：@RequestMapping(“/logout”) 任何请求方式都可以访问！
    • 如果需要特定指定：
    @Controller
public class UserController {

    /**
     * 精准设置访问地址 /user/login
     * method = RequestMethod.POST 可以指定单个或者多个请求方式!
     * 注意:违背请求方式会出现405异常!
     */
    @RequestMapping(value = {"/user/login"} , method = RequestMethod.POST)
    @ResponseBody
    public String login(){
        System.out.println("UserController.login");
        return "login success!!";
    }

    /**
     * 精准设置访问地址 /user/register
     */
    @RequestMapping(value = {"/user/register"},method = {RequestMethod.POST,RequestMethod.GET})
    @ResponseBody
    public String register(){
        System.out.println("UserController.register");
        return "register success!!";
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 注意：违背请求方式，会出现 405 异常！！！
    1.5 进阶注解

    • 还有 @RequestMapping 的 HTTP 方法特定快捷方式变体：

      • @GetMapping
      • @PostMapping
      • @PutMapping
      • @DeleteMapping
      • @PatchMapping
    @RequestMapping(value="/login",method=RequestMethod.GET)
||
@GetMapping(value="/login")

    • 1
    • 2
    • 3
    • 注意：进阶注解只能添加到 handler 方法上，无法添加到类上！
    1.6 常见配置问题
    • 出现原因：多个 handler 方法映射了同一个地址，导致 SpringMVC 在接收到这个地址的请求时该找哪个 handler 方法处理。

    There is already ‘demo03MappingMethodHandler’ bean method com.alex.mvc.handler.Demo03MappingMethodHandler#empGet() mapped.

    2. 接收参数

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

    1. 参数编码：

      param 类型的参数会被编码为 ASCII 码。例如，假设 name=john doe，则会被编码为 name=john%20doe。而 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 参数接收
    2.2.1 直接接值
    2.2.1.1 客户端请求

    在这里插入图片描述

    2.2.1.2 handler 接收参数
    • 只要形参数名和类型与传递参数相同，即可自动接收!
    @Controller
@RequestMapping("param")
public class ParamController {

    /**
     * 前端请求: http://localhost:8080/param/value?name=xx&age=18
     *
     * 可以利用形参列表,直接接收前端传递的param参数!
     *    要求: 参数名 = 形参名
     *          类型相同
     * 出现乱码正常，json接收具体解决！！
     * @return 返回前端数据
     */
    @GetMapping(value="/value")
    @ResponseBody
    public String setupForm(String name,int age){
        System.out.println("name = " + name + ", age = " + age);
        return name + age;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    2.2.2 @RequestParam 注解
    • 可以使用 @RequestParam 注释将 Servlet 请求参数（即查询参数或表单数据）绑定到控制器中的方法参数。
    • @RequestParam使用场景：
      • 指定绑定的请求参数名
      • 要求请求参数必须传递
      • 为请求参数提供默认值
    • 基本用法：
     /**
 * 前端请求: http://localhost:8080/param/data?name=xx&stuAge=18
 *
 *  使用@RequestParam注解标记handler方法的形参
 *  指定形参对应的请求参数@RequestParam(请求参数名称)
 */
@GetMapping(value="/data")
@ResponseBody
public Object paramForm(@RequestParam("name") String name,
                        @RequestParam("stuAge") int age){
    System.out.println("name = " + name + ", age = " + age);
    return name+age;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 默认情况下，使用此批注的方法参数是必需的，但可以通过将 @RequestParam 批注的 required 标志设置为 false！
    • 如果没有没有设置非必须，也没有传递参数会出现：
      在这里插入图片描述
    • 将参数设置非必须，并且设置默认值：
    @GetMapping(value="/data")
@ResponseBody
public Object paramForm(@RequestParam("name") String name,
                        @RequestParam(value = "stuAge",required = false,defaultValue = "18") int age){
    System.out.println("name = " + name + ", age = " + age);
    return name+age;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    2.2.3 特殊场景接值
    2.2.3.1 一名多值
    • 多选框，提交的数据的时候一个 key 对应多个值，我们可以使用集合进行接收！
      /**
   * 前端请求: http://localhost:8080/param/mul?hbs=吃&hbs=喝
   *
   *  一名多值,可以使用集合接收即可!但是需要使用@RequestParam注解指定
   */
  @GetMapping(value="/mul")
  @ResponseBody
  public Object mulForm(@RequestParam List<String> hbs){
      System.out.println("hbs = " + hbs);
      return hbs;
  }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    2.2.3.2 实体接收
    • Spring MVC 是 Spring 框架提供的 Web 框架，它允许开发者使用实体对象来接收 HTTP 请求中的参数。通过这种方式，可以在方法内部直接使用对象的属性来访问请求参数，而不需要每个参数都写一遍。下面是一个使用实体对象接收参数的示例：
    • 定义一个用于接收参数的实体类：
    public class User {

  private String name;

  private int age = 18;

  // getter 和 setter 略
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 在控制器中，使用实体对象接收，示例代码如下：
    @Controller
@RequestMapping("param")
public class ParamController {

    @RequestMapping(value = "/user", method = RequestMethod.POST)
    @ResponseBody
    public String addUser(User user) {
        // 在这里可以使用 user 对象的属性来接收请求参数
        System.out.println("user = " + user);
        return "success";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 在上述代码中，将请求参数 name 和 age 映射到实体类属性上！要求属性名必须等于参数名！否则无法映射！
    • 使用 postman 传递参数测试：
      在这里插入图片描述
    2.3 路径 参数接收
    • 路径传递参数是一种在 URL 路径中传递参数的方式。在 RESTful 的 Web 应用程序中，经常使用路径传递参数来表示资源的唯一标识符或更复杂的表示方式。而 Spring MVC 框架提供了 @PathVariable 注解来处理路径传递参数。
    • @PathVariable 注解允许将 URL 中的占位符映射到控制器方法中的参数。
    • 例如，如果我们想将 /user/{id} 路径下的 {id} 映射到控制器方法的一个参数中，则可以使用 @PathVariable 注解来实现。
    • 下面是一个使用 @PathVariable 注解处理路径传递参数的示例：
     /**
 * 动态路径设计: /user/{动态部分}/{动态部分}   动态部分使用{}包含即可! {}内部动态标识!
 * 形参列表取值: @PathVariable Long id  如果形参名 = {动态标识} 自动赋值!
 *              @PathVariable("动态标识") Long id  如果形参名 != {动态标识} 可以通过指定动态标识赋值!
 *
 * 访问测试:  /param/user/1/root  -> id = 1  uname = root
 */
@GetMapping("/user/{id}/{name}")
@ResponseBody
public String getUser(@PathVariable Long id,
                      @PathVariable("name") String uname) {
    System.out.println("id = " + id + ", uname = " + uname);
    return "user_detail";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    2.4 json 参数接收
    • 前端传递 JSON 数据时，Spring MVC 框架可以使用 @RequestBody 注解来将 JSON 数据转换为 Java 对象。@RequestBody 注解表示当前方法参数的值应该从请求体中获取，并且需要指定 value 属性来指示请求体应该映射到哪个参数上。其使用方式和示例代码如下：
    2.4.1 前端发送 JSON 数据的示例：（使用 postman 测试）
    {
  "name": "张三",
  "age": 18,
  "gender": "男"
}

    • 1
    • 2
    • 3
    • 4
    • 5
    2.4.2 定义一个用于接收 JSON 数据的 Java 类，例如：
    public class Person {
  private String name;
  private int age;
  private String gender;
  // getter 和 setter 略
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    2.4.3 在控制器中，使用 @RequestBody 注解来接收 JSON 数据，并将其转换为 Java 对象
    @PostMapping("/person")
@ResponseBody
public String addPerson(@RequestBody Person person) {

  // 在这里可以使用 person 对象来操作 JSON 数据中包含的属性
  return "success";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 在上述代码中，@RequestBody 注解将请求体中的 JSON 数据映射到 Person 类型的 person 参数上，并将其作为一个对象来传递给 addPerson() 方法进行处理。
    2.4.4 完善配置
    • 测试：
      在这里插入图片描述
    • 问题： - org.springframework.web.HttpMediaTypeNotSupportedException: Content-Type ‘application/json;charset=UTF-8’ is not supported]
      在这里插入图片描述
    • 原因：
      • 不支持 json 数据类型处理
      • 没有 json 类型处理的工具（jackson）
    • 解决：
      • springmvc handlerAdpater 配置 json 转化器,配置类需要明确：
    //TODO: SpringMVC对应组件的配置类 [声明SpringMVC需要的组件信息]

//TODO: 导入handlerMapping和handlerAdapter的三种方式
 //1.自动导入handlerMapping和handlerAdapter [推荐]
 //2.可以不添加,springmvc会检查是否配置handlerMapping和handlerAdapter,没有配置默认加载
 //3.使用@Bean方式配置handlerMapper和handlerAdapter
@EnableWebMvc  //json数据处理,必须使用此注解,因为他会加入json处理器
@Configuration
@ComponentScan(basePackages = "com.alex.controller") //TODO: 进行controller扫描

//WebMvcConfigurer springMvc进行组件配置的规范,配置组件,提供各种方法! 前期可以实现
public class SpringMvcConfig implements WebMvcConfigurer {


}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • pom.xml 加入 jackson 依赖
    <dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-databindartifactId>
    <version>2.15.0version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    2.4.5 @EnableWebMvc 注解说明
    • @EnableWebMvc 注解效果等同于在 XML 配置中，可以使用 元素！我们来解析对应的解析工作！
    • 让我们来查看下具体的动作！
    2.4.5.1 先查看标签最终对应解析的 Java 类

    在这里插入图片描述

    2.4.5.2 查看解析类中具体的动作即可
    • 打开源码：org.springframework.web.servlet.config.MvcNamespaceHandler

    在这里插入图片描述

    • 打开源码：org.springframework.web.servlet.config.AnnotationDrivenBeanDefinitionParser
    class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {

  public static final String HANDLER_MAPPING_BEAN_NAME = RequestMappingHandlerMapping.class.getName();

  public static final String HANDLER_ADAPTER_BEAN_NAME = RequestMappingHandlerAdapter.class.getName();

  static {
    ClassLoader classLoader = AnnotationDrivenBeanDefinitionParser.class.getClassLoader();
    javaxValidationPresent = ClassUtils.isPresent("jakarta.validation.Validator", classLoader);
    romePresent = ClassUtils.isPresent("com.rometools.rome.feed.WireFeed", classLoader);
    jaxb2Present = ClassUtils.isPresent("jakarta.xml.bind.Binder", classLoader);
    jackson2Present = ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", classLoader) &&
            ClassUtils.isPresent("com.fasterxml.jackson.core.JsonGenerator", classLoader);
    jackson2XmlPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.xml.XmlMapper", classLoader);
    jackson2SmilePresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.smile.SmileFactory", classLoader);
    jackson2CborPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.cbor.CBORFactory", classLoader);
    gsonPresent = ClassUtils.isPresent("com.google.gson.Gson", classLoader);
  }


  @Override
  @Nullable
  public BeanDefinition parse(Element element, ParserContext context) {
    //handlerMapping加入到ioc容器
    readerContext.getRegistry().registerBeanDefinition(HANDLER_MAPPING_BEAN_NAME, handlerMappingDef);

    //添加jackson转化器
    addRequestBodyAdvice(handlerAdapterDef);
    addResponseBodyAdvice(handlerAdapterDef);

    //handlerAdapter加入到ioc容器
    readerContext.getRegistry().registerBeanDefinition(HANDLER_ADAPTER_BEAN_NAME, handlerAdapterDef);
    return null;
  }

  //具体添加jackson转化对象方法
  protected void addRequestBodyAdvice(RootBeanDefinition beanDef) {
    if (jackson2Present) {
      beanDef.getPropertyValues().add("requestBodyAdvice",
          new RootBeanDefinition(JsonViewRequestBodyAdvice.class));
    }
  }

  protected void addResponseBodyAdvice(RootBeanDefinition beanDef) {
    if (jackson2Present) {
      beanDef.getPropertyValues().add("responseBodyAdvice",
          new RootBeanDefinition(JsonViewResponseBodyAdvice.class));
    }
  }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
  • 相关阅读:
    工业机器人之“慧眼”——机器视觉
    计算机专业大学生应该怎么规划未来？
    x-api接口鉴权架构设计和实现【万字+深度】
    加速 PyTorch 模型预测常见方法梳理
    VSCode配置C和C++语言
    【算法合集】学习算法第三天（二叉树遍历篇）
    数据库设计三大范式
    1688API接口介绍详情
    Unity实现摄像机向屏幕中间发射射线射击物体
    RocketMQ
  • 原文地址：https://blog.csdn.net/sgsgkxkx/article/details/133580722