swagger2.9.2版本与knife4j

swagger2.9.2是一个用于生成和展示API文档的开源工具，而knife4j是在swagger的基础上进行封装的工具，使得生成的文档更加美观和易用。要使用knife4j，首先需要在项目中引入knife4j的依赖，然后在swagger的配置类上添加@EnableKnife4j注解。最后，启动服务器并在浏览器中输入http://localhost:port/swagger-ui.html即可使用knife4j生成的文档。

相关问题

Spring boot 怎么集成 swagger 和 knife4j

### 回答1：

可以使用 Springfox 来集成 Swagger 和 Knife4j。Springfox 是一个用于构建 Swagger UI 和 Knife4j UI 的库。可以通过简单的配置，将 Swagger 和 Knife4j 集成到 Spring Boot 项目中。

### 回答2：
Spring Boot 集成 Swagger 和 Knife4j 的步骤如下：

1. 在项目的 pom.xml 文件中添加相关依赖：

<!-- Swagger2 依赖 -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>

<!-- Knife4j 依赖 -->
<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-spring-boot-starter</artifactId>
    <version>3.0.1</version>
</dependency>

2. 在项目的启动类上增加注解 `@EnableSwagger2`。

@SpringBootApplication
@EnableSwagger2
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

3. 配置 Swagger 相关参数，创建一个配置类（如 SwaggerConfig）。

@Configuration
public class SwaggerConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.demo"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("API 文档")
                .description("示例项目的API文档")
                .version("1.0.0")
                .build();
    }
}

4. 在浏览器中访问 Swagger 文档，URL 一般为 `http://localhost:8080/swagger-ui.html`，通过 Swagger 可以查看和测试 API 接口。

5. 如需使用 Knife4j 的增强功能，修改 Swagger 配置类中的 `Docket` 为 `Knife4jDocket`。

@Configuration
public class SwaggerConfig {
    @Bean
    public Knife4jDocket knife4jDocket() {
        return new Knife4jDocket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.demo"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("API 文档")
                .description("示例项目的API文档")
                .version("1.0.0")
                .build();
    }
}

经过以上步骤，就可以成功集成 Swagger 和 Knife4j，通过 Swagger 可以方便地查看和测试 API 接口文档，同时 Knife4j 提供了更多的增强功能，可以更好地管理和展示 API 接口文档。

### 回答3：
在Spring Boot中集成Swagger和Knife4j的步骤如下：

1. 添加依赖：
在Maven的pom.xml文件中，添加以下依赖：

   <dependency>
       <groupId>io.springfox</groupId>
       <artifactId>springfox-swagger2</artifactId>
       <version>2.9.2</version>
   </dependency>
   <dependency>
       <groupId>io.springfox</groupId>
       <artifactId>springfox-swagger-ui</artifactId>
       <version>2.9.2</version>
   </dependency>
   <dependency>
       <groupId>com.github.xiaoymin</groupId>
       <artifactId>knife4j-spring-boot-starter</artifactId>
       <version>2.0.2</version>
   </dependency>

2. 创建Swagger配置类：
创建一个Swagger配置类，用于配置Swagger的相关参数。可以参考以下示例代码：

   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import springfox.documentation.builders.ApiInfoBuilder;
   import springfox.documentation.builders.PathSelectors;
   import springfox.documentation.builders.RequestHandlerSelectors;
   import springfox.documentation.service.ApiInfo;
   import springfox.documentation.spi.DocumentationType;
   import springfox.documentation.spring.web.plugins.Docket;
   import springfox.documentation.swagger2.annotations.EnableSwagger2;

   @Configuration
   @EnableSwagger2
   public class SwaggerConfig {

       @Bean
       public Docket api() {
           return new Docket(DocumentationType.SWAGGER_2)
                   .apiInfo(apiInfo())
                   .select()
                   .apis(RequestHandlerSelectors.basePackage("com.example.controller"))
                   .paths(PathSelectors.any())
                   .build();
       }

       private ApiInfo apiInfo() {
           return new ApiInfoBuilder()
                   .title("API文档")
                   .description("API文档")
                   .version("1.0")
                   .build();
       }
   }

3. 配置Knife4j的扩展设置：
创建一个Knife4j配置类，用于配置Knife4j的相关参数。可以参考以下示例代码：

   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
   import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
   import springfox.documentation.swagger2.annotations.EnableSwagger2WebMvc;

   @Configuration
   @EnableSwagger2WebMvc
   public class Knife4jConfig implements WebMvcConfigurer {

       @Override
       public void addResourceHandlers(ResourceHandlerRegistry registry) {
           registry.addResourceHandler("doc.html")
                   .addResourceLocations("classpath:/META-INF/resources/");
           registry.addResourceHandler("/webjars/**")
                   .addResourceLocations("classpath:/META-INF/resources/webjars/");
       }

       @Bean
       public Knife4jProperties knife4jProperties() {
           Knife4jProperties properties = new Knife4jProperties();
           properties.setEnableKnife4j(true);
           return properties;
       }
   }

4. 启动应用程序：
启动Spring Boot应用程序，并访问"http://localhost:8080/swagger-ui.html"，即可查看生成的Swagger API文档。

总结：
通过添加相关的依赖和配置类，我们可以很容易地在Spring Boot中集成Swagger和Knife4j。Swagger用于生成API文档，而Knife4j是对Swagger的扩展，提供了更丰富的功能和界面。集成后，我们可以方便地查看和测试接口文档。

srpingboot 集成swagger2 knife4j 具体的demo

以下是一个使用Spring Boot集成Swagger2和Knife4j的示例：

首先，在`pom.xml`文件中添加以下依赖项：

<!-- Swagger2 -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>

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

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

接下来，在Spring Boot的启动类中加上Swagger2和Knife4j的相关注解。示例中的启动类为`DemoApplication.java`：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
@EnableSwagger2
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.demo.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Demo API")
                .description("API documentation for demo project")
                .version("1.0")
                .build();
    }
}

在上述代码中，我们通过`@EnableSwagger2`注解启用Swagger2，并创建了一个`Docket` bean来配置Swagger2的基本信息。

接下来，在控制器类中使用Swagger2的注解来定义API文档。示例中的控制器类为`DemoController.java`：

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;

@RestController
@RequestMapping("/api")
@Api(tags = "Demo API")
public class DemoController {

    @GetMapping("/hello")
    @ApiOperation(value = "Say hello", notes = "Returns a greeting message")
    public String sayHello() {
        return "Hello, Swagger!";
    }
}

在上述代码中，我们使用了Swagger2的注解`@Api`和`@ApiOperation`来定义API的标签、描述和操作。

最后，运行Spring Boot应用程序，并访问`http://localhost:8080/doc.html`即可查看生成的API文档。你将看到Swagger2和Knife4j提供的界面，展示了API的详细信息。

这就是一个简单的Spring Boot集成Swagger2和Knife4j的示例。你可以根据实际需求进行配置和扩展。希望对你有所帮助！