• SpringMVC的注解、参数传递、页面跳转

     

    一.SpringMvc常用注解

    常用注解

    @RequestMapping:@RequestMapping注解是一个用来处理请求地址映射的注解，可用于映射一个请求或一个方法，可以用在类或方法上。
    @RequestParam:@RequestParam主要用于将请求参数区域的数据映射到控制层方法的参数上

    @ModelAttribute:

    绑定请求参数到命令对象：放在功能处理方法的入参上时，用于将多个请求参数绑定到一个命令对象，从而简化绑定流程，而且自动暴露为模型数据用于视图页面展示时使用；

    暴露表单引用对象为模型数据：放在处理器的一般方法（非功能处理方法）上时，是为表单准备要展示的表单引用对象，如注册时需要选择的所在城市等，而且在执行功能处理方法（@RequestMapping注解的方法）之前，自动添加到模型对象中，用于视图页面展示时使用；

    暴露@RequestMapping方法返回值为模型数据：放在功能处理方法的返回值上时，是暴露功能处理方法的返回值为模型数据，用于视图页面展示时使用。

    @SessionAttributes:用于将数据存储到会话（Session）中，在多个请求之间共享数据。

    @RequestBody:用于将方法的返回值直接作为响应体返回给客户端，常用于返回JSON数据。

    @RequestHeader:使用 @RequestHeader 注解可以获取指定的请求头信息。

    @PathVariable:该注解请求URI中的模板变量部分到处理器功能处理方法的方法参数上的绑定。

    @CookieValue:@CookieValue注解主要是将请求的Cookie数据，映射到功能处理方法的参数上。
    使用人类思维解释

    解释：

    当你在使用 Spring MVC 框架来构建一个 Web 应用程序时，你会经常使用一些特殊的注解来告诉框架如何处理请求和数据。让我用更容易理解的方式解释这些注解：

    1. @RequestMapping: 这就像一个路标，告诉框架哪个方法应该处理特定的 URL 请求。你可以把它想象成一本地图上的指示牌，告诉你如何到达特定的目的地。

    2. @RequestParam: 当你需要从客户端请求中获取参数时，这个注解就派上用场了。它帮助你将请求中的数据映射到你的方法参数上，就像你从用户口中听到点菜的内容一样。

    3. @ModelAttribute: 这个注解有三种用法：

      • 当放在方法参数上时，它可以将多个请求参数绑定到一个命令对象，使得参数的绑定变得更加简单。想象一下，你收到了一个复杂的订单，这个注解可以帮助你将这个订单整理成一个简单的格式。
      • 当放在一般方法上时，它可以为表单准备要展示的数据，比如在注册页面中选择所在城市的选项。这样，数据会自动添加到模型对象中，以便在视图页面上展示。
      • 当放在功能处理方法（@RequestMapping 注解的方法）的返回值上时，它将方法的返回值暴露为模型数据，以便在视图页面上使用。

    4. @SessionAttributes: 这个注解用于将数据存储在会话（Session）中，以便在多个请求之间共享数据。就像你在不同的餐厅订了多道菜，然后在同一个餐厅一次一道地享用一样。

    5. @RequestBody: 当你想要将方法的返回值直接作为响应体返回给客户端时，可以使用这个注解。通常用于返回 JSON 数据，就像你点了一份外卖，外卖盒里就是你要的食物。

    6. @RequestHeader: 用于获取请求头的信息。你可以想象它为你提供了关于客户端请求的额外信息，就像你在餐馆里点菜时，服务员询问你的特殊要求。

    7. @PathVariable: 当你需要从请求的 URL 中提取特定的部分作为方法的参数时，可以使用这个注解。就像你在路上遇到一个特殊标志，告诉你需要走哪条路线。

    8. @CookieValue: 这个注解帮助你将请求的 Cookie 数据映射到方法的参数上。想象一下，你点了一份甜点，服务员将甜点的名字告诉你，这就是 CookieValue 的作用。

    这些注解就像是你与 Spring MVC 框架之间的沟通工具，它们帮助你更轻松地处理请求和数据，就像你在餐馆里处理订单和食物一样。

    二.参数传递

    pom.xml导入SLF4J的依赖

    1. <log4j2.version>2.9.1log4j2.version>
    2. <log4j2.disruptor.version>3.2.0log4j2.disruptor.version>
    3. <slf4j.version>1.7.13slf4j.version>
    4.  
    6.  
    10. <dependency>
    11. 	<groupId>org.slf4jgroupId>
    12. 	<artifactId>slf4j-apiartifactId>
    13. 	<version>${slf4j.version}version>
    14. dependency>
    15. <dependency>
    16. 	<groupId>org.slf4jgroupId>
    17. 	<artifactId>jcl-over-slf4jartifactId>
    18. 	<version>${slf4j.version}version>
    19. 	<scope>runtimescope>
    20. dependency>
    21.  
    23. <dependency>
    24. 	<groupId>org.apache.logging.log4jgroupId>
    25. 	<artifactId>log4j-apiartifactId>
    26. 	<version>${log4j2.version}version>
    27. dependency>
    28. <dependency>
    29. 	<groupId>org.apache.logging.log4jgroupId>
    30. 	<artifactId>log4j-coreartifactId>
    31. 	<version>${log4j2.version}version>
    32. dependency>
    34. <dependency>
    35. 	<groupId>org.apache.logging.log4jgroupId>
    36. 	<artifactId>log4j-slf4j-implartifactId>
    37. 	<version>${log4j2.version}version>
    38. dependency>
    40. <dependency>
    41. 	<groupId>org.apache.logging.log4jgroupId>
    42. 	<artifactId>log4j-webartifactId>
    43. 	<version>${log4j2.version}version>
    44. 	<scope>runtimescope>
    45. dependency>
    46.  
    48. <dependency>
    49. 	<groupId>com.lmaxgroupId>
    50. 	<artifactId>disruptorartifactId>
    51. 	<version>${log4j2.disruptor.version}version>
    52. dependency>

    1. 基础类型+String类型

    1. package com.liao.web;
    2.  
    3. import com.liao.model.Book;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.springframework.stereotype.Controller;
    6. import org.springframework.web.bind.annotation.*;
    7.  
    8. import javax.servlet.http.HttpServletRequest;
    9. import java.util.Map;
    10.  
    11. @Slf4j
    12. @Controller
    13. @RequestMapping("/param")
    14. public class ParamController {
    15.  
    16.     @RequestMapping("/hello1")
    17.     public String index(Integer bid ,String bname) {
    18.     log.info("简单参数：bid:{},bname:{} ",bid,bname);
    19.     return "index";
    20.     }
    21. }


    2. 复杂类型


       

    1. @RequestMapping("/hello2")
    2.     public String hello2(Book book , HttpServletRequest httpServletRequest) {
    3.         log.info("复杂参数：bid:{},bname:{} ",
    4.                 httpServletRequest.getParameter("bid"),
    5.                 httpServletRequest.getParameter("bname"));
    6.         log.info("复杂参数：book:{} ",
    7.                 book.toString());
    8.         return "index";
    9.     }


    3. @RequestParam
     

    1.     @RequestMapping("/hello3")
    2.     public String toHello3(@RequestParam Integer bid,
    3.                            @RequestParam(required = false,value = "price") Integer bookPrice,
    4.                            @RequestParam("bookName") String bname){
    5.         log.info(">>>> 使用@RequestParam注解传递参数：{},{},{}", bid,bname,bookPrice);
    6.         return "index";
    7.     }


    控制台输出

    不会输出任何结果。

    注：@RequestParam的required属性

     该参数是否为必传项。默认是true，表示请求中一定要传入对应的参数，否则会报404错误，如果设置为false时，当请求中没有此参数，将会默认为null,而对于基本数据类型的变量，则必须有值，这时会抛出空指针异常。如果允许空值，则接口中变量需要使用包装类来声明。
     

    4. @PathVariable
     

    1.  @RequestMapping("/hello4/{bid}")
    2.     public String toHello4(@PathVariable("bid") Integer bid){
    3.         log.info(">>>> 使用@PathVariable注解传递参数：{}", bid);
    4.         return "index";
    5.     }


     5.@RequestBody


    导入@RequestBody依赖

    1.  <jackson.version>2.9.3jackson.version>
    2.  
    3.  <dependency>
    4.       <groupId>com.fasterxml.jackson.coregroupId>
    5.       <artifactId>jackson-databindartifactId>
    6.       <version>${jackson.version}version>
    7.     dependency>
    8.     <dependency>
    9.       <groupId>com.fasterxml.jackson.coregroupId>
    10.       <artifactId>jackson-coreartifactId>
    11.       <version>${jackson.version}version>
    12.     dependency>
    13.     <dependency>
    14.       <groupId>com.fasterxml.jackson.coregroupId>
    15.       <artifactId>jackson-annotationsartifactId>
    16.       <version>${jackson.version}version>
    17.     dependency>

    测试代码

       

    1.  @RequestMapping("/hello5")
    2.     public String toHello5(@RequestBody Map map){
    3.         System.out.println(map);
    4.         return "index";
    5.     }


    请使用postman或者apipost/eolink等工具发送请求数据。因为浏览器无法携带集合参数，所以借助第三方软件进行测试。

    6. @RequestHeader
     

    1. @RequestMapping("/hello7")
    2.     public String toHello7(Book book, @RequestBody Map map, @RequestHeader("jwt") String jwt){
    3.         System.out.println(map);
    4.         System.out.println(book);
    5.         System.out.println(jwt);
    6.         return "index";
    7.     }

    参数传递注意事项

    Spring MVC 提供了多种方式来处理参数传递，但在某些情况下可能会遇到一些困难。以下是一些可能引起困难的情况和解决方法：

    1. 复杂对象传递: 当你需要传递复杂的对象作为参数时，可能需要确保请求中的参数名称与对象的字段名称匹配。解决方法是使用@ModelAttribute注解将请求参数映射到对象，或者使用合适的数据绑定工具，如Jackson来处理JSON数据。

    2. 路径变量和查询参数: 处理路径变量和查询参数时，确保你的@RequestMapping注解和方法参数与请求的URL匹配。Spring MVC可以根据请求的URL来自动解析这些参数。

    3. 参数验证: 参数验证是一个常见的需求，但可能会导致困难。你可以使用Spring的@Valid注解和javax.validation包中的验证注解来实现参数验证。

    4. 多部分文件上传: 如果需要上传文件，Spring MVC提供了MultipartFile作为参数类型，但处理文件上传可能会有一些复杂性。你需要配置适当的文件上传解析器，并确保前端表单以正确的方式提交文件。

    5. 复杂的请求映射: 当你的应用程序有多个控制器和请求映射时，可能需要小心管理请求的映射关系，以确保请求被正确路由到适当的处理方法。

    6. Session 数据: 在不同请求之间共享数据可能会有一些挑战，尤其是在集群环境中。使用@SessionAttributes注解可以在会话中存储和共享数据。

    7. 不同数据类型的参数: 处理不同数据类型的参数时，你需要确保数据类型的转换和验证是正确的。Spring MVC会尝试自动进行数据类型转换，但你需要确保你的参数和请求中的数据类型一致。

    虽然Spring MVC提供了强大的参数传递和绑定功能，但在复杂的应用程序中，可能需要仔细规划和调试，以确保参数传递不会引发问题。使用合适的注解、验证和数据绑定技术，可以解决大多数参数传递的困难。同时，详细的日志和调试工具也有助于识别和解决问题。

    三.方法返回值

    1.void


    ResponseUtil

    1. package com.liao.untils;
    2.  
    3. import com.fasterxml.jackson.databind.ObjectMapper;
    4.  
    5. import javax.servlet.http.HttpServletResponse;
    6. import java.io.PrintWriter;
    7.  
    8. public class ResponseUtil {
    9.  
    10.     public static void write(HttpServletResponse response,Object o)throws Exception{
    11.         response.setContentType("text/html;charset=utf-8");
    12.         PrintWriter out=response.getWriter();
    13.         out.println(o.toString());
    14.         out.flush();
    15.         out.close();
    16.     }
    17.     
    18.     public static void writeJson(HttpServletResponse response,Object o)throws Exception{
    19.         ObjectMapper om = new ObjectMapper();
    20.         write(response, om.writeValueAsString(o));
    21.     }
    22. }

    ReturnController 

    1. package com.liao.web;
    2.  
    3. import com.liao.untils.ResponseUtil;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6.  
    7. import javax.servlet.http.HttpServletResponse;
    8. import java.util.HashMap;
    9. import java.util.Map;
    10. @Controller
    11. @RequestMapping("/rs")
    12. public class ReturnController {
    13.  
    14.     @RequestMapping("/hello1")
    15.     public void hello1(HttpServletResponse response){
    16.         Map map=new HashMap<>();
    17.         map.put("code",200);
    18.         map.put("msg","添加成功");
    19.         try {
    20.             ResponseUtil.writeJson(response,map);
    21.         } catch (Exception e) {
    22.             e.printStackTrace();
    23.         }
    24.  
    25.     }
    26.  
    27. }

    2.String+model

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: 86158
    4.   Date: 2023/9/5
    5.   Time: 15:49
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <html>
    10. <head>
    11.     <title>Titletitle>
    12. head>
    13. <body>
    14. <h1>Helloh1>
    15. 名称：${name}
    16. 地址：${address}
    17. body>
    18. html>

     代码

    1. package com.liao.web;
    2.  
    3. import com.liao.untils.ResponseUtil;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.ui.Model;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7.  
    8. import javax.servlet.http.HttpServletRequest;
    9. import javax.servlet.http.HttpServletResponse;
    10. import java.util.HashMap;
    11. import java.util.Map;
    12.  
    13.  
    14. @Controller
    15. @RequestMapping("/rs")
    16. public class ReturnController {
    17.  
    18.     @RequestMapping("/hello2")
    19.     public String hello2(Model model,
    20.                        HttpServletRequest request){
    21.           model.addAttribute("name","张三");
    22.           request.setAttribute("address","嘿嘿嘿");
    23.       return "index";
    24.     }
    25.  
    26.  
    27. }

     四：ModelAndView

    1.  
    2. package com.liao.web;
    3.  
    4. import com.liao.untils.ResponseUtil;
    5. import org.springframework.stereotype.Controller;
    6. import org.springframework.ui.Model;
    7. import org.springframework.web.bind.annotation.RequestMapping;
    8. import org.springframework.web.servlet.ModelAndView;
    9.  
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12. import java.util.HashMap;
    13. import java.util.Map;
    14.  
    15.  
    16. @Controller
    17. @RequestMapping("/rs")
    18. public class ReturnController {
    19.  
    20.  
    21.     @RequestMapping("/hello3")
    22.     public ModelAndView hello3(){
    23.         ModelAndView mv=new ModelAndView();
    24.         mv.addObject("sign","打篮球");
    25.         mv.setViewName("index");
    26.         return mv;
    27.     }
    28. }

    四、页面跳转


    在Spring MVC中，页面跳转可以通过转发（forward）或重定向（redirect）来实现。

    1. @RequestMapping("/hello6")
    2.     public String hello6() throws Exception {
    3.         System.out.println("hello6");
    4.         return "forward:hello2";
    5.     };


    转发（forward）

    使用请求转发将请求发送到另一个URL路径上进行处理，客户端的URL地址不会变化。这种方式适用于不同请求之间的跳转和处理，可以共享请求的上下文数据。

    1.  @RequestMapping("/hello7")
    2.     public String hello7() throws Exception {
    3.         System.out.println("hello6");
    4.         return "forward:/param//hello1";
    5.     };


    重定向（redirect）

    使用重定向将请求发送到另一个URL路径上进行处理，客户端的URL地址会改变。这种方式适用于不同请求之间的跳转和处理，可以避免表单重复提交等问题。
     

    1.  @RequestMapping("/hello9")
    2.     public String hello9() throws Exception {
    3.         System.out.println("hello6");
    4.         return "redirect:/param//hello1";
    5.     };

  • 相关阅读:
    线性代数 | 矩阵运算 加减 数乘 矩阵的幂运算
    selenium 等待方式
    Windows系统使用powershell查找并删除重复文件
    Paper Reading《Torch.manual_seed(3407) is all you need》
    微服务学习第三十三节
    字节架构师分析Spring Boot源码：日志、缓存、Web服务等
    邮戳锁StampedLock
    java计算机毕业设计基于springboot 垃圾回收分类网站
    Android TV Test蓝牙互操作性
    CocosCreator3.8研究笔记（二十三）CocosCreator 动画系统-动画编辑器相关功能面板说明
  • 原文地址：https://blog.csdn.net/liaozhixiangjava/article/details/132693596