swagger est un outil populaire de génération de documents d'interface en temps réel. Les documents d'interface sont un outil indispensable dans les projets actuels de séparation front-end et back-end. Avant le développement front-end et front-end, le back-end doit d'abord produire le document d'interface. Le front-end développe le projet sur la base de l'interface. Une fois le développement des deux parties terminé, un débogage et des tests conjoints seront effectués.
Le document d'interface est donc en fait un accord entre les deux parties avant développement. Habituellement, les documents d'interface sont divisés en hors ligne et en temps réel. Les outils de document d'interface hors ligne incluent : Word (équivalent à Wu a dit), YAPI, Xiaoyaoji, etc. Ce type de document doit être écrit par des programmeurs et dispose généralement de fonctions de test d'interface. Habituellement, les développeurs écrivent d'abord les informations sur le document d'interface hors ligne, puis les transmettent au personnel frontal pour un développement de référence. Le plus gros inconvénient est que lorsque notre programme d'interface change, nous devons revenir en arrière et maintenir le contenu ci-dessus, ce qui est très gênant, vraiment gênant.
Le document d'interface en temps réel peut générer automatiquement le document d'interface correspondant en fonction de notre code. L'avantage est que lorsque notre code change, le document d'interface généré sera automatiquement mis à jour. il suffit de le libérer à temps. Cependant, comme il est généré automatiquement à partir du code, le plus gros inconvénient est que le code est très intrusif et nous oblige à intégrer le code pertinent pour générer les documents d'interface dans le code du projet. Il existe de nombreuses solutions pour la documentation des interfaces en temps réel, mais swagger reste l'une des plus influentes.
Adresse du site officiel : swagger.io Bien sûr, le site officiel est entièrement en anglais, ce qui semble assez gênant. Je vous suggère de suivre mes étapes, c'est très simple.
En même temps, permettez-moi de dire quelque chose : swagger est divisé en deux versions couramment utilisées : swagger2 et swagger3. La différence entre les deux n'est pas très grande. Il optimise principalement les dépendances et les annotations. Swagger2 doit introduire deux packages jar, et swagger3 n'en a besoin que d'un seul. Il n'y a pas de grande différence d'utilisation. Ce qui suit prend swagger2 comme exemple.
<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>Vous devez d'abord ajouter une annotation : @EnableSwagger2. Nous pouvons ajouter cette annotation à la classe de démarrage SpringBoot, ou nous pouvons personnaliser une classe de configuration et la placer dessus. Après avoir ajouté cette annotation, cela signifie que nous avons activé la fonction Swagger dans le projet.
Nous utilisons la deuxième méthode pour définir nous-mêmes une classe de configuration, et nous pouvons également ajouter une configuration Docket. La configuration dite du Docket est la configuration d'un ensemble de documents d'interface (un projet ou une version), tels que les noms de paramètres, les contacts, etc.
Nous ajoutons une classe SwaggerConfig sous le dossier de configuration.
@Configuration
@EnableSwagger2
public class SwaggerConfig {
/**
* 设置多个：
*
* @Bean
* public Docket appApi() {
*
* List<Parameter> pars = new ArrayList<>();
* ParameterBuilder token = new ParameterBuilder();
* token.name("token").description("用户令牌").modelRef(new ModelRef("string")).parameterType("header").required(false)
* .build();
* pars.add(token.build());
*
* return new Docket(DocumentationType.SWAGGER_2).select().paths(regex("/app/.*")).build()
* .globalOperationParameters(pars).apiInfo(pdaApiInfo()).useDefaultResponseMessages(false)
* .enable(enableSwagger)
* .groupName("appApi");
*
* }
*
* @Bean
* public Docket adminApi() {
*
* List<Parameter> pars = new ArrayList<>();
* ParameterBuilder token = new ParameterBuilder();
* token.name("token").description("用户令牌").modelRef(new ModelRef("string")).parameterType("header").required(false)
* .build();
* pars.add(token.build());
* return new Docket(DocumentationType.SWAGGER_2).select().paths(regex("/admin/.*")).build()
* .globalOperationParameters(pars).apiInfo(pdaApiInfo()).useDefaultResponseMessages(false)
* .enable(enableSwagger)
* .groupName("adminApi");
*
* }
*
*
* @return
*/
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
.apis(RequestHandlerSelectors.basePackage("com.lsqingfeng.action.swagger.controller")).paths(PathSelectors.any())
.build().globalOperationParameters(setHeaderToken());
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder().title("action-swagger").description("swagger实战").termsOfServiceUrl("")
.version("1.0").build();
}
/**
* @Description: 设置swagger文档中全局参数
* @param
* @Date: 2020/9/11 10:15
* @return: java.util.List<springfox.documentation.service.Parameter>
*/
private List<Parameter> setHeaderToken() {
List<Parameter> pars = new ArrayList<>();
ParameterBuilder userId = new ParameterBuilder();
userId.name("token").description("用户TOKEN").modelRef(new ModelRef("string")).parameterType("header")
.required(true).build();
pars.add(userId.build());
return pars;
}
}Ce qui précède est un exemple de configuration, et une méthode setToken est également définie, ce qui signifie que toutes les interfaces qui génèrent des documents doivent contenir un paramètre de jeton de type d'en-tête.
La description directe de notre document d'interface se situe principalement au niveau du Contrôleur, comme la fonction de cette interface, le nom des paramètres, le nom de la valeur de retour, etc. Pour ces valeurs, nous devons ajouter les annotations correspondantes aux méthodes, aux paramètres de requête et aux paramètres de retour sur le contrôleur, afin que swagger puisse nous aider à générer les documents d'interface correspondants. Il s'agit de l'intrusion dans le code existant que j'ai mentionné plus tôt.
Écrivons un cas.
Créez d'abord un package vo, écrivez-y notre requête et les paramètres correspondants, et utilisez JavaBean pour définir la structure de données de la requête et de la réponse. Notez que les annotations correspondantes doivent être ajoutées ici :
Classe Request :
package com.lsqingfeng.springboot.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* @className: SwaggerReqVO
* @description:
* @author: sh.Liu
* @date: 2022-03-22 19:19
*/
@Data
@ApiModel("创建Swagger请求参数")
public class SwaggerReqVO {
@ApiModelProperty("id")
private Integer id;
@ApiModelProperty("姓名")
private String name;
@ApiModelProperty("性别")
private Integer gender;
}Classe Response :
package com.lsqingfeng.springboot.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* @className: SwaggerResVO
* @description:
* @author: sh.Liu
* @date: 2022-03-22 19:20
*/
@Data
@ApiModel("创建Swagger响应结果")
public class SwaggerResVO {
@ApiModelProperty("id")
private Integer id;
@ApiModelProperty("姓名")
private String name;
@ApiModelProperty("性别")
private Integer gender;
@ApiModelProperty("啥啥")
private String what;
}L'annotation @ApiModel et @@ApiModelProperty sont utilisées ici respectivement pour définir le nom de l'entité et le nom de l'entité. champ, qui est pratique à afficher lors de la génération du document d'interface.
Regardons à nouveau le contrôleur :
package com.lsqingfeng.springboot.controller;
import com.lsqingfeng.springboot.vo.SwaggerReqVO;
import com.lsqingfeng.springboot.vo.SwaggerResVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;
/**
* @className: SwaggerController
* @description: swagger 接口测试
* @author: sh.Liu
* @date: 2022-03-22 19:18
*/
@RestController
@RequestMapping("/swagger")
@Api(value = "用户接口", tags = {"用户接口"})
public class SwaggerController {
@ApiOperation("新增用户")
@PostMapping("save")
public String save(@RequestBody SwaggerReqVO req) {
return "success";
}
@GetMapping("getById")
@ApiOperation("根据条件查询用户")
public SwaggerResVO getById(@RequestBody SwaggerResVO req) {
return new SwaggerResVO();
}
}Les annotations @Api et @ApiOperation sont utilisées pour marquer respectivement le nom du groupe d'interface et le nom de l'interface. Maintenant, nous démarrons le projet.
J'ai trouvé cette erreur signalée.
La raison de la recherche en ligne est que la version SpringBoot2.6 est incompatible avec Swagger2.9.2. Certaines personnes disent également que cela est dû au fait que la version du package guava est trop basse.
Je les ai tous essayés séparément, et le problème du remplacement de la dépendance à la version supérieure de goyave existe toujours.
La raison principale de ce problème est en effet que la version SpringBoot est trop élevée. Si vous utilisez SpringBoot2.5.x et des versions antérieures, il n'y a aucun problème.
Spring Boot 2.6.X utilise PathPatternMatcher pour faire correspondre les chemins. La correspondance de chemin utilisée par Springfox référencée par Swagger est basée sur AntPathMatcher.
Donc, si vous souhaitez le résoudre, ajoutez une configuration et modifiez le mode de correspondance routière de springBoot MVC.
Ajouter la configuration dans le fichier de configuration springBoot :
spring.mvc.pathmatch.matching-strategy=ANT_PATH_MATCHER
S'il s'agit d'un fichier de configuration au format yml :
Recommencez pour résoudre le problème.
Adresse d'accès : ip:numéro de port/swagger-ui.html
正常情况就可以看到我们的界面了。一会再说非正常情况。由于我们只给用户接口添加了注解，所有用户接口是可以直接观察中文文档的。而剩下的两个接口，由于没添加注解，所以都是以默认的形式展示的。
点开接口，我们可以看到接口中的想详细信息
点击model,可以看到字段的中文描述。点击 Try it out,就可以直接调试接口。同时注意接口中都让填一个token,这就是我们之前的设置成效了。
截止到目前其实swagger的集成就已经完毕了，主要就是根据我们的注解生成文档，并且可以在线调用调试。开发的时候，我们只需要把Controller这一层的请求和响应，以及方法描述等内容先开发完毕，就可以提供给前端让他们参照开发了。
正常情况我们按照上面的步骤就可以出现页面，但是有些时候可能是由于springBoot的版本过高导致的，我们输入之前的地址，出现404的情况，这个主要是由于项目中无法读取到swagger依赖包下的页面导致的。如果出现了这个问题，我们可以添加一个配置类，让他实现WebMvcConfigurer 接口，在添加一个方法：
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
registry.addResourceHandler("swagger-ui.html")
.addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**")
.addResourceLocations("classpath:/META-INF/resources/webjars/");
}完整代码如下：
package com.lsqingfeng.springboot.config;
import com.lsqingfeng.springboot.interceptor.TokenInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* @className: WebMvcConfig
* @description:webMvc配置
* @author: sh.Liu
* @date: 2022-01-13 09:51
*/
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
registry.addResourceHandler("swagger-ui.html")
.addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**")
.addResourceLocations("classpath:/META-INF/resources/webjars/");
}
}这个时候在启动就可以了！
上面的整个过程已经完成了，但是生成的接口文档的页面，其实很多人不太喜欢，觉得不太符合国人的使用习惯，所有又有一些大神，提供了其他的UI测试页面。这个页面的使用还是比较广泛的。
修改方式：只需引入一个依赖包：
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>swagger-bootstrap-ui</artifactId>
<version>1.9.6</version>
</dependency>然后把刚才实现的那个的那个方法再添加一条：
registry.addResourceHandler("doc.html")
.addResourceLocations("classpath:/META-INF/resources/");完成代码：
package com.lsqingfeng.springboot.config;
import com.lsqingfeng.springboot.interceptor.TokenInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* @className: WebMvcConfig
* @description:webMvc配置
* @author: sh.Liu
* @date: 2022-01-13 09:51
*/
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
// @Override
// public void addInterceptors(InterceptorRegistry registry) {
// //拦截
// registry.addInterceptor(new TokenInterceptor())
// .addPathPatterns("/**")
// .excludePathPatterns("/login");
// }
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
registry.addResourceHandler("swagger-ui.html")
.addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**")
.addResourceLocations("classpath:/META-INF/resources/webjars/");
registry.addResourceHandler("doc.html")
.addResourceLocations("classpath:/META-INF/resources/");
}
}重新启动项目： 访问路径发生了变化：** ip:端口号/doc.html**
页面出现了。我们在看看我们的用户接口：
这个风格确实更加的直观，同时也是可以直接进行调试的。大部分的swagger都用的这个风格的文档。
上面已经很详细的讲解了swagger2的集成方式，而swagger3的集成方式更加的简洁一些。
首先引入依赖：
<dependency> <groupId>io.springfox</groupId> <artifactId>springfox-boot-starter</artifactId> <version>3.0.0</version> </dependency>
然后是替换注解： swagger2使用的开启注解是： @EnableSwagger2
而在swagger3中，这个注解要换成： @EnableOpenApi
配置类：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.oas.annotations.EnableOpenApi;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
@Configuration
public class SwaggerConfig {
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.OAS_30) // v2 不同
.select()
.apis(RequestHandlerSelectors.basePackage("com.example.swaggerv3.controller")) // 设置扫描路径
.build();
}
}要注意，里边的版本类型换成了 OAS_30, 就是swagger3的意思。
OAS 是 OpenAPI Specification 的简称，翻译成中文就是 OpenAPI 说明书。
同时访问地址：原始地址，也就是没换UI的地址： localhost:8080/swagger-ui/index.html这个要和swagger2区分开。
swagger3的原始UI风格也发生了一些变化：
同时swagger3也是可以更换UI的。方法和swagger2一样。
如果我们的项目中有关于跨域的处理，同时还有拦截器，然后还要使用swagger，这种情况大家要注意了，有可能我们的拦截器会将swagger中的页面路径拦截掉导致swagger页面出不来，当我们在拦截器中把swagger的页面排除掉的时候，也有可能会导致跨域配置的失效。
具体解决方案简单提一下：
拦截器：
/**
* 拦截器配置
*
* @author liuShuai
*/
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Bean
public TokenInterceptor tokenInterceptor() {
return new TokenInterceptor();
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry
.addInterceptor(tokenInterceptor())
.addPathPatterns("/**")
.excludePathPatterns("/user/login")
.excludePathPatterns("/user/downloadExcel")
.excludePathPatterns("/swagger-resources/**", "/webjars/**", "/v2/**", "/swagger-ui.html/**");
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("swagger-ui.html")
.addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**")
.addResourceLocations("classpath:/META-INF/resources/webjars/");
}
}跨域配置：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
/**
* @className: CorsConfig
* @description:
* @author: sh.Liu
* @date: 2020-12-02 10:16
*/
@Configuration
public class CorsConfig {
@Bean
public CorsFilter corsFilter() {
CorsConfiguration config = new CorsConfiguration();
config.addAllowedOrigin("*");
config.setAllowCredentials(true);
config.addAllowedMethod("*");
config.addAllowedHeader("*");
UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
configSource.registerCorsConfiguration("/**", config);
return new CorsFilter(configSource);
}
}用这两种方式去配置，就可以让他们和平共处了。
另： 配套项目代码已托管中gitCode: gitcode.net/lsqingfeng/…
分支： feautre/MybatisPlus
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Étapes de création du projet SpringBoot
Comment utiliser Swagger
Quelle est la différence entre j2ee et springboot
La différence entre indexof et include
Site officiel d'Okex
La différence entre le système Hongmeng et le système Android
Quelles sont les méthodes d'arrondi en SQL
Le rôle de la carte réseau du serveur
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
