一.简介

• 官网：https://docs.spring.io/spring-framework/reference/web/webmvc.html#mvc
• SpringMVC 是 Spring 的 web 模块，用来开发Web应用
• SpringMVC 应用最终作为 B/S、C/S 模式下的 Server 端
• Web应用的核心就是 处理HTTP请求响应

二.@RequestMapping路径映射

1.添加映射

@RequestMapping标注请求路径，将网络请求与方法相绑定

@ResponseBody表明直接返回该返回值数据，不加这个标注，返回值会被当做一个视图名称

@Controller
public class HelloController {
    @RequestMapping("请求路径")
    @ResponseBody
    public String handle() {
        return "hello world";
    }
}

@ResponseBody可以标在类上，或者直接标注@RestController（@ResponseBody+@Controller）

2.通配符的使用

原则：精确优先

• 无通配符 > 带 {} 路径变量 > ? 通配符 > * 通配符 > ** 通配符

1. ?：匹配单个字符，如 /test? 可匹配 /test1 等。
2. *：匹配任意数量非 / 字符，如 /test/* 能匹配 /test/abc 等。
3. **：匹配任意数量含 / 字符，如 /test/** 可匹配 /test/abc/def 等。
4. 正则表达式：精确匹配路径，如 /test/{id:[0-9]+} 仅匹配 id 为数字的 /test/123 等路径。

3.请求限定

1. 请求方法：用method属性指定处理的请求类型，如GET、POST等。【可以使用GetMapping或者PostMapping代替RequestMapping】
2. 请求参数：通过params属性规定请求必须包含的参数及值。
3. 请求头：利用headers属性限定请求必须包含的请求头及值。
4. 请求内容类型：使用consumes属性指定可处理的请求媒体类型。
   1. application/x-www-form-urlencoded：表单数据默认编码，用于简单表单提交。
   2. multipart/form-data：用于文件或含二进制数据的表单提交。
   3. application/json：前后端分离开发常用，传输 JSON 数据。
   4. application/xml：用于传输 XML 数据，适用于 SOAP 服务等。
   5. text/plain：传输纯文本数据。
   6. text/html：传输 HTML 格式数据，用于网页内容传输。
   7. application/octet-stream：传输二进制数据，如文件、音视频等。
5. 响应内容类型：借助produces属性指定返回响应的媒体类型
   1. 文本类：
      • text/plain：纯文本
      • text/html：HTML 网页
      • text/css：CSS 样式表
      • text/javascript：JS 脚本
   2. 数据交换类：
      • application/json：JSON 数据
      • application/xml：XML 数据
   3. 二进制类：
      • application/octet-stream：通用二进制文件
      • image/*：各类图片
      • audio/*：音频文件
      • video/*：视频文件

@RestController
public class HelloController {
    @RequestMapping(value = "/hello",
            method = {RequestMethod.GET},
            params = {"name"},
            headers = {"Accept"},
            consumes = {"application/json"},
            produces = {"application/json"})
    @ResponseBody
    public String handle() {
        return "hello world";
    }
}

三.HTTP请求与响应

• HTTP 请求会带来各种数据
  • 请求首行：(请求方式、请求路径、请求协议)
  • 请求头：(k: v \n k: v)
  • 请求体：(此次请求携带的其他数据)
• URL 携带大量数据，特别是 GET 请求，会把参数放在 URL 上

• Protocol（协议）：如http://，规定数据传输规则。
• Domain Name（主机 / 域名） ：如www.example.com，网站地址标识。
• Port（端口） ：如:8080，网络通讯的出入口。
• Path（路径） ：如/path/to/myfile.html，定位服务器资源位置。
• Parameters（查询参数） ：如key1=value1&key2=value2，传递额外数据。
• Anchor（片段 / 锚点） ：如#some，用于网页内部定位，不发往服务器。

四.请求处理

请求处理类型

1.使用普通变量，收集请求参数

 @RequestMapping("/handle01")
    public String handle01(String username,String password,String cellphone,boolean agreement){
        //其中username、password等变量名需要与参数名一致
        System.out.println("username:"+username);
        System.out.println("password:"+password);
        System.out.println("cellphone:"+cellphone);
        System.out.println("agreement:"+agreement);
        return "ok";
    }

2.使用@RequestParam，逐一封装多个参数

@RestController
public class test01 {
    @RequestMapping("/handle")
    public String handle(@RequestParam(value = "userName", defaultValue = "张三", required = false) String name) {
        System.out.println(name);
        return "success";
    }
}

在body和param中均可使用@RequestParam接收

@RequestParam可以省略不写

1. value对应请求中参数名称
2. defaultValue表示默认值
3. required默认为true，表示一定要接收到该参数

其他类似注解：

@CookieValue//获取cookie
@RequestHeader//获取请求头

3.使用POJO，统一封装多个参数

简单封装：

将多个属性封装为一个pojo类

@Data
public class Person {
    private String name="zhangsan";  //可设置默认值，防止请求没带参数导致为null
    private int age;
}

参数直接写pojo类，属性会按名称一 一对应装填进pojo类中
注：参数与pojo类变量名需一致---本质就是springmvc帮你使用requsest.getParameter("**")

@RestController
public class test01 {
    @RequestMapping("/handle")
    public String handle(Person person) {
        System.out.println(person);
        return "hello";
    }
}

级联封装复杂对象：

//如下所示，对象套对象也是可以的
@Data 
public class Person {
    // username=zhangsan&password=123456&cellphone=1234&agreement=on
    private String username = "zhangsan"; // request.getParameter("username")
    private String password; // request.getParameter("password")
    private String cellphone;
    private boolean agreement;
    private Address address;
    private String sex;
    private String[] hobby; // request.getParameterValues("hobby")
    private String grade;
}


@Data
class Address {
    private String province;
    private String city;
    private String area;
}

在类中嵌套类，依然能自动装填入参数

4.使用@RequestHeader获取请求头数据

//和@RequestParam写法一样
@RequestMapping("/handle04")
    public String handle04(@RequestHeader("host") String host){
        System.out.println(host);
        return "ok";
    }

5.使用@CookieValue获取Cookie数据

@RequestMapping("/handle05")
    public String handle05(@CookieValue("haha") String haha){
        System.out.println(haha);
        return "ok";
    }

6.@RequestBody接收json

@RestController
public class test01 {
    @RequestMapping("/handle")
    public String handle(@RequestBody Person person) {
        System.out.println(person);
        return "hello";
    }
}

@RequestBody会自动拿到请求体中的json字符串，将json字符串转为person对象
所以其实可以@RequestBody String abc直接拿字符串。

7.MultipartFile上传文件

/**
     * 文件上传；
     * 1、@RequestParam 取出文件项，封装为MultipartFile，就可以拿到文件内容
     * @param person
     * @return
     */
    @RequestMapping("/handle08")
    public String handle08(Person person,
                           @RequestParam("headerImg") MultipartFile headerImgFile,
                           @RequestPart("lifeImg") MultipartFile[] lifeImgFiles) throws IOException {

        //1、获取原始文件名
        String originalFilename = headerImgFile.getOriginalFilename();
        //2、文件大小
        long size = headerImgFile.getSize();
        //3、获取文件流
        InputStream inputStream = headerImgFile.getInputStream();
        System.out.println(originalFilename + " ==> " + size);
        //4、文件保存
        headerImgFile.transferTo(new File("D:\\img\\" + originalFilename));
        System.out.println("===============以上处理了头像=================");
        if (lifeImgFiles.length > 0) {
            for (MultipartFile imgFile : lifeImgFiles) {
                imgFile.transferTo(new File("D:\\img\\" + imgFile.getOriginalFilename()));
            }
            System.out.println("=======生活照保存结束==========");
        }
        System.out.println(person);
        return "ok!!!";
    }

//配置文件可配置上传文件大小限制：
//如：spring.servlet.multipart.max-file-size=1GB
 //   spring.servlet.multipart.max-request-size=10GB

8.HttpEntity获取整个请求

 /**
     * HttpEntity：封装请求头、请求体； 把整个请求拿过来
     *    泛型：<String>：请求体类型； 可以自动转化
     *
     *
     * @return
     */
    @RequestMapping("/handle09")
    public String handle09(HttpEntity<Person> entity){

        //1、拿到所有请求头
        HttpHeaders headers = entity.getHeaders();
        System.out.println("请求头："+headers);
        //2、拿到请求体
        Person body = entity.getBody();
        System.out.println("请求体："+body);
        return "Ok~~~";
    }

9.使用原生Servlet API，获取原生请求对象

如果你是个念旧的人【doge】

/**
     * 接受原生 API
     * @param request
     * @param response
     */
    @RequestMapping("/handle10")
    public void handle10(HttpServletRequest request,
                         HttpServletResponse response,
                         HttpMethod method) throws IOException {
        System.out.println("请求方式："+method);
        String username = request.getParameter("username");
        System.out.println(username);
        response.getWriter().write("ok!!!"+username);
    }

10.还有很多很多其他的请求参数类型......

五.响应处理

响应数据类型

1.返回json

直接返回一个类，就能自动转化为json格式发送

@RequestMapping("/resp01")
    public Person resp01() {
        Person person = new Person();
        person.setUsername("张三");
        person.setPassword("111");
        person.setCellphone("222");
        person.setAgreement(false);
        person.setSex("男");
        person.setHobby(new String[]{"篮球","足球"});
        person.setGrade("三年级");

        return person;
    }
//Map和javabean都是属性--值，
//所以定死的数据模型就写JavaBean ； 定不死的写Map

2.文件下载

/**
     * 文件下载
     * HttpEntity：拿到整个请求数据
     * ResponseEntity：拿到整个响应数据（响应头、响应体、状态码）
     *
     * @return
     */
@RequestMapping("/download")
    public ResponseEntity<InputStreamResource> download() throws IOException {

        //以上代码永远别改
        FileInputStream inputStream = new FileInputStream("C:\\Users\\林\\Pictures\\2025010601274711.png");
        //一口气读会溢出
//        byte[] bytes = inputStream.readAllBytes();
        //1、文件名中文会乱码：解决：
        String encode = URLEncoder.encode("小绿.jpg", "UTF-8");
        //以下代码永远别改
        //2、文件太大会oom（内存溢出）
        InputStreamResource resource = new InputStreamResource(inputStream);
        return ResponseEntity.ok()
                //内容类型：流
                .contentType(MediaType.APPLICATION_OCTET_STREAM)
                //内容大小
                .contentLength(inputStream.available())
                //  Content-Disposition ：内容处理方式
                .header("Content-Disposition", "attachment;filename="+encode)
                .body(resource);
    }

1. ResponseEntity.ok()：创建一个 HTTP 响应实体，状态码为 200 OK，表示请求成功处理。
2. .contentType(MediaType.APPLICATION_OCTET_STREAM)：设置响应的内容类型为 application/octet-stream，这是一种通用的二进制数据类型，常用于表示任意类型的文件。
3. .contentLength(inputStream.available())：设置响应体的字节长度，inputStream.available() 方法返回输入流中可读取的字节数。不过需要注意的是，这个方法返回的是当前可读取的字节数，而不是文件的总字节数，在某些情况下可能不准确。
4. .header(“Content-Disposition”, “attachment; filename=” + encode)：设置响应头 Content-Disposition，告诉浏览器将响应内容作为附件下载，并指定文件名。encode 是经过 URL 编码后的文件名，避免中文文件名出现乱码。
5. .body(isr)：将 InputStreamResource 对象 isr 作为响应体返回，该对象封装了文件的输入流。

六.thymyleaf页面跳转

这部分简单了解就行，页面跳转交给前端来做

@Controller // 开发服务端渲染逻辑
public class PageTestController {
    @RequestMapping("/")
    public String index(){

        // thymeleaf 默认：去 classpath:/templates/ 找页面, 后缀为 .html
        // 页面地址 = classpath:/templates/ + 返回名字 + .html
        return "login";  //返回值就是  页面名称（视图名）
    }
}

@RequestMapping("/login.mvc")
    public String login(String username,
                        String password,
                        //模型就是页面要展示的所有数据
                        Model model){
        System.out.println("用户登录："+username+","+password);

        // 去数据库查到登录的用户信息

        // 去数据库查到访客列表

        List<User> list = Arrays.asList(
                new User(1L, "张三1", 18),
                new User(2L, "张三2", 19),
                new User(3L, "张三3", 16),
                new User(4L, "张三4", 12)
        );


        model.addAttribute("users",list);
        model.addAttribute("name",username);
        model.addAttribute("age",18);

        return "page/success";
    }

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>成功</title>
</head>
<body>
<h1>恭喜，登录成功：</h1>
<!-- th:xx； 修改标签的任意属性 -->
<h2>用户名：<span th:text="${name}" th:id="${name}">张三</span> </h2>
<h2 >年龄：[[${age}]]  </h2>

<!-- 列表：今天的访客 -->
<table border="1px">
    <tr>
        <th>序号</th>
        <th>用户名</th>
        <th>年龄</th>
        <th>成年人吗</th>
    </tr>


    <tr th:each="user : ${users}">
        <td>[[${user.id}]]</td>
        <td th:text="${user.getName()}">张三</td>
        <td th:text="${user.age}">18</td>
<!--        <td th:if="${user.age >= 18}">是</td>-->
<!--        <td th:if="${user.age < 18}">否</td>-->

        <td th:text="${user.age >= 18? '是':'否'}">否</td>
    </tr>


</table>
</body>
</html>

七.Restful风格

点击跳转

八.@PathVariable路径变量

• 基本写法：用 {变量名} 定义，如 /users/{id}。
• 多变量：一个路径可含多个 {变量名}，如 /users/{userId}/orders/{orderId}。
• 正则约束：{变量名:正则表达式} 约束变量格式，如 /products/{productId:[0-9]+}。
• 混合路径：路径含固定部分与 {变量名}，如 /api/v1/users/{id}。

在参数前添加@PathVariable取出路径变量的值

九.拦截器

1.拦截器的实现

要实现一个 SpringMVC 拦截器，需要创建一个类并实现 HandlerInterceptor 接口，该接口包含三个方法：

• preHandle：在请求处理之前执行，返回 true 表示继续执行后续的处理流程，返回 false 表示中断请求处理。
• postHandle：在请求处理之后，视图渲染之前执行。
• afterCompletion：在整个请求处理完成后执行，通常用于资源清理等操作。

执行顺序：preHandle>>>目标方法>>>postHandle>>afterCompletion

public class MyHandlerIntercepter implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) throws Exception {
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }
​
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }
​
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

2.拦截器的配置

//容器中需要有一个这样的组件：WebMvcConfigurer
//实现方法1)@Bean 放一个WebMvcConfigurer
//        2）配置类实现WebMvcConfigurer[如下所示]
@Configuration
public class WebConfig implements WebMvcConfigurer {
​
    @Autowired
    MyHandlerIntercepter myHandlerIntercepter;
​
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myHandlerIntercepter)//添加拦截器
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/login"); // 排除登录请求
    }
}

3.多个拦截器执行顺序

• 拦截器执行顺序：preHandle顺序执行 => 目标方法 => postHandle倒序执行 => 渲染 => 倒序
• 只有执行成功的 preHandle 会倒序执行 afterCompletion
• postHandle 、afterCompletion 从哪里炸，倒序链路从哪里结束
• 只要有一个拦截器拦截了，所有postHandle方法就不会执行
• postHandle 失败不会影响 afterCompletion 执行

4.拦截器和过滤器区别

十.注解式异常处理

单一类异常处理

在某类中添加异常处理方法，异常处理方法只会处理该类的异常
比如如果Controller本类出现异常，会自动在本类中找有没有@ExceptionHandler标注的方法，如果有，执行这个方法，它的返回值就是客户端收到的结果

@ResponseBody
@ExceptionHandler(ArithmeticException.class)//括号中写异常类
public void test(ArithmeticException.ex){
    System.out.println(100,"发生异常"+ex.getmessage());
}

全局异常处理

• 全局异常处理类上添加注解@ControllerAdvice
• 该类下的异常处理方法会处理所有异常

自适应处理

• 当异常未被处理时，SpringBoot底层对SpringMVC有一套自适应兜底机制
• 浏览器会响应页面，移动端会响应json

异常处理的最终方式

1. 有业务异常类：BizException
2. 有异常枚举类：BizExceptionEnume列举是项目中每个模块将会出现的所有异常情况
3. 编写业务代码的时候，只需要编写正确逻辑，如果出现预期的问题，需要以抛异常的方式中断逻辑并通知上层
4. 全局异常处理器：GlobalExceptionHandler：处理所有异常，返回给前端约定的json数据与错误码

十一.数据校验

JSR 303 是 Java 为 Bean 数据合法性校验提供的标准框架，它定义了一套可移植的验证约束和元数据模型，允许开发者通过注解方式对 Java Bean 的字段进行校验，提升代码的健壮性和可维护性。在 Java 中，Hibernate Validator 是 JSR 303 的一个常用实现。

1.导包

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

2.编写注释校验

注解加在属性上面

1. @NotNull：被注释的元素不能为 null。
2. @NotEmpty：被注释的字符串、集合、数组等不能为 null 且长度必须大于 0。
3. @NotBlank：被注释的字符串不能为 null，且去除首尾空格后长度大于 0。
4. @Size：被注释的元素大小必须在指定范围内。
5. @Min：被注释的元素必须是一个数字，其值必须大于等于指定的最小值。
6. @Max：被注释的元素必须是一个数字，其值必须小于等于指定的最大值。
7. @Pattern：被注释的元素必须符合指定的正则表达式。
8. @Email：被注释的元素必须是一个有效电子邮箱

注解括号中可以写message属性，校验不通过时提醒前端

@NotNull(message="这是提示")

3.@Valid开启校验

在参数前添加@Valid注解，不添加就不会校验

public void add(@RequestBody @Valid Employee employee)

4.BingdingResult校验结果

• 默认结果：如果校验不通过，方法不执行，并且会返回一长串默认的json
• 修改结果：添加BindingResult参数，校验不通过，方法也会照常执行，错误结果会封装到BindingResult当中

@Controller
public class jiaoyan {
    @RequestMapping("/test")
    public void test(@RequestBody @Valid Employee employee, BindingResult result) {
        if (result.hasErrors()) {
          System.out.println(result.getFieldError().getDefaultMessage());
        }
        else {
            System.out.println(employee);
        }
    }
}

5.全局异常处理器

MethodArgumentNotValidException 异常会在使用 @Valid 注解进行验证且验证失败时抛出。

@Component
public class ExceptionHandlers {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public String bindException(MethodArgumentNotValidException ex) {
        BindingResult result = ex.getBindingResult();
        List<FieldError> fieldErrors = result.getFieldErrors();
        Map<String, String> map = new HashMap<>();
        for (FieldError fieldError : fieldErrors) {
            map.put(fieldError.getField(), fieldError.getDefaultMessage());
        }
        return "异常方法";
    }
}

这样就可以统一处理所有的校验异常

e.printStackTrace();
异常处理打印错误堆栈

@ExceptionHandler(Throwable.class)
public R error(Throwable e){
   System.out.println("[全局]-Exception处理"+e.getClass());
   e.printStackTrace();
   return R.error(500,e.getMessage());
}

6.自定义校验

1.自定义注解

创建annotation文件夹

public @interface Gender{
}

2.自定义校验器

定义一个类实现ConstraintValidator接口

isValid就是校验方法

public class myvalidator implements ConstraintValidator<Gender, String> {
    /**
     *
     * @param o 前端提交的属性值
     * @param context 校验上下文
     * @return
     */
    @Override
    public boolean isValid(Object o, ConstraintValidatorContext context) {
        return true;
    }
}

3.自定义校验注解

// 定义校验器实现类
@Constraint(validatedBy = { myvalidator.class })
// 注解可以应用的目标元素类型
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER })
// 注解的保留策略
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface validatorInterface {
  // 校验失败时的默认消息
  String message() default "自定义校验失败";
  // 校验组
  Class<?>[] groups() default {};
  // 负载信息
  Class<? extends Payload>[] payload() default {};
}

4.国际化错误消息

1.基本使用

在messages.properties中定义错误消息

名称(例如：gender.message)=错误消息 

在方法中调用错误消息

message="{gender.message}"

2.国际化用法

配置文件messages后添加国家区域代码

例如中国：

messages_zh_CN.properties

在不同国家环境读取不同配置文件

5.总结

数据校验：
1、导入校验包
2、JavaBean 编写校验注解
3、使用 @Valid 告诉 SpringMVC 进行校验
效果1： 如果校验不通过，目标方法不执行
4【以后不用】、在 @Valid 参数后面，紧跟一个 BindingResult 参数，封装校验结果* 效果2： 全局异常处理机制
5【推荐】：编写一个全局异常处理器，处理 MethodArgumentNotValidException（校验出错的异常），统一返回校验失败的提示消息
6：自定义校验 = 自定义校验注解 + 自定义校验器

十二.VO对象的使用

1. POJO（Plain Old Java Object） 定义：简单Java对象，无特殊框架依赖，有属性及getter/setter等方法。 用途：用于数据表示与传递。
2. DO（Domain Object） 定义：面向领域模型，抽象业务概念，包含业务数据与行为。 用途：封装业务逻辑，表达业务概念，是领域层核心。
3. DAO（Data Access Object） 定义：数据访问对象。 用途：负责与数据库交互，实现数据增删改查，分离业务与数据访问逻辑。
4. VO（Value Object） 定义：值对象。 用途：为前端展示提供合适数据结构。
5. DTO（Data Transfer Object） 定义：数据传输对象。 用途：在不同层间传输数据，减少传输量，保护业务对象结构。
6. BO（Business Object） 定义：业务对象。 用途：封装业务逻辑，分离业务与数据访问逻辑。
7. PO（Persistent Object） 定义：持久化对象。 用途：与数据库表对应，用于ORM框架实现数据映射。

原则：

• vo对象与bean对象属性完全相同

• bean对象内不添加数据校验，vo对象内添加数据校验
• 前端传递的对象用vo对象接收
• vo对象可分为response和request的对象，分别处理发送和接收

1.创建VO对象

@Data
public class EmployeeVO {
    @NotNull(message = "id不能为空")
    private Long id;
    
    private String name;
    
    private Integer age;

     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date birth;
}
//注：只要是日期：标注统一注解：@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    //默认的日期格式： 2024-09-05T08:47:58.000+00:00
    //反序列化：前端提交日期字符串 ===> 日期对象
    //序列化：  日期对象 ===> 日期字符串

2.使用VO对象接收数据

@RestController
public class EmployeeController {
    @Autowired
    private EmployeeService employeeService;
    
    public void test(@RequestBody @Valid EmployeeVO vo) {
        Employee employee = new Employee();
        
        //vo对象拷贝到bean对象
        BeanUtils.copyProperties(vo, employee);
        
        employeeService.save(employee);
        return;
    }
}

十三.接口文档

1.简介

• Swagger可以快速生成实时接口文档，方便前后开发人员进行协调沟通。遵循OpenAPI规范。

• Knife4j是基于Swagger之上的增强套件，官网https://doc.xiaominfo.com/v2/
• 网址：http://localhost:8080/doc.html 可查看当前项目的文档

2.引入依赖

<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
    <version>4.4.0</version>
</dependency>

3.yaml配置文件

# springdoc-openapi项目配置
springdoc:
  swagger-ui:
    path: /swagger-ui.html
    tags-sorter: alpha
    operations-sorter: alpha
  api-docs:
    path: /v3/api-docs
  group-configs:
    - group: 'default'
      paths-to-match: '/**'
      packages-to-scan: com.xiaominfo.knife4j.demo.web
# knife4j的增强配置，不需要增强可以不配
knife4j:
  enable: true
  setting:
    language: zh_cn

4.标签用法

@Tag(name = "")//描述controller类作用
@Operation(summary = "")//描述方法作用
@Schema(description = "")//描述model层面每个属性
@Parameter(name = "参数名", description = "描述", in = "参数位置", required = true/fa;se)//描述参数作用

————springMVC结束—————-