Swagger配置API接口文档

Swagger配置API接口文档

一：概述

Swagger是一个用于设计、构建和文档化 RESTful API 的开源框架。它提供了一组工具，使得开发人员能够更轻松地定义、描述和测试API接口。

核心组件：

• Swagger规范（Swagger Specification）: 定义了一种格式化的API规范，使用YAML或JSON格式，用于描述API的各种细节，包括路由、参数、返回值等。

• Swagger编辑器（Swagger Editor）: 提供了一个交互式的编辑界面，让开发人员能够方便地编写和验证Swagger规范文件。

• Swagger UI: 一个动态生成的HTML文件，可以将Swagger规范文件渲染成一个美观易用的API文档网页。通过Swagger UI，开发人员可以直观地查看API接口的详细信息，包括请求示例、响应模型和参数说明。

• Swagger Codegen: 一个自动生成API客户端代码的工具，根据Swagger规范文件，它可以生成多种编程语言的代码框架，帮助开发人员快速集成和调用API接口。

优势：

• 方便的API文档自动生成和维护。
• 更好的API可读性和可测试性。
• 简化与前端开发团队或第三方开发者之间的协作。
• 提高API的可靠性和版本管理能力。

二：实验步骤

1.导入依赖

<!-- 引入 Swagger 依赖 -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>

<!-- swagger2-UI -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>

2.代码生成器

package com.gcxy.utils;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.engine.VelocityTemplateEngine;

import java.util.ArrayList;
import java.util.List;

public class CodeGenerator {

    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/gcxy_teach?serverTimezone=UTC";
        String username = "root";
        String password = "123456";
        String module = ""; //  表示项目的模块名称
        String outPath = System.getProperty("user.dir") + "/" + module + "/src/main/java"; // 文件输出路径
        String parent = "com.gcxy"; // 父包的名称
        String moduleName = ""; // 模块名称
        String entity = "entity";
        String mapper = "mapper";
        String service = "service";
        String serviceImpl = "service.Impl";
        String controller = "controller";
        String mapperXml = "mapper.xml";

        List<String> tables = new ArrayList<>();
        tables.add("account");
        tables.add("phone");
        tables.add("dep");
        tables.add("stu");

        FastAutoGenerator.create(url, username, password)
                // 全局配置
                .globalConfig(builder -> {
                    builder.author("码农ovo") // 设置作者
                            .enableSwagger() // 开启 swagger 模式
                            .fileOverride() // 覆盖已生成文件
                            .outputDir(outPath) // 指定输出目录
                            .disableOpenDir(); // 生成后不打开目录
                })

                // 包配置
                .packageConfig(builder -> {
                    builder.parent(parent) // 设置父包名
                            .moduleName(moduleName) // 设置父包模块名
                            .entity(entity)
                            .mapper(mapper)
                            .service(service)
                            .serviceImpl(serviceImpl)
                            .controller(controller)
                            .xml(mapperXml);
                })
                // 策略配置
                .strategyConfig(builder -> {
                    builder.addInclude(tables) // 设置需要生成的表名
//                            .addTablePrefix("t_", "c_"); // 设置过滤表前缀
                            .entityBuilder() // 开启生成实体类
                            .enableLombok() // 开启lombok模型
                            .mapperBuilder() // 开启生成mapper
                            .superClass(BaseMapper.class)
//                            .enableMapperAnnotation() // 开启mapper注解
                            .formatMapperFileName("%sMapper") // 格式化mapper名称
                            .formatXmlFileName("%sMapper") // 格式化xml的名称
                            .serviceBuilder() // 开启生成service
                            .formatServiceFileName("%sService") //格式化service接口文件名称
                            .formatServiceImplFileName("%sServiceImpl")
                            .controllerBuilder() //开启controller生成
                            .formatFileName("%sController")
                            .enableRestStyle();
                })
                .templateEngine(new VelocityTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();
    }
}

3.添加配置信息

package com.gcxy.config;

import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import io.swagger.annotations.ApiOperation;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.*;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spi.service.contexts.SecurityContext;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * Swagger2的接口配置
 *
 * @author zyy
 */
@Configuration
@EnableSwagger2 //标记项目启用 Swagger API 接口文档
public class SwaggerConfig
{

    /** 是否开启swagger */
    @Value("${swagger.enabled}")
    private boolean enabled;

    /** 设置请求的统一前缀 */
    @Value("${swagger.pathMapping}")
    private String pathMapping;

    /**
     * 创建API
     */
    @Bean
    public Docket createRestApi()
    {   // 创建Docket对象
        return new Docket(DocumentationType.SWAGGER_2) // 文档类型，使用Swagger2
                // 是否启用Swagger
                .enable(enabled)
                // 用来创建该API的基本信息，展示在文档的页面中（自定义展示的信息）
                // 设置Api信息
                .apiInfo(apiInfo())
                // 设置哪些接口暴露给Swagger展示
                .select()
                // 扫描所有有注解的api，用这种方式更灵活
                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
                // 扫描指定包中的swagger注解
                // .apis(RequestHandlerSelectors.basePackage("com.project.tool.swagger"))
                // 扫描所有
                .paths(PathSelectors.any())
                // 构建出 Docket 对象
                .build()
                /* 设置安全模式，swagger可以设置访问token */
                .securitySchemes(securitySchemes())
                .securityContexts(securityContexts())
                .pathMapping(pathMapping);
    }

    /**
     * 安全模式，这里指定token通过Authorization头请求头传递
     */
    private List<SecurityScheme> securitySchemes()
    {
        List<SecurityScheme> apiKeyList = new ArrayList<SecurityScheme>();
        apiKeyList.add(new ApiKey("Authorization", "Authorization", "header"));
        return apiKeyList;
    }

    /**
     * 安全上下文
     */
    private List<SecurityContext> securityContexts()
    {
        List<SecurityContext> securityContexts = new ArrayList<>();
        securityContexts.add(
                SecurityContext.builder()
                        .securityReferences(defaultAuth())
                        .forPaths(PathSelectors.regex("^(?!auth).*$"))
                        .build());
        return securityContexts;
    }

    /**
     * 默认的安全上引用
     */
    private List<SecurityReference> defaultAuth()
    {
        AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
        authorizationScopes[0] = authorizationScope;
        List<SecurityReference> securityReferences = new ArrayList<>();
        securityReferences.add(new SecurityReference("Authorization", authorizationScopes));
        return securityReferences;
    }

    /**
     * 添加摘要信息
     */
    private ApiInfo apiInfo()
    {
        // 用ApiInfoBuilder进行定制
        return new ApiInfoBuilder()
                // 设置标题
                .title("标题：Swagger测试_接口文档")
                // 描述
                .description("描述：用于管理人员信息,具体包括XXX,XXX模块...")
                // 作者信息
                .contact(new Contact("Huang先森", null, null))
                // 版本
                .version("版本号:1.0" )
                .build();
    }
}

4.解决版本冲突问题

# 报错信息
org.springframework.context.ApplicationContextException: Failed to start bean 'documentationPluginsBootstrapper'; nested exception is java.lang.NullPointerException

在application.yml中添加以下配置：

spring:
  mvc:
    pathmatch:
      matching-strategy: ant_path_matcher

5.编写Controller 测试

package com.gcxy.controller;


import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author zyy
 * @since 2023-12-10
 */

@Api("手机信息管理")
@RestController
@RequestMapping("/phone")
public class PhoneController {

    @ApiOperation("Swagger测试接口")
    //@GetMapping("/test")
    @RequestMapping("/test)
    public void test(){
        System.out.println("这是一个测试接口！！！");
    }

}

6.启动项目

启动项目。然后浏览器访问 http://127.0.0.1:8080/swagger-ui.html (8080是你项目端口)地址，就可以看到 Swagger 生成的 API 接口文档。效果如下：

7.Swagger相关注解

@Api

@Api 注解是 Swagger 中用于标记控制器类（Controller）的注解，表示该类包含了 API 接口。它具有以下常用属性：

• value：指定 API 分组或分类的名称。

• tags：设置 API 接口的标签，用于对 API 进行分组和分类。[]数组，可以填写多个。

  • 可以在一个 Controller 上的 @Api 的 tags 属性，设置多个标签，那么这个 Controller 下的 API 接口，就会出现在这两个标签中。
  • 如果在多个 Controller 上的 @Api 的 tags 属性，设置一个标签，那么这些 Controller 下的 API 接口，仅会出现在这一个标签中。
  • 本质上，tags 就是为了分组 API 接口，和 Controller 本质上是一个目的。所以绝大数场景下，我们只会给一个 Controller 一个唯一的标签。

• description：对 API 接口的描述信息。(现已废弃)

@Api 注解的不常用属性，如下：

• produces 属性：请求请求头的可接受类型( Accept )。如果有多个，使用 , 分隔。

• consumes 属性：请求请求头的提交内容类型( Content-Type )。如果有多个，使用 , 分隔。

• protocols 属性：协议，可选值为 “http”、“https”、“ws”、“wss” 。如果有多个，使用 , 分隔。

• authorizations 属性：授权相关的配置，[] 数组，使用 @Authorization 注解。

• hidden 属性：是否隐藏，不再 API 接口文档中显示。

  @RestController
  @Api(value = "User API", tags = "User Management", description = "APIs for managing users")
  @RequestMapping("/api/users")
  public class UserController {
  
      // API 接口方法...
    
  }
  
  

@ApiOperation

@ApiOperation 注解是 Swagger 中用于标记Controller类中方法的注解，表示该方法是一个 API 操作，并可以添加说明和备注信息。

@ApiOperation 注解具有以下常用属性：

• value：指定 API 操作的简要描述或者说操作名。
• notes：提供 API 操作的详细描述和注释。
• tags：设置 API 操作所属的标签，用于对 API 进行分组和分类。和 @API 注解的 tags 属性一致。

@ApiOperation 不常用属性：

• nickname 属性：API 操作接口的唯一标识，主要用于和第三方工具做对接。
• httpMethod 属性：请求方法，可选值为 GET、HEAD、POST、PUT、DELETE、OPTIONS、PATCH 。因为 Swagger 会解析 SpringMVC 的注解，所以一般无需填写。
• produces 属性：和 @API 注解的 produces 属性一致。
• consumes 属性：和 @API 注解的 consumes 属性一致。
• protocols 属性：和 @API 注解的 protocols 属性一致。
• authorizations 属性：和 @API 注解的 authorizations 属性一致。
• hidden 属性：和 @API 注解的 hidden 属性一致。
• response 属性：响应结果类型。因为 Swagger 会解析方法的返回类型，所以一般无需填
• responseContainer 属性：响应结果的容器，可选值为 List、Set、Map 。
• responseReference 属性：指定对响应类型的引用。这个引用可以是本地，也可以是远程。并且，当设置了它时，会覆盖 response 属性。说人话，就是可以忽略这个属性，哈哈哈。
• responseHeaders 属性：响应头，[] 数组，使用 @ResponseHeader 注解。
• code 属性：响应状态码，默认为 200 。
• extensions 属性：拓展属性，[] 属性，使用 @Extension 注解。
• ignoreJsonView 属性：在解析操作和类型，忽略 JsonView 注释。主要是为了向后兼容。

@RestController
@Api(value = "User API", tags = "User Management")
@RequestMapping("/api/users")
public class UserController {

    @ApiOperation(value = "Get user by ID", notes = "Retrieve user information based on the given ID")
    @GetMapping("/{id}")
    public UserDTO getUserById(@PathVariable("id") Long id) {
        // 实现代码...
    }
  
}

@ApiOperation 注解标记了 getUserById 方法，其中 value 属性指定了 API 操作的简要描述为 “Get user by ID”，notes 属性提供了关于该 API 操作的详细描述，tags 属性设置了该 API 操作所属的标签为 “User Management”。
需要注意的是，@ApiOperation 注解通常使用在具体的 API 接口方法上，可以为每个方法添加对应的注解。这样可以根据注解的信息来生成准确的文档描述，方便其他开发人员了解和使用接口。

@ApiParam

@ApiParam 注解是 Swagger 中用于标记方法参数的注解，用于为 API 操作的参数添加描述和说明。

@ApiParam 注解具有以下常用属性：

• value：指定参数的简要描述。
• name：指定参数的名称。
• required：设置参数是否为必需，默认为 false。
• defaultValue：设置参数的默认值。
• allowableValues：指定参数的可接受值范围。
• example：设置参数的示例值。
• hidden：设置参数是否在文档中隐藏，默认为 false。

@RestController
@Api(value = "User API", tags = "User Management")
@RequestMapping("/api/users")
public class UserController {

    @ApiOperation(value = "Update user", notes = "Update the user information")
    @PutMapping("/{id}")
    public void updateUser(
            @ApiParam(value = "User ID", required = true) @PathVariable("id") Long id,
            @ApiParam(value = "User data", required = true) @RequestBody UserDTO userDto
    ) {
        // 实现代码...
    }
  
}

@ApiParam 注解分别标记了 id 和 userDto 两个参数。其中，id 参数的 value 属性指定了参数的简要描述为 “User ID”，required 属性设置参数为必需，userDto 参数的 value 属性指定了参数的简要描述为 “User data”。

通过使用 @ApiParam 注解，Swagger 可以根据该参数的注解生成相应的文档。开发人员可以在注解的属性中提供参数的描述、是否必需、默认值、可接受值范围等信息，帮助其他开发人员理解和使用该 API 接口。

需要注意的是，@ApiParam 注解通常使用在具体的 API 接口方法的参数上，可以为每个参数添加对应的注解。这样可以根据注解的信息来生成准确的文档描述，方便其他开发人员了解和使用接口。

@ApiImplicitParam

@ApiImplicitParam 注解是 Swagger 提供的用于描述 API 操作的参数的注解之一，用于标记方法参数，并提供参数的详细描述和说明。

@ApiImplicitParam 注解具有以下常用属性：

• name：指定参数的名称。

• value：指定参数的简要描述。

• dataType：指定参数的数据类型。

• dataTypeClass 属性：数据类型，通过 dataTypeClass 定义。在设置了 dataTypeClass 属性的情况下，会覆盖 dataType 属性。推荐采用这个方式。

• paramType：指定参数的类型，包括路径参数（path）、查询参数（query）、请求体参数（body）、表单参数（form）等。

  • path 值：对应 SpringMVC 的 @PathVariable 注解。
  • 【默认值】query 值：对应 SpringMVC 的 @RequestParam 注解。
  • body 值：对应 SpringMVC 的 @RequestBody 注解。
  • header 值：对应 SpringMVC 的 @RequestHeader 注解。
  • form 值：Form 表单提交，对应 SpringMVC 的 @PathVariable 注解。

• example：设置参数的示例值。

• required：设置参数是否为必需，默认为 false。

• defaultValue：设置参数的默认值。

@RestController
@Api(value = "User API", tags = "User Management")
@RequestMapping("/api/users")
public class UserController {

    @ApiOperation(value = "Create user", notes = "Create a new user")
    @ApiImplicitParams({
        @ApiImplicitParam(name = "name", value = "User name", dataType = "String", paramType = "query"),
        @ApiImplicitParam(name = "age", value = "User age", dataType = "int", paramType = "query")
    })
    @PostMapping("/")
    public void createUser(HttpServletRequest request) {
        String name = request.getParameter("name");
        int age = Integer.parseInt(request.getParameter("age"));
        
        // 实现代码...
    }
  
}

@ApiParam 注解和 @ApiImplicitParam 注解 区别

1. 适用范围：

   • @ApiParam 注解可以应用于方法的参数、字段或方法。
   • @ApiImplicitParam 注解主要应用于方法的参数。

2. 适用范围：

   • @ApiParam 注解可以应用于方法的参数、字段或方法。
   • @ApiImplicitParam 注解主要应用于方法的参数。

3. 所属注解：

• @ApiParam 注解属于 Swagger 的核心注解，提供了更丰富的参数描述功能。
• @ApiImplicitParam 注解属于 @ApiImplicitParams 注解的一部分，用于描述方法的多个参数。

3. 参数传递方式：

• @ApiParam 注解常用于路径参数、查询参数、请求体参数等。
• @ApiImplicitParam 注解常用于路径参数、查询参数等。

4. 参数描述灵活性：

• @ApiParam 注解提供了更多的属性，如 name、value、dataType、required、allowableValues 等，可以对参数进行详细描述，并支持限制范围、示例值等。
• @ApiImplicitParam 注解相对较简单，只提供了少数几个属性，如 name、value、dataType、paramType，可用于基本的参数描述。

使用 @ApiParam 注解时：

对 userId 和 userDto 这两个参数进行详细的描述和说明。

@PostMapping("/users/{id}")
public void updateUser(
    @PathVariable("id") @ApiParam(value = "User ID", example = "1") Long userId,
    @RequestBody @ApiParam(value = "Updated user information") UserDto userDto) {
    // 实现代码...
}

使用 @ApiImplicitParam 注解时：

@ApiImplicitParam 注解用于对 userId 和 userDto 这两个参数进行基本的描述和说明。

@PostMapping("/users/{id}")
@ApiImplicitParams({
    @ApiImplicitParam(name = "id", value = "User ID", dataType = "Long", paramType = "path"),
    @ApiImplicitParam(name = "userDto", value = "Updated user information", dataType = "UserDto", paramType = "body")
})
public void updateUser(@PathVariable("id") Long userId, @RequestBody UserDto userDto) {
    // 实现代码...
}

总而言之，@ApiParam 注解提供了更丰富的参数描述功能，并可以应用于更多的场景，而 @ApiImplicitParam 注解则相对简单，适合基本的参数描述。开发人员可以根据实际需求选择使用适当的注解来描述 API 操作的参数。

@ApiModel

@ApiModel 注解是 Swagger 中用于标记类的注解，表示该类是一个用于 API 文档定义的模型。

@ApiModel 注解具有以下常用属性：

• value：指定模型的名称。
• description：提供对模型的详细描述和注释。
• parent：指定该模型的父类。
• discriminator：设置该模型的鉴别器（用于区分不同子类的字段）。

@ApiModel(value = "User", description = "User object")
public class UserDTO {

    @ApiModelProperty(value = "User ID", example = "1")
    private Long id;

    @ApiModelProperty(value = "Username", example = "john.doe")
    private String username;

    // 省略其他属性和方法...
  
}

在上述代码中，@ApiModel 注解标记了 UserDTO 类，其中 value 属性指定了模型的名称为 “User”，description 属性提供了关于该模型的详细描述。

通过使用 @ApiModel 注解，Swagger 可以根据该类的注解生成相应的文档。开发人员可以在注解的属性中提供模型的名称、描述、父类等信息，帮助其他开发人员理解和使用该模型。

此外，还可以使用 @ApiModelProperty 注解标记模型中的属性，用于为属性添加描述和说明。@ApiModelProperty 注解具有类似于 @ApiParam 注解的属性，例如 value、example 等，用于提供属性的描述、示例值等信息。

需要注意的是，@ApiModel 注解通常使用在类上，用于标记该类是一个模型。而 @ApiModelProperty 注解通常使用在类的属性上，用于标记和描述属性。通过这些注解，Swagger 可以根据注解的信息生成准确的文档描述，方便其他开发人员了解和使用模型。

@ApiModelProperty

@ApiModelProperty 注解是 Swagger 提供的一个用于描述模型属性的注解。它可以用于类的字段或者 getter 方法上，用于提供更详细的属性描述和配置。

@ApiModelProperty 注解具有以下特点和用途：

1. 属性说明：通过 value 属性可以为属性提供文本说明，描述该属性的含义和用途。

2. 数据类型：通过 dataType 属性可以指定属性的数据类型，例如字符串、整数、布尔值等。

3. 示例值：通过 example 属性可以设置属性的示例值，用于展示该属性在实际使用中的取值范例。

4. 是否必需：通过 required 属性可以指定该属性是否是必需的，即是否需要在请求中提供该属性的值。

5. 隐藏属性：通过 hidden 属性可以控制是否将该属性隐藏起来，不在生成的文档中显示。

6. 其他配置：@ApiModelProperty 还提供了一些其他的属性，例如 allowableValues（限制属性的取值范围）、notes（额外的补充说明）等。这些属性可以根据需要进行配置。

   public class User {
       @ApiModelProperty(value = "用户ID", example = "12345")
       private Long id;
   
       @ApiModelProperty(value = "用户名", required = true)
       private String username;
   
       // 省略其他属性的定义和注解
   
       // Getter 和 Setter 方法
   }
   
   

   @ApiModelProperty 注解被应用于 id 和 username 这两个属性上，提供了属性的说明、示例值以及是否必需的信息。

@ApiResponse

@ApiResponse 注解是 Swagger 提供的一个用于描述 API 接口的响应信息的注解。它可以用于方法、类或者接口上，用于提供更详细的响应信息和配置。

@ApiResponse 注解具有以下特点和用途：

1. 响应说明：通过 message 属性可以为响应提供文本说明，描述该响应的含义和用途。
2. 响应码：通过 code 属性可以指定响应的状态码，例如 200、400、500 等。
3. 响应模型：通过 response 属性可以指定响应的模型类型，通常是一个实体类，用于描述响应的数据结构。
4. 多个响应：@ApiResponse 注解支持多个一起使用，可以用于描述一个接口方法可能返回的不同响应场景。可以使用 responseContainer 属性来指定响应数据的容器类型，例如 List、Map 等。
5. 其他配置：@ApiResponse 还提供了一些其他的属性，例如 reference（引用其他定义的响应模型）、responseHeaders（响应头信息）等。这些属性可以根据需要进行配置。

@GetMapping("/users/{id}")
@ApiResponse(code = 200, message = "成功", response = User.class)
@ApiResponse(code = 404, message = "用户不存在")
public User getUserById(@PathVariable("id") Long id) {
    // 实现代码...
}

@ApiResponse 注解被应用于 getUserById 方法上，提供了两个不同的响应场景：一个是 code 为 200 的成功响应，返回的是一个 User 类型的实体对象；另一个是 code 为 404 的用户不存在的错误响应。

@ApiResponses

@ApiResponses 注解是 Swagger 提供的一个用于描述 API 接口多个响应情况的注解。它可以用于方法、类或者接口上，用于提供更详细的响应信息和配置。

@ApiResponses 注解具有以下特点和用途：

1. 响应说明：通过 value 属性可以为多个响应情况提供文本说明，描述每个响应的含义和用途。
2. 响应列表：通过数组形式，使用 @ApiResponse 注解来描述每个响应情况。每个 @ApiResponse 注解包含 code、message、response 等属性，用于指定响应的状态码、说明和对应的响应模型。
3. 其他配置：@ApiResponses 还提供了一些其他的属性，例如 reference（引用其他定义的响应模型）、responseHeaders（响应头信息）等。这些属性可以根据需要进行配置。

@GetMapping("/users/{id}")
@ApiResponses(value = {
    @ApiResponse(code = 200, message = "成功", response = User.class),
    @ApiResponse(code = 404, message = "用户不存在")
})
public ResponseEntity<User> getUserById(@PathVariable("id") Long id) {
    // 实现代码...
}

@ApiResponses 注解被应用于 getUserById 方法上，提供了两个不同的响应情况：一个是 code 为 200 的成功响应，返回的是一个 User 类型的实体对象；另一个是 code 为 404 的用户不存在的错误响应。

@ApiIgnore

@ApiIgnore 是 Swagger 提供的一个注解，用于指示 Swagger 忽略某个特定的类、方法或字段，不生成对应的 API 文档。

使用 @ApiIgnore 注解的场景包括但不限于：

1. 忽略整个类：将 @ApiIgnore 注解应用于类上，表示 Swagger 忽略该类的所有 API 接口，不生成对应的文档信息。
2. 忽略单个方法：将 @ApiIgnore 注解应用于方法上，表示 Swagger 忽略该方法对应的 API 接口，不生成对应的文档信息。
3. 忽略字段：将 @ApiIgnore 注解应用于字段上，表示 Swagger 忽略该字段，不在生成的模型中包含该字段的信息。

@Api(tags = "用户管理")
@RestController
public class UserController {

    @ApiOperation("获取用户列表")
    @GetMapping("/users")
    public List<User> getUsers() {
        // 实现代码...
    }

    @ApiIgnore
    @GetMapping("/admin/users")    
    public List<User> getAdminUsers() {
        // 实现代码...
    }
}

getUsers 方法被 Swagger 生成为 API 文档的一部分，因为它没有被标记为 @ApiIgnore。而 getAdminUsers 方法被标记为 @ApiIgnore，因此 Swagger 将忽略它，不会生成对应的 API 文档。

使用 @ApiIgnore 注解可以方便地控制 Swagger 生成的 API 文档内容，特别是在某些情况下需要隐藏或排除一些不需要展示的接口或字段时非常有用。

Swagger UI-进阶

Knife4j 提供的主要特性包括：

• 界面美观：Knife4j 提供了漂亮的界面主题和样式，使得生成的 API 文档更加专业和吸引人。

• 接口分组：Knife4j 支持将接口按照一定的规则进行分组，方便用户对接口进行组织和管理。

• 接口测试：Knife4j 提供了在线的接口测试功能，使得开发人员可以在文档页面直接进行接口测试，而无需另外打开其他工具。

• 文档扩展：Knife4j 支持在 API 文档中嵌入自定义的 Markdown 格式文档，方便开发人员添加额外的说明和示例。

• 参数校验和模拟测试：Knife4j 支持对接口请求参数进行校验，并提供了模拟测试的功能，方便开发人员在不依赖后端接口实现的情况下进行接口调试。

1.引入依赖

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

2.添加配置类

@Configuration
public class ResourcesConfig implements WebMvcConfigurer
{

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry)
    {

        /** swagger配置 */
        registry.addResourceHandler("doc.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
    }
}

启动项目。然后浏览器访问 http://127.0.0.1:8080/doc.html 地址，就可以看到 Swagger 生成的 API 接口文档。效果如下：