Dans le mode de développement actuel avec une vitesse itérative de plus en plus rapide, de plus en plus de projets sont développés en utilisant springboot comme framework côté serveur Une fois le développement de l'API back-end et l'auto-test terminés, comment les collègues front-end peuvent-ils se connecter avec vous rapidement et efficacement ? Qu'en est-il des API ? Vous connaissez peut-être les moyens suivants :

1.1 Rédiger la documentation de l'API

Il s'agit d'une approche relativement traditionnelle par de nombreuses entreprises. D'une manière générale, cette méthode a des exigences élevées pour les développeurs d'API, car le processus d'écriture de document est relativement long, donc avant que l'API ne soit développée, il est nécessaire de contrôler strictement les paramètres du API Afin de réduire le coût des événements causés par les modifications du processus d'amarrage. Les documents peuvent être modifiés à l'aide de documents Word traditionnels ou à l'aide de Markdown.

1.2 Utiliser des outils de débogage en ligne

De nos jours, il existe de nombreux outils de débogage d'interface en ligne sur le marché. Il vous suffit de déployer votre service API sur le serveur, puis vous pouvez déboguer à distance en ligne.

1.3 facteur

Il s'agit d'un outil de débogage local relativement traditionnel mais également très utile.Pour l'équipe, le développeur du serveur peut saisir l'API développée par A, puis partager l'API via le mode de partage d'équipe, et le frontal peut l'obtenir. a été débogué et ancré.

1.4 fanfaronnade

Avec l'utilisation croissante de swagger et sa popularité, en particulier dans le mode de développement agile, il présente plus d'avantages et est accepté par de nombreuses équipes de développement. Il suffit d'intégrer des dépendances swagger côté serveur, puis de faire une configuration simple. Il peut être utilisé immédiatement, et le coût d'utilisation et d'apprentissage peut être considéré comme presque nul.

2. Introduction à la fanfaronnade

2.1 Contexte

Après que la séparation actuelle des front-end et back-ends soit devenue le modèle de base pour une itération rapide du produit, la façon de terminer rapidement le débogage conjoint rapide de l'API et du front-end est devenue un facteur clé dans la version progressive du produit. contexte, bien que le front-end puisse remplir ses propres fonctions grâce à la vérification des données fictives, mais il n'y a pas de véritable débogage conjoint des données avec le serveur, je me sens toujours peu fiable, mais différentes équipes ont différentes méthodes de débogage conjoint, ce qui oblige certaines équipes à utiliser des outils simples , une efficacité de débogage conjointe élevée et certains complexes, entraînant une efficacité de débogage conjointe très faible, et même de nouveaux coûts d'apprentissage.

Dans ce contexte, comment améliorer le débogage conjoint rapide avec API et réduire au maximum le coût d'apprentissage des membres de l'équipe ? Ainsi, l'émergence de swagger est une bonne solution à un tel problème.

2.2 Avantages et inconvénients du swagger

2.2.1 Avantages du fanfaron

L'utilisation de swager présente les avantages suivants :

L'intégration est simple, il suffit d'introduire un package jar swagger et de faire une configuration simple;
Générez automatiquement des documents, utilisez simplement les annotations pertinentes de swagger dans l'interface pour annoter, et les documents d'interface correspondants peuvent être générés ;
Mettre à jour automatiquement le document, car il est généré dynamiquement, donc si vous modifiez l'interface, le document sera automatiquement modifié en conséquence (si vous mettez également à jour l'annotation). De cette façon, je n'enverrai pas la situation où j'ai modifié l'interface mais oublié de mettre à jour le document d'interface ;
Prend en charge le débogage en ligne, swagger fournit la fonction d'interface d'appel en ligne ;

2.2.2 Inconvénients du fanfaron

Bien que swagger apporte de la commodité à la gestion des API, il y a encore quelques lacunes,

Vous ne pouvez pas créer de cas de test, mais fournissez uniquement un débogage en ligne simple. Si vous souhaitez stocker des cas de test, vous devez choisir d'autres outils, tels que postman, ou exporter des fichiers yaml via swagger pour le stockage ;
Certaines normes de codage de base doivent être suivies dans le programme. Par exemple, si vous devez renvoyer des données json et que ces données peuvent être au format Map, nous ne pouvons pas marquer la description de chaque champ des données renvoyées dans ce format Map pour le moment, et s'il s'agit d'une classe d'entité , il doit s'agir d'une classe d'entités Les attributs sont marqués d'annotations spécifiques.Le problème causé par cela est évidemment que la classe d'entités du programme semble un peu désordonnée, pas assez soignée et redondante ;
Il est impossible de rafraîchir dynamiquement l'API.Si vous oubliez de redémarrer une certaine interface actuellement utilisée par le frontal après l'avoir modifiée localement, le frontal peut toujours utiliser l'ancienne interface ;
Il y a un certain degré de problème de sécurité et trop d'informations seront exposées sur l'interface utilisateur. Par exemple, dans une certaine interface, le frontal peut n'avoir besoin que de 3 paramètres requis, mais sur l'interface utilisateur de swagger, tout le champ les informations de l'objet seront affichées. Remplissez-le, de sorte qu'il semble désordonné et redondant ;

2.2.3 scénarios d'utilisation fanfarons

Tous les projets ne sont pas adaptés à l'utilisation de swagger. Par exemple, certains projets plus anciens peuvent entraîner d'énormes coûts de temps et de main-d'œuvre s'ils sont fortement intégrés en raison de problèmes de version. Certains projets ont également des exigences de sécurité particulièrement élevées et ne sont pas autorisés à être arbitraire. Il n'est pas approprié d'utiliser swagger pour exposer l'API du serveur au réseau externe. Cependant, à en juger par la tendance actuelle, l'utilisation de swagger peut encore améliorer l'efficacité globale du développement et de l'amarrage. Voici quelques scénarios résumés ci-dessous pour référence:

Pour les projets avec un petit volume d'affaires, une itération rapide des fonctions et des exigences de temps de développement serrées, vous pouvez envisager d'utiliser swagger ;
Exigences de sécurité faibles, ou uniquement utilisé dans l'environnement intranet de l'entreprise, ou uniquement utilisé au stade du développement, cela peut également être considéré comme une utilisation fanfaronnade au stade du développement ;
Le framework de serveur est springboot, et springboot occupe actuellement le courant dominant du framework de microservices, il est donc plus pratique de s'intégrer à swagger;

3. Plusieurs modes d'intégration couramment utilisés par swagger

Prenant l'intégration de springboot et swagger comme exemple, il offre une variété de façons d'utiliser.Voici ceux qui sont couramment utilisés.Maîtriser ceux-ci devrait être suffisant pour faire face à la plupart des scénarios.

3.1 fanfaronnades2

C'est une méthode originale, et c'est aussi une méthode souvent utilisée par de nombreuses petites équipes, elle peut être utilisée en introduisant directement le package jar dépendant de base de swagger. L'intégration avec springboot comprend principalement les packages suivants :

springfox-swagger2 ;
springfox-swagger-ui ;

3.2 couteau4j

Le prédécesseur de Knife4j est swagger -bootstrap-ui, et le prédécesseur swagger-bootstrap-ui est un pur projet de skin swagger-ui ui;

L'intention initiale du projet était d'écrire une version améliorée de l'interface utilisateur frontale de swagger, mais avec le développement du projet, confronté à des besoins de plus en plus personnalisés, le code Java principal a dû être écrit pour répondre à de nouveaux besoins.

Entre les versions 1.8.5 et 1.9.6 de swagger-bootstrap-ui, le code Java back-end et l'interface utilisateur sont mélangés dans un package Jar que les développeurs peuvent utiliser. Bien que cette méthode soit très pratique pour intégrer swagger, il suffit d'introduire le package jar, mais elle semble un peu gonflée sous l'architecture microservice. Par conséquent, le projet a été officiellement renommé knife4j, nommé knife4j dans l'espoir qu'elle puisse être aussi petite, légère et puissante qu'un poignard. Le changement de nom espère également en faire une solution générale pour les documents d'interface Swagger, et pas seulement se concentrer sur l'interface utilisateur frontale.

3.2.1 fonctionnalités de knife4j

Toutes les fonctionnalités de swagger-bootstrap-ui seront concentrées dans le package knife4j-spring-ui, et la planification ultérieure répondra également aux besoins plus personnalisés des développeurs ;
Le principal changement est que le chemin du package de classe pertinent du projet est remplacé par le préfixe com.github.xiaoymin.knife4j, et les développeurs doivent remplacer le chemin du package lors de l'utilisation d'annotations améliorées ;
Le code Java back-end et le package d'interface utilisateur sont séparés en packages jar de plusieurs modules pour faciliter l'utilisation d'annotations de documents améliorées sous l'architecture de microservice actuelle (en utilisant le projet de microservice SpringCloud, seul le package jar de l'interface utilisateur doit être intégré au couche passerelle C'est tout, alors séparez les extrémités avant et arrière);
knife4j continue d'utiliser le numéro de version de swagger-bootstrap-ui, la première version commence à partir de 1.9.6, veuillez vous référer à la documentation pour la méthode d'utilisation (extraite de l'introduction officielle de knife4j);

3.2.2 notes de version de knife4j

Les principales versions de knife4j sont essentiellement les suivantes

1.9.6	Style de peau bleue, commencez à changer de nom, ajoutez plus de modules backend
2.0~2.0.5	Ui réécrit, la version sous-jacente du framework springfox est 2.9.2
2.0.6~	La version du framework springfox est mise à niveau vers 2.10.5 et la spécification OpenAPI est v2
3.0~	La version sous-jacente du framework springfox de dépendance est mise à niveau vers 3.0.3 et la spécification OpenAPI est v3

3.3 Springdoc

Par rapport aux deux premiers, springdoc est actuellement très populaire. Premièrement, ce framework est relativement nouveau, et la vitesse de maintenance et de mise à jour du code est rapide, et lorsqu'il est intégré au projet springboot, il fournit également un plug-in de sécurité, qui peut améliorer l'utilisation dans une certaine mesure. L'adresse de git est : adresse du code source springdoc

3.3.1 Présentation de SpringDoc

SpringDoc est un outil de génération de documents d'API qui peut être utilisé conjointement avec SpringBoot. Basé sur OpenAPI 3, il compte actuellement plus de 1 700 étoiles sur Github. La version de mise à jour est toujours très diligente. C'est une meilleure bibliothèque Swagger ! Il convient de mentionner que SpringDoc supporte non seulement les projets Spring WebMvc, mais également les projets Spring WebFlux, et même les projets Spring Rest et Spring Native. Bref, il est très puissant. Voici un schéma d'architecture SpringDoc.

Quatre boîtiers multimodes intégrés Springboot

Ce qui précède a théoriquement compris plusieurs façons couramment utilisées d'utiliser Swagger, puis donnera des explications détaillées à travers des cas réels.

4.1 springboot intègre swagger2

Pré-préparation, construisez le projet springboot, la structure du répertoire est la suivante

4.1.1 Ajouter les dépendances principales suivantes

Les éléments suivants ne sont que des dépendances de base, vous pouvez les ajouter en fonction de votre propre situation

<dependencies>

        <dependency>
            <groupId>org.modelmapper</groupId>
            <artifactId>modelmapper</artifactId>
            <version>3.1.0</version>
        </dependency>

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

        <!--swagger API获取-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <!--swagger-ui API获取-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>


    </dependencies>

4.1.2 Fichier de configuration

L'utilisation de cette méthode ne nécessite pas trop de configuration, un seul port est configuré ici

server.port=8088

4.1.3 Classe de configuration swagger personnalisée

Cette classe est la configuration la plus importante dans l'ensemble du processus d'intégration, comprenant principalement :

Définissez le chemin de numérisation de l'interface ;
L'interface swagger-ui affiche des informations ;

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.service.Contact;
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 createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                //用于生成API信息
                .apiInfo(apiInfo())
                //select()函数返回一个ApiSelectorBuilder实例,用来控制接口被swagger做成文档
                .select()
                //用于指定扫描哪个包下的接口
                .apis(RequestHandlerSelectors.basePackage("com.congge.controller"))
                //选择所有的API,如果你想只为部分API生成文档，可以配置这里
                .paths(PathSelectors.any())
                .build();
    }

    /**
     * 用于定义API主界面的信息，比如可以声明所有的API的总标题、描述、版本
     * @return
     */
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                //用来自定义API的标题
                .title("SpringBoot项目SwaggerAPIAPI测试")
                //用来描述整体的API
                .description("SpringBoot项目SwaggerAPI描述信息")
                //创建人信息
                .contact(new Contact("测试人员","http://localhost:8082/swagger-ui.html","[email protected]"))
                //用于定义服务的域名
                //.termsOfServiceUrl("")
                .version("1.0") //可以用来定义版本
                .build();
    }

}

4.1.4 Interface de test personnalisée

Pour personnaliser une interface de test, on peut dire que pour permettre à l'interface du projet d'être déboguée dans swagger-ui, le plus important est d'ajouter cette annotation à la classe : @Api, quelques annotations sur d'autres méthodes, vous pouvez vous référer au document officiel Il suffit de le configurer ;

//http://localhost:8088/swagger-ui.html  主页访问地址

@RestController
@Api(tags = "UserController", description = "UserController | 测试swagger")
public class UserController {

    @GetMapping("getById")
    @ApiOperation(value="getById 方法", notes="getById，根据ID获取账户信息")
    public User getById(){
        return new User("001","jerry","123456");
    }

    @PostMapping("/save")
    public String saveUser(UserRequest userRequest){
        User user = new User();
        BeanUtils.copyProperties(userRequest,user);
        return "success";
    }

}

4.1.5 Classe d'entité personnalisée

Dans de nombreux cas, les paramètres de l'interface sont des types d'objets. À ce stade, afin que les collègues d'accueil connaissent la signification de chaque paramètre de l'objet, il est préférable d'ajouter des annotations fanfaronnes aux propriétés de chaque objet selon la spécification swagger. Un exemple est fourni ci-dessous ;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value="用户登录表单对象",description="用户登录表单对象")
public class User implements Serializable {

    private static final long serialVersionUID = -2896873555774275129L;

    @ApiModelProperty(value = "用户ID",required = true,example = "001")
    private String id;

    @ApiModelProperty(value = "用户名称",required = true,example = "jerry")
    private String userName;

    @ApiModelProperty(value = "密码",required = true,example = "123456")
    private String passWord;

}

4.1.6 Accéder à l'interface Swagger

Démarrez le service, puis visitez le navigateur : http://localhost:8088/swagger-ui.html , quant à la façon de déboguer et d'utiliser, les étudiants intéressés peuvent l'essayer par eux-mêmes, c'est relativement simple ;

4.2 couteau d'intégration springboot4j

Ce qui précède présente brièvement le contexte de knife4j. Ensuite, examinons les étapes détaillées de l'intégration de knife4j dans springboot. Tout d'abord, créez un projet springboot vide à l'avance. La structure du répertoire est la suivante

4.2.1 Présentation des dépendances principales

Seuls deux packages sont nécessaires pour la démonstration ici, si vous avez d'autres exigences, vous pouvez continuer à les ajouter ;

    <dependencies>
        <!-- Spring Boot Web依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

    </dependencies>

4.2.2 Classe de configuration personnalisée

Ceci est similaire à l'intégration de swagger2 ci-dessus. Vous devez personnaliser une classe qui définit les informations d'affichage de l'interface utilisateur et le chemin du package où se trouve la classe d'interface analysée.

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.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class Knife4jConfiguration {

    @Bean(value = "defaultApi2")
    public Docket defaultApi2() {
        String groupName="3.X版本";
        Docket docket=new Docket(DocumentationType.OAS_30)
                .apiInfo(new ApiInfoBuilder()
                        .title("这是knife4j API ")
                        .description("这是knife4j，记录了API相关的出参和入参信息")
                        .termsOfServiceUrl("http://yaomaoyang.com")
                        .contact(new Contact("congge","http://127.0.0.1","[email protected]"))
                        .version("3.0")
                        .build())
                //分组名称
                .groupName(groupName)
                .select()
                //这里指定Controller扫描包路径
                .apis(RequestHandlerSelectors.basePackage("com.congge.controller"))
                .paths(PathSelectors.any())
                .build();
        return docket;
    }
}

4.2.3 Ajouter une interface de test

Afin de permettre à l'interface d'être affichée sur l'interface de l'interface utilisateur, la chose la plus importante est d'ajouter cette annotation @Api sur la classe. D'autres annotations peuvent être marquées sur la méthode de la classe d'interface selon les besoins, de la même manière que l'utilisation de swagger ci-dessus ;

@RestController
@RequestMapping(value = "/user")
@Api(tags = "用户管理API")
public class UserController {

    /**
     * 根据ID获取账户信息
     * @param id
     * @return
     */
    @GetMapping(value = "/getById")
    @ApiImplicitParam(name = "name",value = "姓名",required = true)
    @ApiOperation("根据ID获取账户信息")
    public User test(@RequestParam("id") String id){
        User user = new User();
        user.setId(id);
        user.setPassWord("123456");
        user.setUserName("jerry");
        return user;
    }

}

4.2.4 Classes d'entités personnalisées

Si les paramètres reçus dans certaines interfaces sont un objet, afin de permettre aux autres élèves de comprendre les paramètres de l'objet, vous pouvez ajouter des annotations fournies par knife4j à l'objet.Voici un exemple

@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value="用户登录表单对象",description="用户对象参数")
public class User implements Serializable {

    private static final long serialVersionUID = -2896873555774275129L;

    @ApiModelProperty(value = "用户ID",required = true,example = "001")
    private String id;

    @ApiModelProperty(value = "用户名称",required = true,example = "jerry")
    private String userName;

    @ApiModelProperty(value = "密码",required = true,example = "123456")
    private String passWord;

}

4.2.5 Accéder à l'interface utilisateur

Démarrez le projet, puis accédez à l'interface via cette adresse : http://localhost:8082/doc.html pour voir si l'interface a un style plus professionnel ;

4.3 intégration de springboot springdoc

Par rapport aux deux premiers, springdoc est apparu plus tard, mais à l'heure actuelle, sa popularité semble être meilleure.D'une part, il a les fonctions de base du fanfaron, et en même temps, il a certaines garanties sur la sécurité d'accès. , Regardons les étapes d'intégration spécifiques, créons un projet springboot à l'avance, la structure du répertoire est la suivante :

4.3.1 Ajouter des dépendances principales

D'autres dépendances peuvent être citées comme appropriées en fonction de leurs propres circonstances

    <dependencies>
        <!-- Spring Boot Web依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- springdoc swagger ui -->
        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-ui</artifactId>
            <version>1.7.0</version>
        </dependency>

        <dependency>
            <groupId>org.springdoc</groupId>
            <artifactId>springdoc-openapi-javadoc</artifactId>
            <version>1.7.0</version>
        </dependency>
    </dependencies>

4.3.2 Fichiers de configuration de base

Ajoutez les configurations suivantes au fichier application.yml. Ces configurations sont bien connues et ne seront pas expliquées ici. Parmi elles :

api-docs.path : /v3/api-docs Cette configuration consiste à obtenir l'adresse du document yml de l'interface

Il contient des configurations plus riches, vous pouvez vous référer aux informations sur Internet, il existe des instructions plus détaillées, par exemple, vous pouvez également configurer le pré-chemin pour ouvrir l'interface de l'interface utilisateur, etc.

# springdoc配置
springdoc:
  # 分组配置
  group-configs:
    - group: 用户管理
      packages-to-scan: com.congge.controller
      paths-to-match: /users/**
    - group: 角色管理
      packages-to-scan: com.congge.controller
      paths-to-match: /roles/**
  api-docs:
    enabled: true
    path: /v3/api-docs

server:
  port: 8087

4.3.3 Classe de configuration personnalisée

La configuration personnalisée peut regrouper et gérer diverses API dans le projet et les injecter dans le conteneur Spring sous la forme de beans ;

import io.swagger.v3.oas.models.Components;
import io.swagger.v3.oas.models.ExternalDocumentation;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import io.swagger.v3.oas.models.servers.Server;
import org.springdoc.core.GroupedOpenApi;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Arrays;

@Configuration
public class OpenApiConfig {

    /*@Bean
    public OpenAPI springShopOpenAPI() {
        return new OpenAPI()
                .info(new Info().title("Springdoc OAS3.0 - RESTful API")
                        .description("Springdoc OAS3.0 构建RESTful API")
                        .version("1.0")
                        .license(new License().name("Apache 2.0").url("http://springdoc.org")))
                .servers(Arrays.asList(
                        new Server().description("开发环境").url("http://localhost:8087")
                ))
                .externalDocs(new ExternalDocumentation()
                        .description("SpringShop Wiki Documentation")
                        .url("https://springshop.wiki.github.org/docs"));
    }*/

    @Bean
    public OpenAPI openAPI() {
        return new OpenAPI()
                .components(new Components())
                .info(new Info()
                        .title("User Manager API")
                        .description("用户管理系统API.")
                        .version("1.0"));
    }

    @Bean
    public GroupedOpenApi frontApi() {
        return GroupedOpenApi.builder()
                .group("frontApi")
                .pathsToMatch(new String[]{"/users/**", "/roles/**"})
                .packagesToExclude("com.congge.controller")
                .build();
    }
}

4.3.4 Interface de test personnalisée

Notez que l'annotation sur la classe d'interface, @Tag, est la clé de la reconnaissance sur l'interface utilisateur ;

//http://localhost:8087/swagger-ui/index.html?urls.primaryName=%E7%94%A8%E6%88%B7%E7%AE%A1%E7%90%86

@Tag(name = "用户管理", description = "用户管理FrontApi")
@RestController
@RequestMapping("/users")
public class UserController {

    /**
     * 查询用户详细信息
     *
     * @param id 用户ID
     * @return 用户信息
     */
    @GetMapping("/get")
    public UserInfo getUser(@RequestParam String id) {
        return new UserInfo();
    }

}

@Data
@Schema(description = "用户返回实体对象")
class UserInfo {
    @Schema(description = "用户名称")
    private String userName;
    @Schema(description = "用户密码")
    private String passWord;
}

4.3.5 Accéder à l'interface utilisateur

Démarrez le projet et accédez à l'adresse de l'interface : http://localhost:8087/swagger-ui/index.html , vous pouvez voir l'effet suivant, qui est similaire aux deux précédents lors du débogage de l'interface sur l'interface de l'interface utilisateur ;

5. Écrivez à la fin

Cet article résume en détail les différentes manières d'utiliser springboot pour intégrer swagger, en espérant vous apporter une aide dans votre développement au quotidien. C'est la fin de cet article, merci d'avoir regardé !

[Microservices] Springboot intègre swagger dans plusieurs modes et les utilise en détail

Introduction