springfox.documentation.RequestHandler Java Examples

private Docket baseDocket() {
    // 请求类型过滤规则
    Predicate<RequestHandler> controllerPredicate = getControllerPredicate();
    // controller 包路径
    Predicate<RequestHandler> controllerPackage = RequestHandlerSelectors.basePackage(packAge);
    return new Docket(DocumentationType.SWAGGER_2)
            .groupName(groupName)
            .forCodeGeneration(true)
            .select()
            .apis(controllerPackage)
            .apis(controllerPredicate)
            .paths(PathSelectors.any())
            .build()
            .apiInfo(this.serviceApiInfo())
            .securitySchemes(securitySchemes())
            .securityContexts(securityContexts());
}
 

private Predicate<RequestHandler> getControllerPredicate() {
    groupName = groupList.get(groupIndex);
    List<String> apiTags = groupMap.get(groupName);
    Predicate<RequestHandler> methodPredicate = (input) -> {
        Api api = null;
        Optional<Api> apiOptional = input.findControllerAnnotation(Api.class);
        if (apiOptional.isPresent()) {
            api = apiOptional.get();
        }
        List<String> tags = Arrays.asList(api.tags());
        if (api != null && apiTags.containsAll(tags)) {
            return true;
        }
        return false;
    };
    groupIndex++;
    return Predicates.and(RequestHandlerSelectors.withClassAnnotation(RestController.class), methodPredicate);
}
 

final protected void registerDocketsByWebApiAnnotation(int index, String appName, Class<?> rootClass) {
		Collection<Predicate<RequestHandler>> predicates = createPackagePredicateByClass(rootClass);
		
		logger.info("register docket for rootClass: {}", rootClass);
//		Docket docket = createDocket(index+".1 ["+appName+"]外部接口", appName, Arrays.asList(webApi(predicates)));
		String docketBeanName = appName+"Docket";
		logger.info("docket[{}] created...", docketBeanName);
		this.registerDocketIfNotExist(docketBeanName, index+".1 ["+appName+"]外部接口", appName, Arrays.asList(webApi(predicates)));
		/*if (!applicationContext.containsBeanDefinition(docketBeanName)) {
			SpringUtils.registerAndInitSingleton(applicationContext, docketBeanName, docket);
			logger.info("docket[{}] registered", docketBeanName);
		} else {
			logger.info("docket[{}] ignored", docketBeanName);
		}*/
		
		docketBeanName = appName+"InnerDocket";
		logger.info("docket[{}] created...", docketBeanName);
		this.registerDocketIfNotExist(docketBeanName, index+".2 ["+appName+"]内部接口", appName, Arrays.asList(notWebApi(predicates)));
		/*Docket innerDocket = createDocket(index+".2 ["+appName+"]内部接口", appName, Arrays.asList(notWebApi(predicates)));
		if (!applicationContext.containsBeanDefinition(docketBeanName)) {
			SpringUtils.registerAndInitSingleton(applicationContext, docketBeanName, innerDocket);
			logger.info("docket[{}] registered", docketBeanName);
		} else {
			logger.info("docket[{}] ignored", docketBeanName);
		}*/
	}
 

protected Docket createDocket(String groupName, String applicationName, Collection<Predicate<RequestHandler>> packages){
	Docket docket = new Docket(DocumentationType.SWAGGER_2)
				.ignoredParameterTypes(ApiIgnore.class)
				.groupName(groupName)
				.alternateTypeRules(
						AlternateTypeRules.newRule(
								typeResolver.resolve(DeferredResult.class, typeResolver.resolve(ResponseEntity.class, WildcardType.class)),
								typeResolver.resolve(WildcardType.class)
                              )
				)
		//		.pathProvider(pathProvider)
		        .select()
		            .apis(Predicates.or(packages))
		            .paths(PathSelectors.any())
		        .build()
		        .globalOperationParameters(createGlobalParameters())
		        .apiInfo(apiInfo(applicationName));
	
	addGlobalResponseMessages(docket);
	return docket;
}
 

@BeforeEach
public void setup() throws Exception {
    MockitoAnnotations.initMocks(this);
    Method method = this.getClass().getMethod("test", new Class<?>[]{Pageable.class, Integer.class});
    resolver = new TypeResolver();
    RequestHandler handler = new WebMvcRequestHandler(new HandlerMethodResolver(resolver), null, new
        HandlerMethod(this, method));
    DocumentationContext docContext = mock(DocumentationContext.class);
    RequestMappingContext reqContext = new RequestMappingContext(docContext, handler);
    builder = spy(new OperationBuilder(null));
    context = new OperationContext(builder, RequestMethod.GET, reqContext, 0);
    List<TypeNameProviderPlugin> plugins = new LinkedList<>();
    extractor = new TypeNameExtractor(resolver, SimplePluginRegistry.create(plugins), new
        JacksonEnumTypeDeterminer());
    plugin = new PageableParameterBuilderPlugin(extractor, resolver);
}
 

@SuppressWarnings("unused")
private static final Predicate<RequestHandler> basePackages(final Class<?>... classes)
{
	final Set<Predicate<RequestHandler>> predicates = new HashSet<>(classes.length);
	for (final Class<?> clazz : classes)
	{
		final String packageName = clazz.getPackage().getName();
		predicates.add(RequestHandlerSelectors.basePackage(packageName));
	}

	if(predicates.size() == 1)
	{
		return predicates.iterator().next();
	}

	return Predicates.or(predicates);
}
 

protected Docket createDocket(Set<Predicate<RequestHandler>> packages){
	Docket docket = new Docket(DocumentationType.SWAGGER_2)
				.ignoredParameterTypes(ApiIgnore.class)
		//		.pathProvider(pathProvider)
		        .select()
		            .apis(Predicates.or(packages))
		            .paths(PathSelectors.any())
		        .build()
		        .apiInfo(apiInfo(getServiceName()));
	return docket;
}
 

@Bean
public Docket createRestApi() {
	Predicate<RequestHandler> predicate = new Predicate<RequestHandler>() {
		@Override
		public boolean apply(RequestHandler input) {
			if (input.isAnnotatedWith(ApiOperation.class))// 只有添加了ApiOperation注解的method才在API中显示
				return true;
			return false;
		}
	};
	return new Docket(DocumentationType.SWAGGER_2).//
			apiInfo(apiInfo()).select().//
			apis(predicate).//
			paths(PathSelectors.any()).build();
}
 

protected Set<Predicate<RequestHandler>> getAllApiDocPackages(){
	Set<Predicate<RequestHandler>> packages = Sets.newHashSet();
   	packages.addAll(getPluginBasePackages());
   	String scanPackageName = getScanPackageName();//ClassUtils.getPackageName(ServiceApplication.class);
   	if(StringUtils.isNotBlank(scanPackageName)){
   		packages.add(RequestHandlerSelectors.basePackage(scanPackageName));
   	}
   	return packages;
}
 

protected Set<Predicate<RequestHandler>> getPluginBasePackages(){
   	if(pluginManager!=null){
    	return pluginManager.getPlugins()
    				.stream()
    				.map(p->RequestHandlerSelectors.basePackage(ClassUtils.getPackageName(p.getRootClass())))
    				.collect(Collectors.toSet());
   	}
   	return Collections.emptySet();
}
 

protected void registerDocketIfNotExist(String docketBeanName, String groupName, String appName, Collection<Predicate<RequestHandler>> packages) {
	Docket innerDocket = createDocket(groupName, appName, packages);
	if (!applicationContext.containsBeanDefinition(docketBeanName)) {
		SpringUtils.registerAndInitSingleton(applicationContext, docketBeanName, innerDocket);
		logger.info("docket[{}] registered", docketBeanName);
	} else {
		logger.info("docket[{}] ignored", docketBeanName);
	}
}
 

final protected Collection<Predicate<RequestHandler>> createPackagePredicate(String... packNames) {
	return Stream.of(packNames)
				.map(packName -> {
					return RequestHandlerSelectors.basePackage(packName);
				})
				.collect(Collectors.toSet());
}
 

final protected Collection<Predicate<RequestHandler>> createPackagePredicateByClass(Class<?>... rootClass) {
	return Stream.of(rootClass)
				.map(c -> {
					return RequestHandlerSelectors.basePackage(ClassUtils.getPackageName(c));
				})
				.collect(Collectors.toSet());
}
 

@SuppressWarnings("deprecation")
protected Predicate<RequestHandler> notWebApi(Collection<Predicate<RequestHandler>> packages){
   	return rh->{
       	return Predicates.or(packages).apply(rh) && 
									!WebApiRequestMappingCombiner.findWebApiAttrs(rh.getHandlerMethod().getMethod(), 
																rh.declaringClass())
																.isPresent();
       };
}
 

@SuppressWarnings("deprecation")
protected Predicate<RequestHandler> webApi(Collection<Predicate<RequestHandler>> packages){
   	return rh->{
       	return Predicates.or(packages).apply(rh) && 
       								WebApiRequestMappingCombiner.findWebApiAttrs(rh.getHandlerMethod().getMethod(), 
       															rh.declaringClass())
       															.isPresent();
       };
}
 

@Bean
public Docket createRestApi() {
    Predicate<RequestHandler> predicate = new Predicate<RequestHandler>() {
        @Override
        public boolean apply(RequestHandler input) {
            Class<?> declaringClass = input.declaringClass();

            boolean isController = declaringClass.isAnnotationPresent(Controller.class);
            boolean isRestController = declaringClass.isAnnotationPresent(RestController.class);

            String className = declaringClass.getName();

            String pattern = "com\\.codingapi\\.file\\.local\\.server\\.controller\\..*Controller";
            boolean has =  Pattern.matches(pattern, className);
            if(has){
                if(isController){
                    if(input.isAnnotatedWith(ResponseBody.class)){
                        return true;
                    }
                }
                if(isRestController){
                    return true;
                }
                return false;
            }

            return false;
        }
    };
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo())
            .useDefaultResponseMessages(false)
            .select()
            .apis(predicate)
            .build();
}
 

@Bean
public Docket createRestApi() {
    Predicate<RequestHandler> predicate = new Predicate<RequestHandler>() {
        @Override
        public boolean apply(RequestHandler input) {
            Class<?> declaringClass = input.declaringClass();

            boolean isController = declaringClass.isAnnotationPresent(Controller.class);
            boolean isRestController = declaringClass.isAnnotationPresent(RestController.class);

            String className = declaringClass.getName();

            String pattern = "com\\.codingapi\\.file\\.fastdfs\\.server\\.controller\\..*Controller";
            boolean has =  Pattern.matches(pattern, className);
            if(has){
                if(isController){
                    if(input.isAnnotatedWith(ResponseBody.class)){
                        return true;
                    }
                }
                if(isRestController){
                    return true;
                }
                return false;
            }

            return false;
        }
    };
    return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo())
            .useDefaultResponseMessages(false)
            .select()
            .apis(predicate)
            .build();
}
 

private Function<RequestHandlerProvider, ? extends Iterable<RequestHandler>> handlers() {
    return new Function<RequestHandlerProvider, Iterable<RequestHandler>>() {
        @Override
        public Iterable<RequestHandler> apply(RequestHandlerProvider input) {
            return input.requestHandlers();
        }
    };
}
 

@Override
public List<RequestHandler> requestHandlers() {
    return byPatternsCondition().sortedCopy(nullToEmptyList(serviceBeans).stream()
            .filter(bean -> AnnotatedElementUtils.hasAnnotation(bean.getInterfaceClass(), Api.class))
            .reduce(newArrayList(), toMappingEntries(), (o1, o2) -> o1)
            .stream().map(toRequestHandler()).collect(Collectors.toList()));
}
 

private static Optional<? extends Class<?>> declaringClass(RequestHandler input) {
	return Optional.fromNullable(input.declaringClass());
}
 

@Bean
public Docket api(){
	Set<Predicate<RequestHandler>> packages = getAllApiDocPackages();
	Docket docket = createDocket(packages);
	return docket;
}
 

protected Predicate<RequestHandler> notWebApi(){
	Set<Predicate<RequestHandler>> packages = getAllApiDocPackages();
   	return notWebApi(packages);
}
 

protected Predicate<RequestHandler> webApi(){
	Set<Predicate<RequestHandler>> packages = getAllApiDocPackages();
   	return webApi(packages);
}
 

private static Optional<? extends Class<?>> declaringClass(RequestHandler input) {
    return Optional.fromNullable(input.declaringClass());
}
 

private Function<HandlerMethod, RequestHandler> toRequestHandler() {
    return handlerMethod -> new ApiRequestHandler(methodResolver, handlerMethod,
            allAsRequestBody(handlerMethod)
                    ? annotateBody(handlerMethod)
                    : methodResolver.methodParameters(handlerMethod));
}
 

@Override
public RequestHandler combine(RequestHandler other) {
    return other;
}
 

public static Predicate<RequestHandler> dubboApi() {
    return input -> input instanceof ApiRequestHandler;
}
 

public static Predicate<RequestHandler> basePackage(final String[] basePackages) {
    return input -> declaringClass(input).transform(handlerPackage(basePackages)).or(true);
}
 

@SuppressWarnings("deprecation")
private static Optional<? extends Class<?>> declaringClass(RequestHandler input) {
    return Optional.fromNullable(input.declaringClass());
}
 

private void initGlobalRequestMappingArray(SwaggerExt swaggerExt) {
    if (this.globalHandlerMappings.size() == 0) {
        String parentPath = "";
        if (!StringUtils.isEmpty(swaggerExt.getBasePath()) && !"/".equals(swaggerExt.getBasePath())) {
            parentPath = parentPath + swaggerExt.getBasePath();
        }

        try {
            List<RequestHandler> requestHandlers = FluentIterable.from(this.handlerProviders).transformAndConcat(this.handlers()).toList();
            Iterator<RequestHandler> var4 = requestHandlers.iterator();

            while(true) {
                RequestHandler requestHandler;
                do {
                    if (!var4.hasNext()) {
                        return;
                    }

                    requestHandler = var4.next();
                } while(!(requestHandler instanceof WebMvcRequestHandler));

                WebMvcRequestHandler webMvcRequestHandler = (WebMvcRequestHandler)requestHandler;
                Set<String> patterns = webMvcRequestHandler.getRequestMapping().getPatternsCondition().getPatterns();
                Set<RequestMethod> restMethods = webMvcRequestHandler.getRequestMapping().getMethodsCondition().getMethods();
                HandlerMethod handlerMethod = webMvcRequestHandler.getHandlerMethod();
                Class<?> controllerClazz = ClassUtils.getUserClass(handlerMethod.getBeanType());
                Method method = ClassUtils.getMostSpecificMethod(handlerMethod.getMethod(), controllerClazz);

                String url;
                for(Iterator<String> var12 = patterns.iterator(); var12.hasNext(); this.globalHandlerMappings.add(new RestHandlerMapping(parentPath + url, controllerClazz, method, restMethods))) {
                    url = var12.next();
                    if (LOGGER.isDebugEnabled()) {
                        LOGGER.debug("url:" + url + "\r\nclass:" + controllerClazz.toString() + "\r\nmethod:" + method.toString());
                    }
                }
            }
        } catch (Exception var14) {
            LOGGER.error(var14.getMessage(), var14);
        }
    }

}