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

野性酷女 2023-10-15 16:55 35阅读 0赞

## 一.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的依赖

<log4j2.version>2.9.1</log4j2.version>
    <log4j2.disruptor.version>3.2.0</log4j2.disruptor.version>
    <slf4j.version>1.7.13</slf4j.version>
     
    
     
    
    
    
    <dependency>
    	<groupId>org.slf4j</groupId>
    	<artifactId>slf4j-api</artifactId>
    	<version>${slf4j.version}</version>
    </dependency>
    <dependency>
    	<groupId>org.slf4j</groupId>
    	<artifactId>jcl-over-slf4j</artifactId>
    	<version>${slf4j.version}</version>
    	<scope>runtime</scope>
    </dependency>
     
    
    <dependency>
    	<groupId>org.apache.logging.log4j</groupId>
    	<artifactId>log4j-api</artifactId>
    	<version>${log4j2.version}</version>
    </dependency>
    <dependency>
    	<groupId>org.apache.logging.log4j</groupId>
    	<artifactId>log4j-core</artifactId>
    	<version>${log4j2.version}</version>
    </dependency>
    
    <dependency>
    	<groupId>org.apache.logging.log4j</groupId>
    	<artifactId>log4j-slf4j-impl</artifactId>
    	<version>${log4j2.version}</version>
    </dependency>
    
    <dependency>
    	<groupId>org.apache.logging.log4j</groupId>
    	<artifactId>log4j-web</artifactId>
    	<version>${log4j2.version}</version>
    	<scope>runtime</scope>
    </dependency>
     
    
    <dependency>
    	<groupId>com.lmax</groupId>
    	<artifactId>disruptor</artifactId>
    	<version>${log4j2.disruptor.version}</version>
    </dependency>

#### 1. 基础类型+String类型 ####

package com.liao.web;
     
    import com.liao.model.Book;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.*;
     
    import javax.servlet.http.HttpServletRequest;
    import java.util.Map;
     
    @Slf4j
    @Controller
    @RequestMapping("/param")
    public class ParamController {
     
        @RequestMapping("/hello1")
        public String index(Integer bid ,String bname) {
        log.info("简单参数：bid:{},bname:{} ",bid,bname);
        return "index";
        }
    }

####    2. 复杂类型 ####

@RequestMapping("/hello2")
        public String hello2(Book book , HttpServletRequest httpServletRequest) {
            log.info("复杂参数：bid:{},bname:{} ",
                    httpServletRequest.getParameter("bid"),
                    httpServletRequest.getParameter("bname"));
            log.info("复杂参数：book:{} ",
                    book.toString());
            return "index";
        }

####    3. @RequestParam    ####

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

控制台输出

不会输出任何结果。

注：@RequestParam的required属性

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

4. @PathVariable

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

####    5.@RequestBody ####

导入@RequestBody依赖

<jackson.version>2.9.3</jackson.version>
     
     <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-databind</artifactId>
          <version>${jackson.version}</version>
        </dependency>
        <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-core</artifactId>
          <version>${jackson.version}</version>
        </dependency>
        <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-annotations</artifactId>
          <version>${jackson.version}</version>
        </dependency>

测试代码

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

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

#### 6. @RequestHeader    ####

@RequestMapping("/hello7")
        public String toHello7(Book book, @RequestBody Map map, @RequestHeader("jwt") String jwt){
            System.out.println(map);
            System.out.println(book);
            System.out.println(jwt);
            return "index";
        }

#### 参数传递注意事项 ####

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

package com.liao.untils;
     
    import com.fasterxml.jackson.databind.ObjectMapper;
     
    import javax.servlet.http.HttpServletResponse;
    import java.io.PrintWriter;
     
    public class ResponseUtil {
     
        public static void write(HttpServletResponse response,Object o)throws Exception{
            response.setContentType("text/html;charset=utf-8");
            PrintWriter out=response.getWriter();
            out.println(o.toString());
            out.flush();
            out.close();
        }
        
        public static void writeJson(HttpServletResponse response,Object o)throws Exception{
            ObjectMapper om = new ObjectMapper();
            write(response, om.writeValueAsString(o));
        }
    }

ReturnController

package com.liao.web;
     
    import com.liao.untils.ResponseUtil;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
     
    import javax.servlet.http.HttpServletResponse;
    import java.util.HashMap;
    import java.util.Map;
    @Controller
    @RequestMapping("/rs")
    public class ReturnController {
     
        @RequestMapping("/hello1")
        public void hello1(HttpServletResponse response){
            Map<String,Object> map=new HashMap<>();
            map.put("code",200);
            map.put("msg","添加成功");
            try {
                ResponseUtil.writeJson(response,map);
            } catch (Exception e) {
                e.printStackTrace();
            }
     
        }
     
    }

2.String+model

<%--
      Created by IntelliJ IDEA.
      User: 86158
      Date: 2023/9/5
      Time: 15:49
      To change this template use File | Settings | File Templates.
    --%>
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
    <h1>Hello</h1>
    名称：${name}
    地址：${address}
    </body>
    </html>

代码

package com.liao.web;
     
    import com.liao.untils.ResponseUtil;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;
     
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.util.HashMap;
    import java.util.Map;
     
    
    @Controller
    @RequestMapping("/rs")
    public class ReturnController {
     
        @RequestMapping("/hello2")
        public String hello2(Model model,
                           HttpServletRequest request){
              model.addAttribute("name","张三");
              request.setAttribute("address","嘿嘿嘿");
          return "index";
        }
     
     
    }

四：ModelAndView

package com.liao.web;
     
    import com.liao.untils.ResponseUtil;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.servlet.ModelAndView;
     
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.util.HashMap;
    import java.util.Map;
     
    
    @Controller
    @RequestMapping("/rs")
    public class ReturnController {
     
     
        @RequestMapping("/hello3")
        public ModelAndView hello3(){
            ModelAndView mv=new ModelAndView();
            mv.addObject("sign","打篮球");
            mv.setViewName("index");
            return mv;
        }
    }

## 四、页面跳转 ##

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

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

转发（forward）

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

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

重定向（redirect）

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

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