Swagger 集成安装实践指南

于 2025-04-18 07:30:07 发布
阅读量740 收藏 12
点赞数 10
文章标签： maven java ci/cd postman
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglingli_zll/article/details/147317198
版权

Swagger 集成安装实践指南

一、Swagger 概述与使用场景

1.1 什么是 Swagger？

Swagger 是一套围绕 OpenAPI 规范构建的开源工具集，用于设计、构建、记录和使用 RESTful Web 服务。它通过交互式文档、客户端 SDK 生成和 API 可发现性等功能，简化了 API 开发的整个生命周期。

1.2 Swagger 的核心组件

  1. Swagger Editor - 基于浏览器的编辑器，用于编写 OpenAPI 规范
  2. Swagger UI - 将 OpenAPI 规范呈现为交互式 API 文档
  3. Swagger Codegen - 根据 API 规范生成服务器存根和客户端 SDK
  4. Swagger Core - Java 相关库，用于创建、使用 OpenAPI 规范

1.3 Swagger 的使用场景

  1. API 文档自动生成： 自动从代码生成实时更新的 API 文档
  2. 前后端协作： 前端开发者可在后端完成前使用 Swagger UI 进行接口调试
  3. API 测试： 通过交互式界面直接测试 API 端点
  4. 客户端 SDK 生成： 为不同语言生成客户端库，加速集成过程
  5. API 设计优先开发： 支持先设计 API 契约再实现代码的开发流程
  6. 微服务架构： 在分布式系统中统一管理和文档化多个服务

1.4 为什么需要 API 文档工具？

  • 团队协作痛点： 前后端分离架构下接口沟通成本高
  • 传统文档缺陷： 手动维护易过时、格式不统一、调试不便
  • 自动化优势： 实时更新、可视化测试、代码联调一体化

1.5 Swagger 核心功能矩阵

功能模块作用描述典型使用场景
Swagger EditorAPI 设计工具（在线/离线）编写 OpenAPI 规范文件
Swagger UI交互式文档展示开发测试阶段接口调试
Swagger Codegen客户端/服务端代码生成快速生成 SDK 和 Server 桩代码
Swagger InspectorAPI 自动化测试接口自动化测试验证
Swagger Hub云端 API 协作平台（企业版）团队 API 全生命周期管理

1.6 企业级应用场景深度解析

  • 微服务治理： 统一 50+ 服务的 API 规范标准
  • 开放平台建设： 生成开发者友好的 SDK 文档包
  • CI/CD 集成： API 变更自动生成差异报告
  • 契约测试： 保障接口实现与文档的一致性

二、Swagger 安装与配置

2.1 环境准备

  • Java 8+
  • Maven 3.2+
  • Spring Boot 2.x/3.x (如与 Spring 集成)

2.2 Swagger 2.x 安装 (Springfox)

2.2.1 添加 Maven 依赖：

<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>

2.2.2 创建 Swagger 配置类：

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
          .select()
          .apis(RequestHandlerSelectors.basePackage("com.your.package"))
          .paths(PathSelectors.any())
          .build()
          .apiInfo(apiInfo());
    }
    
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
          .title("Your API Title")
          .description("Your API Description")
          .version("1.0")
          .build();
    }
}

2.3 Swagger 3.x (OpenAPI 3.0) 安装

2.3.1 添加 Maven 依赖：

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>

2.3.2 配置类简化：

@Configuration
public class SwaggerConfig {
    
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.OAS_30)
          .select()
          .apis(RequestHandlerSelectors.basePackage("com.your.package"))
          .paths(PathSelectors.any())
          .build()
          .apiInfo(apiInfo());
    }
    
    private ApiInfo apiInfo() {
        // 同上
    }
}

2.4 SpringDoc OpenAPI (替代 Springfox 的现代方案)

2.4.1 对于 Spring Boot 2.6+ 和 3.x，推荐使用 SpringDoc:

<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-ui</artifactId>
    <version>1.6.14</version>
</dependency>

无需配置类，自动配置，访问 /swagger-ui.html 或 /v3/api-docs

三、Swagger 不同版本差异

Swagger 1.x vs 2.x vs 3.x

特性Swagger 1.xSwagger 2.x (OpenAPI 2.0)Swagger 3.x (OpenAPI 3.0)
规范名称SwaggerOpenAPI 2.0OpenAPI 3.0
文件扩展名.json.json/.yaml.json/.yaml
安全性定义有限支持支持OAuth2增强安全性支持
组件重用不支持部分支持完全支持$ref
多服务器定义不支持不支持支持
Webhook支持不支持不支持支持
回调定义有限改进更强大

Springfox vs SpringDoc

特性Springfox (Swagger 2)SpringDoc (OpenAPI 3)
Spring Boot 兼容性2.6.x以下全版本支持
配置复杂度需要较多配置自动配置为主
性能启动时扫描耗时更高效
社区活跃度维护减少活跃
WebFlux支持有限完整支持
注解支持Swagger注解支持Swagger和Javadoc

四、Swagger 基本使用

4.1 常用注解说明

4.1.1 控制器层注解

  • @Api: 标记控制器类
@Api(tags = "用户管理")
@RestController
@RequestMapping("/users")
public class UserController {}
  • @ApiOperation: 描述API操作
@ApiOperation(value = "创建用户", notes = "根据User对象创建用户")
@PostMapping
public User create(@RequestBody User user) {}
  • @ApiParam: 方法参数说明
@ApiOperation("根据ID获取用户")
@GetMapping("/{id}")
public User getById(@ApiParam(value = "用户ID", required = true) @PathVariable Long id) {}

4.1.2 模型注解

  • @ApiModel: 描述模型类
@ApiModel(description = "用户实体")
public class User {}
  • @ApiModelProperty: 描述模型属性
@ApiModelProperty(value = "用户ID", example = "1")
private Long id;

@ApiModelProperty(value = "用户名", required = true, example = "john_doe")
private String username;

4.2 分组配置

对于大型项目，可以配置多个Docket分组：

@Bean
public Docket userApi() {
    return new Docket(DocumentationType.SWAGGER_2)
        .groupName("用户管理")
        .select()
        .apis(RequestHandlerSelectors.basePackage("com.example.user"))
        .paths(PathSelectors.any())
        .build();
}

@Bean
public Docket orderApi() {
    return new Docket(DocumentationType.SWAGGER_2)
        .groupName("订单管理")
        .select()
        .apis(RequestHandlerSelectors.basePackage("com.example.order"))
        .paths(PathSelectors.any())
        .build();
}

五、企业级集成实践

5.1 安全集成

5.1.1 安全集成

添加JWT认证支持

@Bean
public Docket api() {
    return new Docket(DocumentationType.SWAGGER_2)
        .securitySchemes(Arrays.asList(apiKey()))
        .securityContexts(Arrays.asList(securityContext()))
        // 其他配置...
}

private ApiKey apiKey() {
    return new ApiKey("JWT", "Authorization", "header");
}

private SecurityContext securityContext() {
    return SecurityContext.builder()
        .securityReferences(defaultAuth())
        .forPaths(PathSelectors.any())
        .build();
}

List<SecurityReference> defaultAuth() {
    AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
    AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
    authorizationScopes[0] = authorizationScope;
    return Arrays.asList(new SecurityReference("JWT", authorizationScopes));
}

5.1.2 多环境配置

@Profile({"dev", "staging"}) // 只在开发和测试环境启用
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    // 配置内容
}

5.1.3 自定义响应消息

@Bean
public Docket api() {
    return new Docket(DocumentationType.SWAGGER_2)
        .useDefaultResponseMessages(false)
        .globalResponseMessage(RequestMethod.GET,
            Arrays.asList(
                new ResponseMessageBuilder()
                    .code(500)
                    .message("服务器内部错误")
                    .build(),
                new ResponseMessageBuilder()
                    .code(403)
                    .message("资源不可用")
                    .build()
            ))
        // 其他配置...
}

5.1.4 企业级完整配置示例

@Profile({"dev", "staging"})
@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Value("${system.version}")
    private String systemVersion;
    
    @Value("${swagger.enable}")
    private boolean enableSwagger;

    @Bean
    public Docket enterpriseApi() {
        return new Docket(DocumentationType.SWAGGER_2)
            .enable(enableSwagger)
            .select()
            .apis(RequestHandlerSelectors.basePackage("com.enterprise.api"))
            .paths(PathSelectors.ant("/api/**"))
            .build()
            .apiInfo(apiInfo())
            .securitySchemes(Arrays.asList(apiKey(), basicAuth()))
            .securityContexts(Arrays.asList(securityContext()))
            .produces(new HashSet<>(Arrays.asList("application/json")))
            .consumes(new HashSet<>(Arrays.asList("application/json")))
            .tags(new Tag("Users", "用户管理API"), 
                  new Tag("Orders", "订单管理API"))
            .genericModelSubstitutes(ResponseEntity.class)
            .useDefaultResponseMessages(false)
            .globalResponseMessage(RequestMethod.GET, commonResponseMessages())
            .globalResponseMessage(RequestMethod.POST, commonResponseMessages());
    }
    
    private ApiKey apiKey() {
        return new ApiKey("API-KEY", "X-API-KEY", "header");
    }
    
    private BasicAuth basicAuth() {
        return new BasicAuth("basicAuth");
    }
    
    private SecurityContext securityContext() {
        return SecurityContext.builder()
            .securityReferences(Arrays.asList(
                new SecurityReference("API-KEY", new AuthorizationScope[0]),
                new SecurityReference("basicAuth", new AuthorizationScope[0])))
            .forPaths(PathSelectors.regex("/api/.*"))
            .build();
    }
    
    private List<ResponseMessage> commonResponseMessages() {
        return Arrays.asList(
            new ResponseMessageBuilder().code(400).message("请求参数错误").build(),
            new ResponseMessageBuilder().code(401).message("未认证").build(),
            new ResponseMessageBuilder().code(403).message("无权限访问").build(),
            new ResponseMessageBuilder().code(404).message("资源不存在").build(),
            new ResponseMessageBuilder().code(500).message("服务器内部错误").build());
    }
    
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
            .title("企业级API平台")
            .description("企业级API文档系统")
            .version(systemVersion)
            .contact(new Contact("技术团队", "https://tech.enterprise.com", "tech@enterprise.com"))
            .license("企业许可协议")
            .licenseUrl("https://license.enterprise.com")
            .build();
    }
}

六、SpringBoot 3.x 集成实战

6.1 环境准备

<!-- pom.xml 核心依赖 -->
<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.2.0</version>
</dependency>

6.2 基础配置类

@Configuration
public class OpenAPIConfig {

    @Bean
    public OpenAPI springShopOpenAPI() {
        return new OpenAPI()
            .info(new Info().title("电商平台API")
                .description("Spring Boot 3.x 接口文档")
                .version("v1.0.0")
                .contact(new Contact()
                    .name("技术团队")
                    .email("tech@ec.com")))
            .externalDocs(new ExternalDocumentation()
                .description("开发手册")
                .url("https://doc.ec.com"));
    }
}

6.3 安全集成方案（JWT + OAuth2）

@Bean
public OpenAPI customOpenAPI() {
    return new OpenAPI()
        .components(new Components()
            .addSecuritySchemes("JWT", new SecurityScheme()
                .type(SecurityScheme.Type.HTTP)
                .scheme("bearer")
                .bearerFormat("JWT"))
            .addSecuritySchemes("OAuth2", new SecurityScheme()
                .type(SecurityScheme.Type.OAUTH2)
                .flows(new OAuthFlows()
                    .clientCredentials(new OAuthFlow()
                        .tokenUrl("/oauth/token")
                        .scopes(new Scopes()
                            .addString("read", "读权限")
                            .addString("write", "写权限")))))
        .addSecurityItem(new SecurityRequirement()
            .addList("JWT")
            .addList("OAuth2"));
}

七、企业级最佳实践案例

7.1 多模块项目配置

ecommerce-parent
├── user-service
├── product-service
├── order-service
└── api-gateway

7.2 网关层聚合配置

// 在 API Gateway 模块
@Bean
public OpenAPI groupOpenAPI(
   @Autowired List<GroupedOpenApi> groupedOpenApis) {
   
   return new OpenAPI()
      .paths(new Paths()
          .addPath("/users/**", 
              groupedOpenApis.get(0).getPaths().get("/**"))
          .addPath("/products/**",
              groupedOpenApis.get(1).getPaths().get("/**")));
}

7.3 接口响应增强示例

@Operation(summary = "创建订单")
@ApiResponses({
    @ApiResponse(responseCode = "201", 
        description = "订单创建成功",
        content = @Content(schema = @Schema(
            implementation = OrderResponse.class))),
    @ApiResponse(responseCode = "400",
        description = "参数校验失败",
        content = @Content(schema = @Schema(
            implementation = ErrorResponse.class))),
    @ApiResponse(responseCode = "403",
        description = "权限不足",
        content = @Content)
})
@PostMapping("/orders")
public ResponseEntity<OrderResponse> createOrder(
    @RequestBody @Valid OrderRequest request) {
    // 业务逻辑
}

7.4 智能参数校验文档化

public class UserRequest {

    @Schema(description = "用户名", 
        example = "john_doe",
        minLength = 4, 
        maxLength = 20,
        pattern = "^[a-zA-Z0-9_]+$")
    @NotBlank
    private String username;

    @Schema(description = "邮箱地址",
        format = "email",
        example = "user@example.com")
    @Email
    private String email;
}

八、常见问题与解决方案

8.1 Swagger UI 无法访问

问题： 访问 /swagger-ui.html 出现404
解决方案：

  • 检查依赖是否正确添加
  • 对于Spring Boot 2.6+，可能需要添加路径匹配配置：
spring:
  mvc:
    pathmatch:
      matching-strategy: ant_path_matcher
  • 检查是否有安全拦截，需要放行 /swagger-ui.html, /v2/api-docs 等路径

8.2 模型属性不显示

问题： 实体类属性未在Swagger文档中显示
解决方案：

  • 确保使用了 @ApiModelProperty 注解
  • 检查是否使用了正确的Getter/Setter方法
  • 对于非public字段，确保有对应的访问方法

8.3 接口分组问题

问题： 接口没有按预期分组显示
解决方案：

  • 检查 basePackage 配置是否正确
  • 确认不同分组的路径选择器没有重叠
  • 使用 @Api(tags = “分组名”) 进行显式分组

8.4 枚举类型显示问题

问题： 枚举类型在文档中显示为简单字符串
解决方案：

@ApiModelProperty(dataType = "string", allowableValues = "A, B, C")
private EnumType enumField;

或使用 @ApiModel 注解枚举类：

@ApiModel(description = "状态枚举")
public enum Status {
    @ApiModelProperty("活跃状态") ACTIVE,
    @ApiModelProperty("禁用状态") INACTIVE
}

8.5 大文件上传支持

问题： 文件上传接口文档不正确
解决方案：

@ApiOperation("上传文件")
@PostMapping(value = "/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public ResponseEntity<String> uploadFile(
    @ApiParam(value = "文件上传", required = true)
    @RequestPart("file") MultipartFile file) {
    // 实现
}

8.6 性能问题

问题： 项目启动慢，特别是大型项目
解决方案：

  • 限制扫描的包路径，避免扫描不需要的包
# application.yml 配置项
springdoc:
  cache:
    disabled: false # 启用缓存
  packages-to-scan: com.ec.user,com.ec.product # 限定扫描范围
  model-and-view-allowed: false # 禁用不必要组件
  default-consumes-media-type: application/json # 全局默认类型
  • 考虑使用SpringDoc替代Springfox
  • 在生产环境禁用Swagger
@Profile("!prod")
@Configuration
public class OpenAPIConfig { /* 开发环境配置 */ }

@Profile("prod")
@Configuration
public class OpenAPIDisabledConfig {
    @Bean
    public OpenAPI disableDoc() {
        return new OpenAPI().info(new Info().title("API已禁用"));
    }
}

九、高级主题

9.1 自定义UI

可以下载Swagger UI资源并自定义：

  1. 从 https://github.com/swagger-api/swagger-ui 下载dist目录
  2. 放到项目的 src/main/resources/static/swagger-ui 目录
  3. 修改 index.html 中的URL指向 /v2/api-docs
  4. 通过自定义页面访问

9.2 文档导出

9.2.1 文档导出方案对比

工具输出格式适用场景
Swagger2MarkupAsciiDoc/Markdown生成开发手册
Redocly CLIHTML静态站点部署官方文档中心
Postman CollectionsPostman格式接口测试套件导出

9.2.2 使用 swagger2markup 导出为静态文档：

<dependency> 
  <groupId>io.github.swagger2markup</groupId>
    <artifactId>swagger2markup</artifactId>
    <version>1.3.3</version>
</dependency>

导出代码：

@Test
public void generateAsciiDocs() throws Exception {
    URL swaggerUrl = new URL("http://localhost:8080/v2/api-docs");
    Path outputDir = Paths.get("build/asciidoc");
    
    Swagger2MarkupConfig config = new Swagger2MarkupConfigBuilder()
        .withMarkupLanguage(MarkupLanguage.ASCIIDOC)
        .build();
    
    Swagger2MarkupConverter.from(swaggerUrl)
        .withConfig(config)
        .build()
        .toFolder(outputDir);
}

9.3 与Spring HATEOAS集成

@Bean
public Docket api() {
    return new Docket(DocumentationType.SWAGGER_2)
        .select()
        .apis(RequestHandlerSelectors.any())
        .paths(PathSelectors.any())
        .build()
        .directModelSubstitute(Link.class, Resource.class)
        .alternateTypeRules(
            newRule(typeResolver.resolve(CollectionModel.class, WildcardType.class),
                typeResolver.resolve(List.class, WildcardType.class))
        .apiInfo(apiInfo());
}

十、企业级实用案例：电商平台API文档

10.1 场景描述

一个电商平台需要为以下模块提供API文档：

  1. 用户管理
  2. 商品管理
  3. 订单管理
  4. 支付管理
  5. 物流管理

10.2 与 API 网关的集成模式

  • 模式一： 网关统一聚合所有服务的文档
  • 模式二： 各服务独立维护文档，网关仅做路由
  • 模式三： 文档中心与网关解耦，独立部署

10.3 实现方案

10.3.1 多模块分组配置

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket userApi() {
        return buildDocket("用户管理", "com.enterprise.ecommerce.user");
    }
    
    @Bean
    public Docket productApi() {
        return buildDocket("商品管理", "com.enterprise.ecommerce.product");
    }
    
    // 其他模块类似...
    
    private Docket buildDocket(String groupName, String basePackage) {
        return new Docket(DocumentationType.SWAGGER_2)
            .groupName(groupName)
            .select()
            .apis(RequestHandlerSelectors.basePackage(basePackage))
            .paths(PathSelectors.any())
            .build()
            .securitySchemes(Arrays.asList(apiKey()))
            .securityContexts(Arrays.asList(securityContext()))
            .apiInfo(apiInfo());
    }
    
    // 其他配置方法...
}

10.3.2 订单管理API示例

@Api(tags = "订单管理", description = "订单相关操作")
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    @ApiOperation(value = "创建订单", notes = "根据购物车信息创建订单")
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(
        @ApiParam(value = "订单创建请求", required = true) 
        @RequestBody @Valid OrderCreateRequest request,
        @ApiParam(hidden = true) @RequestHeader("X-User-Id") Long userId) {
        // 实现
    }
    
    @ApiOperation(value = "获取订单详情", notes = "根据订单ID获取订单详情")
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDetailResponse> getOrderDetail(
        @ApiParam(value = "订单ID", required = true, example = "123") 
        @PathVariable String orderId) {
        // 实现
    }
    
    @ApiOperation(value = "取消订单", notes = "取消指定订单")
    @PostMapping("/{orderId}/cancel")
    public ResponseEntity<Void> cancelOrder(
        @ApiParam(value = "订单ID", required = true) 
        @PathVariable String orderId,
        @ApiParam(hidden = true) @RequestHeader("X-User-Id") Long userId) {
        // 实现
    }
}

10.3.3 订单模型示例

@ApiModel(description = "订单响应数据")
public class OrderResponse {
    
    @ApiModelProperty(value = "订单ID", example = "ORD123456")
    private String orderId;
    
    @ApiModelProperty(value = "订单状态", example = "PROCESSING")
    private OrderStatus status;
    
    @ApiModelProperty(value = "订单总金额", example = "199.99")
    private BigDecimal totalAmount;
    
    @ApiModelProperty(value = "创建时间", example = "2023-01-01T10:00:00")
    private LocalDateTime createTime;
    
    // getters/setters
}

@ApiModel(description = "订单创建请求")
public class OrderCreateRequest {
    
    @ApiModelProperty(value = "商品项列表", required = true)
    @NotEmpty
    private List<OrderItemRequest> items;
    
    @ApiModelProperty(value = "配送地址ID", required = true, example = "1")
    @NotNull
    private Long addressId;
    
    @ApiModelProperty(value = "支付方式", required = true, example = "ALIPAY")
    @NotNull
    private PaymentMethod paymentMethod;
    
    // getters/setters
}

十一、总结

Swagger 作为 API 开发的全套解决方案，在现代企业级开发中扮演着重要角色。随着 OpenAPI 规范的不断发展，建议关注 SpringDoc 等现代实现方案，特别是在 Spring Boot 2.6+ 和 3.x 项目中。良好的 API 文档不仅能提高开发效率，还能促进团队协作，是微服务架构中不可或缺的一部分。

JAVA：Spring Boot 整合 Swagger 的技术指南
木头
09-06 1585
JAVA：Spring Boot 整合 Swagger 的技术指南
集成Swagger
qq_46054503的博客
03-22 2688
集成步骤： 1、集成swagger需要导入下面两个依赖： <!--引入swagger支持--> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.9.2</version> </dependency> <!-- htt
SpringBoot集成Swagger指南
最新发布
命中的缘分的博客
03-11 424
你可以通过修改Swagger的配置来自定义UI界面，例如更改主题、添加自定义CSS等。通过以上步骤，你可以在Spring Boot项目中成功集成Swagger，并生成API文档。Swagger不仅可以帮助你自动生成文档，还可以提供一个交互式的UI界面，方便开发者测试和调试API。
SpringBoot 14、终极整合 Swagger
sowhat
08-29 957
整合 Swagger
Spring Boot——集成Swagger
一心同学的博客
12-31 4464
保姆级别讲解Swagger工具，讲解关于Swagger的各种实用知识点以及注意事项。
SpringBoot——整合Swagger
戏拈秃笔的博客
08-17 2744
Swagger是一款基于RESTful接口的用于文档在线自动生成和功能测试的开发工具 为了减少前后端开发人员在开发期间的频繁沟通，可以使用Swagger提供的接口文档和线上接口进行前后端功能联调
swagger安装
yangyw
06-28 875
swagger接口文档
Spring Boot-集成Swagger
2401_84048034的博客
05-06 1585
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
SpringBoot集成Swagger
wx1458084829
04-01 176
引入依赖 <properties> <swagger.version>2.6.1</swagger.version> </properties> <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>${swagge
springboot-Swagger集成
weixin_54097396的博客
04-23 858
Swagger官网 ：http://swagger.io/Swagger 是一个规范和完整的框架，用于生成、描述、功能调用测试和可视化 RESTful 风格的在线的接口文档工具。Swagger 是一套基于 OpenAPI 规范（OpenAPI Specification，OAS）构建的开源工具。Swagger 提供了一套通过代码和注解自动生成可视化的 RESTful 风格的API文档，符合 RESTful API设计的行业标准。
Springboot集成Swagger
热门推荐
weixin_51351637的博客
03-18 1万+
之前开发的时候，前端只用管理静态页面， http请求到后端， 模板引擎JSP，故后端是主力如今是前后端分离时代：后端：后端控制层，服务层，数据访问层前端：前端控制层，视图层伪造后端数据（JSON格式），便不再需要后端 ，方便了开发，等到前后端都开发完成之后，便不再使用伪造数据，而是访问远程后端接口前后端如何交互？
Java：SpringBoot系列——第六章 整合Swagger
chenyouchang的博客
01-12 2179
SpringBoot应用集成Swagger的步骤，用于生成接口规范文档和接口测试
【Spring boot框架】Spring boot集成Swagger
zhouhengjian的博客
07-12 735
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考1、POM添加Swagger jar包，但是主要spring boot 版本2、添加swagger配置文件3、启动访问swagger，
SpringBoot【3】集成 Swagger
CharlesYuangc的博客
06-21 756
SpringBoot 集成 Swagger2
swagger 安装（windows 10）
weixin_42369973的博客
09-22 1万+
1.安装node.js 安装swagger之前先去官网下载node进行安装，因为swagger是用node写的，https://nodejs.org/en/download/。 打开cmd 命令测试安装结果。 2.node中安装http-server 打开cmd 命令，执行npm install -g http-server 3.swagger-editor下载及启动 1、...
Swagger的配置安装
m0_62491932的博客
11-05 583
Swagger的配置安装
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值