SpringBoot2.6.0/Springfox3-启动 bean‘ documentationPluginsBootstrapper’失败

This problem's caused by a bug in Springfox. It's making an assumption about how Spring MVC is set up that doesn't always hold true. Specifically, it's assuming that MVC's path matching will use the Ant-based path matcher and not the PathPattern-based matcher. PathPattern-based matching has been an option for some time now and is the default as of Spring Boot 2.6.

As described in Spring Boot 2.6's release notes, you can restore the configuration that Springfox assumes will be used by setting spring.mvc.pathmatch.matching-strategy to ant-path-matcher in your application.properties file. Note that this will only work if you are not using Spring Boot's Actuator. The Actuator always uses PathPattern-based parsing, irrespective of the configured matching-strategy. A change to Springfox will be required if you want to use it with the Actuator in Spring Boot 2.6 and later.

Not a solution but...

I downgraded spring-boot-starter-parent version from 2.6.0 to 2.5.6 and it started to work.

I will complete what Anatoly mentioned about using springdoc-openapi.

First add the springdoc-openapi dependency to your Gradle build.gradle (or Maven pom.xml):

// build.gradle
implementation "org.springdoc:springdoc-openapi-ui:1.6.4"

Add OpenAPIDefinition annotation to your main class:

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

Now you can go to {URI}/swagger-ui/index.html and it will work showing the swagger view.

The workaround mentioned in the below issue comment seems to be working for people with spring actuator as well. Just changing the path matcher won't work for projects using actuator.

1. Set in application.properties file:

   spring.mvc.pathmatch.matching-strategy to ant_path_matcher

2. Add the @Bean below:

@Bean
public WebMvcEndpointHandlerMapping webEndpointServletHandlerMapping(
WebEndpointsSupplier webEndpointsSupplier,
ServletEndpointsSupplier servletEndpointsSupplier,
ControllerEndpointsSupplier controllerEndpointsSupplier,
EndpointMediaTypes endpointMediaTypes,
CorsEndpointProperties corsProperties,
WebEndpointProperties webEndpointProperties,
Environment environment) {
List<ExposableEndpoint<?>> allEndpoints = new ArrayList();
Collection<ExposableWebEndpoint> webEndpoints = webEndpointsSupplier.getEndpoints();
allEndpoints.addAll(webEndpoints);
allEndpoints.addAll(servletEndpointsSupplier.getEndpoints());
allEndpoints.addAll(controllerEndpointsSupplier.getEndpoints());
String basePath = webEndpointProperties.getBasePath();
EndpointMapping endpointMapping = new EndpointMapping(basePath);
boolean shouldRegisterLinksMapping = this.shouldRegisterLinksMapping(
webEndpointProperties, environment, basePath);
return new WebMvcEndpointHandlerMapping(endpointMapping, webEndpoints,
endpointMediaTypes, corsProperties.toCorsConfiguration(),
new EndpointLinksResolver(allEndpoints, basePath),
shouldRegisterLinksMapping, null);
}


private boolean shouldRegisterLinksMapping(WebEndpointProperties webEndpointProperties,
Environment environment, String basePath) {
return webEndpointProperties.getDiscovery().isEnabled() &&
(StringUtils.hasText(basePath) ||
ManagementPortType.get(environment).equals(ManagementPortType.DIFFERENT));
}

Reference:

• https://github.com/springfox/springfox/issues/3462#issuecomment-1010721223

Remove anotations

@EnableSwagger2
@SpringBootApplication
@EnableSwagger2
public class Application {}

Only adding @EnableWebMvc in the main class should resolve the problem:

@EnableWebMvc
@SpringBootApplication
public class MyApp {
public static void main(String[] args) {
SpringApplication.run(MyApp.class);
}
}

The popular workaround overriding a definition of WebMvcEndpointHandlerMapping was not working for me in some environments with JDK 17, Boot+Actuator 2.6, Springfox 3.

This, however, is working for me everywhere I need it (local development and CloudFoundry containers):

@Bean
public WebMvcRequestHandlerProvider webMvcRequestHandlerProvider(
Optional<ServletContext> context,
HandlerMethodResolver methodResolver,
List<RequestMappingInfoHandlerMapping> handlerMappings) {
handlerMappings = handlerMappings.stream()
.filter(rh -> rh.getClass().getName().contains("RequestMapping")).toList();
return new WebMvcRequestHandlerProvider(context, methodResolver, handlerMappings);
}

I wrote a little more about it on the GitHub thread.

Just if someone is having difficulties with this setup, here is my config which is setup for actuator and spring boot 2.6.6:

In my application.yaml:

swagger:
title: ^project.name^
description: ^project.description^
version: ^project.version^
termsOfServiceUrl: \#
contactName: Your name
contactUrl: \#
contactEmail: email
license: License of API
licenseUrl: \#

Make sure that in your pom.xml within <properties> you place:

<properties>
<resource.delimiter>^</resource.delimiter>
</properties>

The above is important for following config:

import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.actuate.autoconfigure.endpoint.web.CorsEndpointProperties;
import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties;
import org.springframework.boot.actuate.autoconfigure.web.server.ManagementPortType;
import org.springframework.boot.actuate.endpoint.ExposableEndpoint;
import org.springframework.boot.actuate.endpoint.web.*;
import org.springframework.boot.actuate.endpoint.web.annotation.ControllerEndpointsSupplier;
import org.springframework.boot.actuate.endpoint.web.annotation.ServletEndpointsSupplier;
import org.springframework.boot.actuate.endpoint.web.servlet.WebMvcEndpointHandlerMapping;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.util.StringUtils;
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;


@Getter
@Setter
@Configuration
@EnableSwagger2
@ConfigurationProperties(prefix = "swagger")
public class SwaggerFoxConfig {


private String title;
private String description;
private String version;
private String termsOfServiceUrl;
private String license;
private String licenseUrl;
private String contactName;
private String contactUrl;
private String contactEmail;


@Bean
public Docket apiDocket() {
return new Docket(DocumentationType.SWAGGER_2)
.useDefaultResponseMessages(false)
.select()
.apis(RequestHandlerSelectors.basePackage("path.to.base.package"))
.paths(PathSelectors.any())
.build()
.apiInfo(apiInfo());
}


private ApiInfo apiInfo() {
System.out.println(this.title);
return new ApiInfo(
this.title,
this.description,
this.version,
this.termsOfServiceUrl,
new Contact(this.contactName, this.contactUrl, this.contactEmail),
this.license,
this.licenseUrl,
Collections.emptyList());
}


@Bean
public WebMvcEndpointHandlerMapping webEndpointServletHandlerMapping(WebEndpointsSupplier webEndpointsSupplier, ServletEndpointsSupplier servletEndpointsSupplier, ControllerEndpointsSupplier controllerEndpointsSupplier, EndpointMediaTypes endpointMediaTypes, CorsEndpointProperties corsProperties, WebEndpointProperties webEndpointProperties, Environment environment) {
List<ExposableEndpoint<?>> allEndpoints = new ArrayList<>();
Collection<ExposableWebEndpoint> webEndpoints = webEndpointsSupplier.getEndpoints();
allEndpoints.addAll(webEndpoints);
allEndpoints.addAll(servletEndpointsSupplier.getEndpoints());
allEndpoints.addAll(controllerEndpointsSupplier.getEndpoints());
String basePath = webEndpointProperties.getBasePath();
EndpointMapping endpointMapping = new EndpointMapping(basePath);
boolean shouldRegisterLinksMapping = this.shouldRegisterLinksMapping(webEndpointProperties, environment, basePath);
return new WebMvcEndpointHandlerMapping(endpointMapping, webEndpoints, endpointMediaTypes, corsProperties.toCorsConfiguration(), new EndpointLinksResolver(allEndpoints, basePath), shouldRegisterLinksMapping, null);
}




private boolean shouldRegisterLinksMapping(WebEndpointProperties webEndpointProperties, Environment environment, String basePath) {
return webEndpointProperties.getDiscovery().isEnabled() && (StringUtils.hasText(basePath) || ManagementPortType.get(environment).equals(ManagementPortType.DIFFERENT));
}
}

Also in your .yaml or .properties have this setup:

spring:
mvc:
pathmatch:
matching-strategy: ANT_PATH_MATCHER
jpa:
bla..
    

    

springfox:
documentation:
swagger-ui:
baseUrl: scheduler-service

Back to pom.xml, have your Spring Boot version and Actuator setup:

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.6.6</version> <!-- lookup parent from repository -->
<relativePath/>
</parent>


...


<properties>
<spring.fox.version>3.0.4</spring.fox.version>
</properties>
   

<dependencies>
<dependency>
<groupId>org.thingsboard</groupId>
<artifactId>springfox-boot-starter</artifactId>
<version>${spring.fox.version}</version>
</dependency>
</dependencies>

You can find Swagger UI at:

http://localhost:8080/your-service-name-from-tag-'name'-in-pom-xml/swagger-ui/index.html

I already had a working system on Spring Boot 1.5.5.RELEASE and things stopped working when I upgraded to Spring Boot version 2.7.2 and 3.0.0 of SpringFox. Followed all steps of Migration Steps but that doesn't solved issue.

Had to do two additional things,

1. In swagger config class - new Docket(DocumentationType.OAS_30) instead of new Docket(DocumentationType.SWAGGER_2)

2. @EnableOpenApi on swagger config class

Swagger is finally coming at a new url than previous versions ( /swagger-ui.html )

/swagger-ui/index.html

Other than the mentioned answer took help from

Also, its a REST API project for me so I don't use EnableWebMvc

Just add this to your application.properties file:spring.mvc.pathmatch.matching-strategy=ANT_PATH_MATCHER.

Path matching policy switch back to ant_path_matcher Add the below line to the application.properties file

spring.mvc.pathmatch.matching-strategy=ant_path_matcher

Add the following definition of the bean

public class SpringBootApplication {


public static void main(String[] args) {
SpringApplication.run(SpringBootApplication.class, args);
}
@Bean
public WebMvcEndpointHandlerMapping webEndpointServletHandlerMapping(WebEndpointsSupplier webEndpointsSupplier,
ServletEndpointsSupplier servletEndpointsSupplier, ControllerEndpointsSupplier controllerEndpointsSupplier,
EndpointMediaTypes endpointMediaTypes, CorsEndpointProperties corsProperties,
WebEndpointProperties webEndpointProperties, Environment environment) {
List<ExposableEndpoint<?>> allEndpoints = new ArrayList();
Collection<ExposableWebEndpoint> webEndpoints = webEndpointsSupplier.getEndpoints();
allEndpoints.addAll(webEndpoints);
allEndpoints.addAll(servletEndpointsSupplier.getEndpoints());
allEndpoints.addAll(controllerEndpointsSupplier.getEndpoints());
String basePath = webEndpointProperties.getBasePath();
EndpointMapping endpointMapping = new EndpointMapping(basePath);
boolean shouldRegisterLinksMapping = this.shouldRegisterLinksMapping(webEndpointProperties, environment,
basePath);
return new WebMvcEndpointHandlerMapping(endpointMapping, webEndpoints, endpointMediaTypes,
corsProperties.toCorsConfiguration(), new EndpointLinksResolver(allEndpoints, basePath),
shouldRegisterLinksMapping, null);
}


private boolean shouldRegisterLinksMapping(WebEndpointProperties webEndpointProperties, Environment environment,
String basePath) {
return webEndpointProperties.getDiscovery().isEnabled() && (StringUtils.hasText(basePath)
|| ManagementPortType.get(environment).equals(ManagementPortType.DIFFERENT));
}
}

I used the first method and solved the problem after adding just one configuration. If you’ve encountered this problem recently, I hope this article helps you.

I have similar issue where I am getting the error like this:

springfox.documentation.spring.web.plugins.DocumentationPluginsBootstrapper: Unable to scan documentation context default

With NullPointerException

This issue I solved by modifying couple of changes.

1. Instead of this

.apis(RequestHandlerSelectors.basePackage(basePackage))

 I used this-

.apis(RequestHandlerSelectors.any())

2. Another change I made is: Add url pattern to get the specific urls only(This is subjective by the way)

.paths(PathSelectors.ant("/external/**"))

The tech stack is:

• Spring-Boot:2.5.0
• Swagger:3.0.0

These steps worked for me with SpringBoot version > 2.6
One thing to note it that dependency io.springfox:springfox-boot-starter:3.0.0 doesnt works well with SpringBoot v > 2.6
See this for more info: https://stackoverflow.com/a/64333853
If your springboot version is less than 2.6 follow this answer :
https://stackoverflow.com/a/74433644/16769477

Step 1: Added following dependencies in build.gradle for springfox.

implementation "io.springfox:springfox-swagger-ui:2.9.2"
implementation "io.springfox:springfox-swagger2:2.9.2"
implementation "io.springfox:springfox-schema:2.9.2"

Step 2: Added this property in application.properties

spring.mvc.pathmatch.matching-strategy = "ANT_PATH_MATCHER"

Step 3: Created a config file as

@EnableSwagger2
@Configuration
public class SpringFoxSwaggerConfig {


@Bean
public Docket apiDocket() {
return new Docket(DocumentationType.SWAGGER_2)
.select()
.apis(RequestHandlerSelectors.any())
.paths(PathSelectors.any())
.build()
.apiInfo(metadata());
}


private ApiInfo metadata() {
return new ApiInfoBuilder()
.title("")
.description("")
.version("")
.version("2.0")
.contact(new Contact(null, null, "this.developer"))
.build();
}
}

clean and build the project
Swagger endpoint should be accessible at these endpoints

http://host-name/servlet-context/v2/api-docs
http://host-name/servlet-context/swagger-ui/index.html

Just create or modify configuration file with adding @EnableWebMvc annotation, sth like this:

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurationSupport {}