SpringMVC常用注解用法

Spring MVC是基于Servlet API构建的原始Web框架。

MVC是Model View Controller的缩写即视图模型控制器，是一种思想，而Spring MVC是对该思想的具体实现。关于SpringMVC的学习我们需要掌握用户和程序的连接、获取参数以及返回数据三大部分。而这三大功能的实现离不开注解，所以这里对这三个过程进行说明，同时对在此过程中用到的注解进行总结。

一、连接过程

Spring MVC 中使⽤ @RequestMapping 来实现 URL 路由映射 即浏览器连接程序。

连接成功的效果：访问注册的地址能打印出我们预想的信息。

示例：

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller//类注解
@ResponseBody//返回text/html
@RequestMapping("/user")//一级路由注册
public class UserController {
    @RequestMapping("/sayhi")//二级路由注册
    public String sayHi(){
        return "hi";
    }
}

启动后访问对应的url地址：

接下来详细介绍@RequestMapping用法

@RequestMapping

它是spring web应用程序中最常被用到的注解之一。

1.作用

作用：注册接口的路由映射。路由映射是指用户访问一个url，将用户的请求对应到应用程序中某个方法的过程。（其实也是起别名）

2.基本用法

它可以修饰类也可以修饰方法。

• 修饰类和方法时，修饰的地址时类+方法。参考上边的例子

• 直接修饰方法：

  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.ResponseBody;
  
  @Controller
  @ResponseBody
  public class UserController2 {
      @RequestMapping("/user2/sayhi")//二级路由注册
      public String sayHi(){
          return "hi";
      }
  }
  

  

注意：无论是@Controller还是@ResponseBody都不可省略

原因如下：

1. 这个类必须随着spring的加载而加载，别人才能通过注册的路由访问到它。

2. @ResponseBody用来修饰类或者方法。修饰类时类中所有的方法都返回html或者json，而不是视图。如果时字符会转换成tex/html，如果是对象，会转换成applicaiton/json返回给前端。

3. 另外这两个注解还可以替换成@RestContrlloer，@RestContrlloer=@ResponseBody+@@Controller。他是一个组合注解

3.@RequestMapping支持的请求连接类型验证

是支持所有的还是支持特定的请求，下边我们进行验证。

首先，它默认支持的肯定是get请求，因为我们在浏览器上输入url地址敲下回车，其实就是get，我们可以通过抓包来验证：

（使用刚刚的sayhi方法）

其次，它也支持post请求，我们可以通过postman+抓包进行验证：

在测试post请求之前，我们先再做一次get：

POST：

显然，可以得出RequestMapping也是支持post请求的。

最后，我们也可以实验别的请求，发现它也是可以支持的：

这里不再一一演示。

4.接口特定请求类型设置方法

当领导一刀切，要求必须只支持某一种方法，怎么设置：

通过查看源码（结合注释）及官网，我们可以知道一共有两种设置方法，这里我们使用post请求为例：

1）使用@PostMapping注解

抓包验证：

与之类似的，对应的get方法有@GetMapping注解

2）设置@RestMapping，并设置method属性

看@RestMapping源码我们可以知道，它有一个属性叫做method，类型是枚举数组，而枚举的值恰巧是请求的方法类型

补充：

1.很容易知道，value和name意思是一样的

2.consume和produces是用来进行路由筛选的，一个用于设置只有特定请求才能访问到，一个用于只能返回特定类型的数据，用的比较少，相当于还是加了一层路由筛选。

这样，我们就可以将其设置成post

@RestController//=@Controller+@ResponseBody
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/sayhi")
    public String sayHi(){
        
        return "hi";
    }
    @RequestMapping(value = "/sayhi2",method = RequestMethod.POST)
    public String sayHi2(){
        
        return "hi";
    }
}

另外，我们也可以通过抓到的包看显示请求类型是否是Post来验证：

很容易看出来是的，所以这种设置方法可行。

二、获取参数过程

获取参数，需要我们后端代码这里有接受的容器，其实也就是我们方法的设置上要有形参，所以获取参数的问题其实也就是形参的设置。

1.1.获取单个参数

我们之前怎么传形参，这里其实就怎么传。

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

//@Controller//类注解
//@ResponseBody//返回非视图
@RestController//=@Controller+@ResponseBody
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/gp")
    public String getParam(String name){
        return name;
    }
}

注意：

1. 拿到单个参数前提是形参和传的参数名一定要相同

2. 不传参数，返回的是默认值.所以推荐参数传递时不要使用基础类型数据

   

   那么这里其实就涉及到一个基础类型和非基础类默认值的问题了，对于基础类型，不传参数会直接报错，对于非基础类型不传参数返回的是null（引用类型默认值是null）

   验证：

   package com.example.demo.controller;
   
   import org.springframework.stereotype.Controller;
   import org.springframework.web.bind.annotation.*;
   
   //@Controller//类注解
   //@ResponseBody//返回非视图
   @RestController//=@Controller+@ResponseBody
   @RequestMapping("/user")
   public class UserController {
       @RequestMapping("/gp")
       public String getParam(String name){
           return name;
       }
       @RequestMapping("/gp1")
       public String getParam(Integer id){
           return ""+id;
       }
       @RequestMapping("/gp2")
       public String getParam(int id){
           return ""+id;
       }
   }
   

补充

内置隐藏参数:request和reponse对象【了解】

当项目启动时，spring mvc会自动帮我们把请求和相应对象赋值给他们

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@RestController//=@Controller+@ResponseBody
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/gp3")
    public String getParam(HttpServletRequest request,HttpServletResponse response) throws IOException {
        response.sendRedirect("http://www.javacn.site");
        return "hi";
    }
}

1.1.获取多个参数

@RequestMapping("/gp4")
public String getParam(String name,String password) {
    return name+":"+password;
}

注意：1. 当有多个参数时，前后端进⾏参数匹配时，是以参数的名称进⾏匹配的，因此参数的顺序是不影响后端获取参数的结果

@RequestParam用法

特殊情况下，前端传递参数和后端接收参数名不同，可以使用@RequestParam重命名前后端参数值，完成后端参数映射。

使用方法：

@RequestParam(前端参数名) xxx xxx(后端参数名)

@RequestMapping("/gp5")
public String getParam5(@RequestParam("username") String name) {
    return name;
}

除了上述基本用法，它还可以完成必传参数和非必传参数的设置：

我们可以看以下它的源码，他是通过required这个字段来完成这个功能的。当required值为true时，不传此参数就会报错400错误；当它为false时，不传也没有关系。

默认情况下，参数既然有是必须传递的。

说明：使用这个注解是一种特殊的场景，即前后端参数不一致时，它不是一种获取参数的类型。

2.获取普通对象

传递方式和多个参数一样，顺序不重要，但是名称必须写对，如果传的参数不对或者名字传错了，就会返回默认值。

因为框架会通过名称帮我们完成了自动参数映射，并且根据返回的结果，帮助我们返回恰当的封装对象。

package com.example.demo.entity;

import lombok.Data;

@Data
public class UserInfo {
    private int id;
    private String name;
    private String password;
    private int age;
}

//获取对象
@RequestMapping("/reg")
public Object getParam9(UserInfo userInfo){
    return userInfo;
}

通过抓包我们可以看出来，这里是返回了json对象：

再比如，我们使用h1标签，那么框架就会返回html形式的结果：

//返回结果
@RequestMapping("/reg1")
public Object reg1(UserInfo userInfo){
    return "<h1>userInfo</h1>";
}

两种方式：①使用传递多个参数的形式②把表单封装成一个对象，使用对象去获取。框架帮助自动映射。

3.获取JSON对象——使用@RequestBody接收

不加注解获取不到：

//获取json对象(通过请求体获取json对象)
@RequestMapping("/reg2")
public Object reg2(@RequestBody UserInfo userInfo){
    return userInfo;
}

4.从基础的URL中获取参数（非参数位置而是path位置）——使用@PathVariable注解

//从基础的url中获取参数
//花括号里填的变量的名字，注意这里对位置是敏感的
@RequestMapping("/reg3/{name}/{pwd}")
public Object reg3(@PathVariable String name,@PathVariable(required = false,name = "pwd") String password){
    return name+":"+password;
}

注意：1. 对位置敏感

2. 使用频率不高，但也有自己的应用场景。例如详情页
3. 注解中name支持重命名，required支持可不传递参数注解位置不同
4. @PathVariable和@RequestParam使用：前者是获取？之前的参数，后者是获取？之后的参数，具体看参数约定、公司要求和业务场景。

5.获取上传文件——使用@RequestPart注解

这个还是比较常用的，比如上传头像：

//获取上传文件
@RequestMapping("/myupload")
public Object upload(@RequestPart("myimage")MultipartFile file){
    File saveFile=new File("F://test//myimage.png");
    try {
        file.transferTo(saveFile);
        return true;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return false;
}

这里使用postman去模拟

注意：

1. 这里的参数必须使用MultipartFile类型接收。因为他里边有transfer方法，可以直接把上传过来的文件流保存为图片。
2. 如果文件太大了，可能上传失败，需要在配置文件中重新配置最大文件大小,max-file-size，具体配置项看官方配置文件。
3. @RequestPart中的参数传的

但是这个代码存在一个问题，是不能上生产线的——后面上传的文件会覆盖前边上传的。

解决思路：文件的名称不能重复——使用Java里边的UUID（通用唯一id）。他是时间戳+随机数+电脑的mac地址+随机种子。文件格式可能会不同，所以还需要得到原生的后缀名。

这里使用file的获取文件名的方法然后使用substring获得后缀。

//获取上传文件（可以上生产线的代码）
@RequestMapping("/myupload2")
public Object upload2(@RequestPart("test")MultipartFile file){
    String fileName= UUID.randomUUID()+file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf("."));
    File saveFile=new File("F://test//"+fileName);
    try {
        file.transferTo(saveFile);
        return true;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return false;
}

补充：目录和文件名都不写死：

//获取文件3：目录和文件名都不写死
public Object upload3(@RequestPart("test")MultipartFile file) throws IOException {
    String contextName=new ClassPathResource("").getFile().getAbsolutePath();
    String fileName= UUID.randomUUID()+file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf("."));
    File saveFile=new File(contextName+fileName);
    try {
        file.transferTo(saveFile);
        return true;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return false;
}

6.获取Cookie——使用@CookieValue注解

获取方式：①使用之前servlet方式（有隐藏参数之前已经提到）②使用注解，比较简洁。这里使用第二种

这里注解的参数有两个值，其中value取决于我们cookie里边的值，这里前端可能没有传递，所以我们这里required设置成false

//获取cookie
@RequestMapping("/getck")
public Object getck(@CookieValue(value = "java",required = false)String java){
    return java;
}

这里因为前端没有传递过来有java的cookie，所以我们这里伪造一个cookie。伪造方法：在浏览器界面f12,点击cookie：

7.获取Header——使用RequestHeader注解

也有两种方式：①使用request对象②使用注解

代码示例：获取host

//获取Header
@RequestMapping("gethd")
public Object getHeader(@RequestHeader("Host")String ht){
    return ht;
}

可以看到这个注解的参数里边还是有前端的名字

8.获取Session——使用@SessionAttribute注解

要获取session我们必须先存

session的存储（没用注解）

存储方式还是之前servlet的方式

private static final String SESSION_KEY="USERINFO_SESSIONKEY";
@RequestMapping("setsess")
public void setsess(HttpServletRequest request) {
    HttpSession session = request.getSession(true);
    if(session!=null){
        session.setAttribute(SESSION_KEY,"zhangsan");
    }
}

session的获取

使用注解@SessionAttribute

//获取Session
@RequestMapping("getsess")
public Object getSession(@SessionAttribute(SESSION_KEY)String name){
    return "session:"+name;
}

系统项的配置

三、返回数据过程

1.返回静态页面（默认类型|不加RestContrlloer或@ResponseBody）

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <h1>返回参数测试</h1>
</body>
</html>

package com.example.demo.controller;

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

@Controller
@RequestMapping("test")
public class TestController {
    @RequestMapping("/index")
    public Object getIndex(){
        return "/index.html";
    }
}

注意：加斜杠表示从根目录访问，不加表示在当前路径寻找。

路径问题可以通过抓包访问（加斜杠是从根目录（ip+端口号去找））

默认请求转发

2.返回非静态页面数据——加@ResponsBody注解

可能是json对象或者其他，框架会自动进行映射。这里以json对象为例

//返回json对象
@RequestMapping("/reg2")
public Object reg2(@RequestBody UserInfo userInfo){
    return userInfo;
}

3.返回跳转/链接【forwardVSredirect】

用的不多，但主要看业务需求。

请求转发(forward)和请求重定向(redirect)是常见面试题

这部分跟注解关系不大，但是面试却很重要，所以单独总结。

关于consumes和produces

consumes

@RequestMapping注解中的consumes属性用于指定客户端请求的MIME类型（Media Type）或请求头中的Content-Type。通过指定consumes属性，可以限制控制器方法只接受特定类型的请求。

consumes属性可以接收一个字符串数组，用于指定允许接受的请求的MIME类型。例如：

@RequestMapping(value = "/example", consumes = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<String> handleJsonRequest(@RequestBody User user) {
    // 处理请求逻辑
}

在上述示例中，使用了consumes = MediaType.APPLICATION_JSON_VALUE来指定只接受Content-Type为application/json的请求。如果收到其他类型的请求（如application/xml），该方法将不会被调用。

此外，consumes属性还可以使用逻辑运算符组合多个MIME类型。以下是一些示例：

• 只接受JSON和XML类型的请求：

@RequestMapping(value = "/example", consumes = { MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE })
public ResponseEntity<String> handleRequest(@RequestBody User user) {
    // 处理请求逻辑
}

• 只接受不是表单的所有请求类型：

@RequestMapping(value = "/example", consumes = "!application/x-www-form-urlencoded")
public ResponseEntity<String> handleRequest(@RequestBody User user) {
    // 处理请求逻辑
}

• 只接受具有自定义请求头的请求类型：

@RequestMapping(value = "/example", consumes = "X-Custom-Header=custom-value")
public ResponseEntity<String> handleRequestRequestBody User user) {
    // 处理请求逻辑

通过使用consumes属性，可以更精确地控制控制器方法接受的客户端请求类型，从而确保数据传输的正确性和安全性。

produces

@RequestMapping注解中的produces属性用于指定控制器方法的响应类型，即指定服务端返回的MIME类型（即Accept类型）或响应头中的Content-Type。

produces属性可以接收一个字符串数组，用于指定控制器方法返回的响应的MIME类型。例如：

@RequestMapping(value = "/example", produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<User> handleJsonRequest() {
    // 处理请求逻辑
    User user = new User("John", "Doe");
    return ResponseEntity.ok().body(user);
}

在上述示例中，使用了produces = MediaType.APPLICATION_JSON_VALUE来指定返回的响应类型为application/json。如果客户端要求其他类型（如application/xml），服务端将不会返回该响应。

此外，produces属性还可以使用逻辑运算符组合多个MIME类型。以下是一些示例：

• 只返回JSON和XML类型的响应：

@RequestMapping(value = "/example", produces = { MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE })
public ResponseEntity<User> handleRequest() {
    // 处理请求逻辑
    User user = new User("John", "Doe");
    return ResponseEntity.ok().body(user);
}

• 只返回不是表单的所有响应类型：

@RequestMapping(value = "/example", produces = "!application/x-www-form-urlencoded")
public ResponseEntity<User> handleRequest() {
    // 处理请求逻辑
    User user = new User("John", "Doe");
    return ResponseEntity.ok().body(user);
}

• 只返回具有自定义响应头的响应类型：

@RequestMapping(value = "/example", produces = "X-Custom-Header=custom-value")
public ResponseEntity<User> handleRequest() {
    // 处理请求逻辑
    User user = new User("John", "Doe");
    return ResponseEntity.ok().body(user);
}

通过使用produces属性，可以更精确地控制控制器方法返回的响应类型，从而确保服务端返回的数据与客户端的期望一致。