Initial support of Webflux with Functional Endpoints

Author: bnasslahsen

springdoc-openapi-common/src/main/java/org/springdoc/core/MethodAttributes.java

@@ -132,6 +132,8 @@ else if (reqMappingMethod != null) {
 		else if (reqMappingClass != null) {
 			fillMethods(reqMappingClass.produces(), reqMappingClass.consumes(), reqMappingClass.headers());
 		}
+		else
+			fillMethods(null, null, null);
 	}
 
 	private void fillMethods(String[] produces, String[] consumes, String[] headers) {

springdoc-openapi-webflux-core/src/main/java/org/springdoc/webflux/annotations/RouterOperation.java

@@ -0,0 +1,84 @@
+/*
+ *
+ *  * Copyright 2019-2020 the original author or authors.
+ *  *
+ *  * Licensed under the Apache License, Version 2.0 (the "License");
+ *  * you may not use this file except in compliance with the License.
+ *  * You may obtain a copy of the License at
+ *  *
+ *  *      https://www.apache.org/licenses/LICENSE-2.0
+ *  *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  * distributed under the License is distributed on an "AS IS" BASIS,
+ *  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  * See the License for the specific language governing permissions and
+ *  * limitations under the License.
+ *
+ */
+
+package org.springdoc.webflux.annotations;
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+
+/**
+ * The annotation may be used to define an operation method as an OpenAPI Operation, and/or to define additional
+ * properties for the Operation.
+ * <p>The following fields can also alternatively be defined at method level (as repeatable annotations in case of arrays),
+ *
+ **/
+@Target({ ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface RouterOperation {
+
+
+	/**
+	 * Alias for {@link RequestMapping#path}.
+	 */
+	String path();
+
+	/**
+	 * Alias for {@link RequestMapping#method}.
+	 */
+	RequestMethod[] method();
+
+	/**
+	 * Alias for {@link RequestMapping#consumes}.
+	 */
+	String[] consumes() default {};
+
+	/**
+	 * Alias for {@link RequestMapping#produces}.
+	 */
+	String[] produces() default {};
+
+	/**
+	 * The class of the Handler bean.
+	 *
+	 * @return the class of the Bean
+	 **/
+	Class<?> beanClass() default Void.class;;
+
+	/**
+	 * The method of the handler Bean.
+	 *
+	 * @return The method of the handler Bean.
+	 **/
+	String beanMethod() default "";
+
+	/**
+	 * The parameters of the handler method.
+	 *
+	 * @return The parameters of the handler method.
+	 **/
+	Class<?>[] parameterTypes() default {};
+
+}

springdoc-openapi-webflux-core/src/main/java/org/springdoc/webflux/annotations/RouterOperations.java

@@ -0,0 +1,44 @@
+/*
+ *
+ *  * Copyright 2019-2020 the original author or authors.
+ *  *
+ *  * Licensed under the Apache License, Version 2.0 (the "License");
+ *  * you may not use this file except in compliance with the License.
+ *  * You may obtain a copy of the License at
+ *  *
+ *  *      https://www.apache.org/licenses/LICENSE-2.0
+ *  *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  * distributed under the License is distributed on an "AS IS" BASIS,
+ *  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  * See the License for the specific language governing permissions and
+ *  * limitations under the License.
+ *
+ */
+
+package org.springdoc.webflux.annotations;
+
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
+import static java.lang.annotation.ElementType.METHOD;
+
+/**
+ * Container for repeatable {@link RouterOperation} annotation
+ *
+ * @see RouterOperation
+ */
+@Target({METHOD, ANNOTATION_TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface RouterOperations {
+	/**
+	 * An array of RouterOperation Objects for the Router
+	 *
+	 * @return the RouterOperation
+	 */
+	RouterOperation[] value() default {};
+}

springdoc-openapi-webflux-core/src/main/java/org/springdoc/webflux/api/OpenApiResource.java

@@ -18,6 +18,11 @@
 
 package org.springdoc.webflux.api;
 
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -30,6 +35,10 @@
 import io.swagger.v3.core.util.Yaml;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.models.OpenAPI;
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springdoc.api.AbstractOpenApiResource;
 import org.springdoc.core.AbstractRequestBuilder;
 import org.springdoc.core.GenericResponseBuilder;
@@ -38,16 +47,25 @@
 import org.springdoc.core.SpringDocConfigProperties;
 import org.springdoc.core.customizers.OpenApiCustomiser;
 import org.springdoc.core.customizers.OperationCustomizer;
+import org.springdoc.webflux.annotations.RouterOperation;
+import org.springdoc.webflux.annotations.RouterOperations;
 import reactor.core.publisher.Mono;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.context.ApplicationContext;
+import org.springframework.core.type.StandardMethodMetadata;
 import org.springframework.http.MediaType;
 import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.util.CollectionUtils;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.method.HandlerMethod;
+import org.springframework.web.reactive.HandlerMapping;
+import org.springframework.web.reactive.function.server.RouterFunction;
 import org.springframework.web.reactive.result.condition.PatternsRequestCondition;
 import org.springframework.web.reactive.result.method.RequestMappingInfo;
 import org.springframework.web.reactive.result.method.RequestMappingInfoHandlerMapping;
@@ -62,8 +80,13 @@
 @RestController
 public class OpenApiResource extends AbstractOpenApiResource {
 
+	private static final Logger LOGGER = LoggerFactory.getLogger(OpenApiResource.class);
+
 	private final RequestMappingInfoHandlerMapping requestMappingHandlerMapping;
 
+	@Autowired
+	private List<HandlerMapping> handlerMappings;
+
 	public OpenApiResource(String groupName, OpenAPIBuilder openAPIBuilder, AbstractRequestBuilder requestBuilder,
 			GenericResponseBuilder responseBuilder, OperationBuilder operationParser,
 			RequestMappingInfoHandlerMapping requestMappingHandlerMapping,
@@ -79,7 +102,7 @@ public OpenApiResource(OpenAPIBuilder openAPIBuilder, AbstractRequestBuilder req
 			RequestMappingInfoHandlerMapping requestMappingHandlerMapping,
 			Optional<List<OperationCustomizer>> operationCustomizers,
 			Optional<List<OpenApiCustomiser>> openApiCustomisers, SpringDocConfigProperties springDocConfigProperties) {
-		super(DEFAULT_GROUP_NAME, openAPIBuilder, requestBuilder, responseBuilder, operationParser,operationCustomizers, openApiCustomisers, springDocConfigProperties);
+		super(DEFAULT_GROUP_NAME, openAPIBuilder, requestBuilder, responseBuilder, operationParser, operationCustomizers, openApiCustomisers, springDocConfigProperties);
 		this.requestMappingHandlerMapping = requestMappingHandlerMapping;
 	}
 
@@ -123,6 +146,51 @@ protected void getPaths(Map<String, Object> restControllers) {
 				}
 			}
 		}
+
+		ApplicationContext applicationContext = (ApplicationContext) requestMappingHandlerMapping.getApplicationContext();
+		Map<String, RouterFunction> routerBeans = applicationContext.getBeansOfType(RouterFunction.class);
+
+		for (Map.Entry<String, RouterFunction> entry : routerBeans.entrySet()) {
+			List<RouterOperation> routerOperationList = new ArrayList<>();
+			RouterOperations routerOperations = applicationContext.findAnnotationOnBean(entry.getKey(), RouterOperations.class);
+			if (routerOperations == null) {
+				RouterOperation routerOperation = applicationContext.findAnnotationOnBean(entry.getKey(), RouterOperation.class);
+				routerOperationList.add(routerOperation);
+			}
+			else
+				routerOperationList.addAll(Arrays.asList(routerOperations.value()));
+
+			if (!CollectionUtils.isEmpty(routerOperationList)) {
+				for (RouterOperation routerOperation : routerOperationList) {
+					if (!Void.class.equals(routerOperation.beanClass())) {
+						Object handlerBean = applicationContext.getBean(routerOperation.beanClass());
+						HandlerMethod handlerMethod = null;
+						if (StringUtils.isNotBlank(routerOperation.beanMethod())) {
+							try {
+								if (ArrayUtils.isEmpty(routerOperation.parameterTypes())) {
+									Optional<Method> methodOptional = Arrays.stream(handlerBean.getClass().getDeclaredMethods())
+											.filter(method1 -> routerOperation.beanMethod().equals(method1.getName()) && method1.getParameters().length == 0)
+											.findAny();
+									if (!methodOptional.isPresent())
+										methodOptional = Arrays.stream(handlerBean.getClass().getDeclaredMethods())
+												.filter(method1 -> routerOperation.beanMethod().equals(method1.getName()))
+												.findAny();
+									if (methodOptional.isPresent())
+										handlerMethod = new HandlerMethod(handlerBean, methodOptional.get());
+								}
+								else
+									handlerMethod = new HandlerMethod(handlerBean, routerOperation.beanMethod(), routerOperation.parameterTypes());
+							}
+							catch (NoSuchMethodException e) {
+								LOGGER.error(e.getMessage());
+							}
+							if (handlerMethod != null)
+								calculatePath(handlerMethod, routerOperation.path(), new HashSet<>(Arrays.asList(routerOperation.method())));
+						}
+					}
+				}
+			}
+		}
 	}
 
 	protected void calculateServerUrl(ServerHttpRequest serverHttpRequest, String apiDocsUrl) {
@@ -131,4 +199,23 @@ protected void calculateServerUrl(ServerHttpRequest serverHttpRequest, String ap
 		openAPIBuilder.setServerBaseUrl(serverBaseUrl);
 	}
 
+	public List<String> getBeansWithAnnotation(ConfigurableListableBeanFactory factory, Class<? extends Annotation> type) {
+
+		List<String> result = new ArrayList<>();
+
+		for (String name : factory.getBeanDefinitionNames()) {
+			BeanDefinition bd = factory.getBeanDefinition(name);
+
+			if (bd.getSource() instanceof StandardMethodMetadata) {
+				StandardMethodMetadata metadata = (StandardMethodMetadata) bd.getSource();
+
+				Map<String, Object> attributes = metadata.getAnnotationAttributes(type.getName());
+				if (null == attributes) {
+					continue;
+				}
+			}
+		}
+
+		return result;
+	}
 }

springdoc-openapi-webflux-core/src/main/java/org/springdoc/webflux/core/RequestBuilder.java

@@ -31,6 +31,7 @@
 import org.springframework.http.codec.multipart.FilePart;
 import org.springframework.http.server.reactive.ServerHttpRequest;
 import org.springframework.http.server.reactive.ServerHttpResponse;
+import org.springframework.web.reactive.function.server.ServerRequest;
 import org.springframework.web.server.ServerWebExchange;
 
 import static org.springdoc.core.SpringDocUtils.getConfig;
@@ -40,6 +41,7 @@ public class RequestBuilder extends AbstractRequestBuilder {
 	static {
 		getConfig().addRequestWrapperToIgnore(ServerWebExchange.class, ServerHttpRequest.class)
 				.addRequestWrapperToIgnore(ServerHttpResponse.class)
+				.addRequestWrapperToIgnore(ServerRequest.class)
 				.addFileType(FilePart.class);
 	}
 

springdoc-openapi-webflux-core/src/test/java/test/org/springdoc/api/app69/RoutingConfiguration.java

@@ -0,0 +1,38 @@
+package test.org.springdoc.api.app69;
+
+import org.springdoc.webflux.annotations.RouterOperation;
+import org.springdoc.webflux.annotations.RouterOperations;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.reactive.function.server.RouterFunction;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+import static org.springframework.web.reactive.function.server.RequestPredicates.DELETE;
+import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
+import static org.springframework.web.reactive.function.server.RequestPredicates.POST;
+import static org.springframework.web.reactive.function.server.RequestPredicates.PUT;
+import static org.springframework.web.reactive.function.server.RequestPredicates.accept;
+import static org.springframework.web.reactive.function.server.RouterFunctions.route;
+
+@Configuration
+public class RoutingConfiguration {
+
+	@Bean
+	@RouterOperations({ @RouterOperation(path = "/api/user/index", method = RequestMethod.GET, beanClass = UserRepository.class, beanMethod = "getAllUsers", consumes = MediaType.APPLICATION_JSON_VALUE),
+			@RouterOperation(path = "/api/user/byFirstName", method = RequestMethod.GET, beanClass = UserRepository.class, beanMethod = "getAllUsers", parameterTypes = {String.class} , consumes = MediaType.APPLICATION_JSON_VALUE),
+			@RouterOperation(path = "/api/user/{id}", method = RequestMethod.GET, beanClass = UserRepository.class, beanMethod = "getUserById", consumes = MediaType.APPLICATION_JSON_VALUE),
+			@RouterOperation(path = "/api/user/post", method = RequestMethod.POST, beanClass = UserRepository.class, beanMethod = "saveUser", consumes = MediaType.APPLICATION_JSON_VALUE),
+			@RouterOperation(path = "/api/user/put/{id}", method = RequestMethod.PUT, beanClass = UserRepository.class, beanMethod = "putUser", consumes = MediaType.APPLICATION_JSON_VALUE),
+			@RouterOperation(path = "/api/user/delete/{id}", method = RequestMethod.DELETE, beanClass = UserRepository.class, beanMethod = "deleteUser", consumes = MediaType.APPLICATION_JSON_VALUE) })
+	public RouterFunction<ServerResponse> monoRouterFunction(UserHandler userHandler) {
+		return route(GET("/api/user/index").and(accept(MediaType.APPLICATION_JSON)), userHandler::getAll)
+				.andRoute(GET("/api/user/{id}").and(accept(MediaType.APPLICATION_JSON)), userHandler::getUser)
+				.andRoute(POST("/api/user/post").and(accept(MediaType.APPLICATION_JSON)), userHandler::postUser)
+				.andRoute(PUT("/api/user/put/{id}").and(accept(MediaType.APPLICATION_JSON)), userHandler::putUser)
+				.andRoute(DELETE("/api/user/delete/{id}").and(accept(MediaType.APPLICATION_JSON)), userHandler::deleteUser);
+	}
+
+}

springdoc-openapi-webflux-core/src/test/java/test/org/springdoc/api/app69/SpringDocApp69Test.java

@@ -0,0 +1,31 @@
+/*
+ *
+ *  * Copyright 2019-2020 the original author or authors.
+ *  *
+ *  * Licensed under the Apache License, Version 2.0 (the "License");
+ *  * you may not use this file except in compliance with the License.
+ *  * You may obtain a copy of the License at
+ *  *
+ *  *      https://www.apache.org/licenses/LICENSE-2.0
+ *  *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  * distributed under the License is distributed on an "AS IS" BASIS,
+ *  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  * See the License for the specific language governing permissions and
+ *  * limitations under the License.
+ *
+ */
+
+package test.org.springdoc.api.app69;
+
+import test.org.springdoc.api.AbstractSpringDocTest;
+
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.ComponentScan;
+
+public class SpringDocApp69Test extends AbstractSpringDocTest {
+
+	@SpringBootApplication
+	@ComponentScan(basePackages = { "org.springdoc", "test.org.springdoc.api.app69" })
+	static class SpringDocTestApp {}
+}