Deprecate and remove all usages of FunctionInspector

spring-cloud-function-adapters/spring-cloud-function-adapter-aws/src/main/java/org/springframework/cloud/function/adapter/aws/SpringBootKinesisEventHandler.java

@@ -32,6 +32,7 @@ import org.springframework.messaging.support.GenericMessage;
 
 import static java.util.stream.Collectors.toList;
 
+
 /**
  * @param <E> payload type
  * @param <O> response type

spring-cloud-function-adapters/spring-cloud-function-adapter-azure/src/main/java/org/springframework/cloud/function/adapter/azure/AzureSpringBootRequestHandler.java

@@ -27,6 +27,8 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import org.springframework.cloud.function.context.AbstractSpringFunctionAdapterInitializer;
+import org.springframework.cloud.function.context.catalog.FunctionTypeUtils;
+import org.springframework.cloud.function.context.catalog.SimpleFunctionRegistry.FunctionInvocationWrapper;
 
 /**
  * @param <I> input type
@@ -129,7 +131,7 @@ public class AzureSpringBootRequestHandler<I, O> extends AbstractSpringFunctionA
 		}
 		if (getInspector() != null) {
 			return Collection.class
-					.isAssignableFrom(getInspector().getInputType(function));
+					.isAssignableFrom(((FunctionInvocationWrapper) function).getRawInputType());
 		}
 		return ((Collection<?>) input).size() <= 1;
 	}
@@ -139,8 +141,8 @@ public class AzureSpringBootRequestHandler<I, O> extends AbstractSpringFunctionA
 			return true;
 		}
 		if (getInspector() != null) {
-			return Collection.class
+			Class<?> outputType = FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(((FunctionInvocationWrapper) function).getOutputType()));
-					.isAssignableFrom(getInspector().getOutputType(function));
+			return Collection.class.isAssignableFrom(outputType);
 		}
 		return ((Collection<?>) output).size() <= 1;
 	}

spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/AbstractSpringFunctionAdapterInitializer.java

@@ -36,6 +36,8 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.WebApplicationType;
 import org.springframework.cloud.function.context.catalog.FunctionInspector;
+import org.springframework.cloud.function.context.catalog.FunctionTypeUtils;
+import org.springframework.cloud.function.context.catalog.SimpleFunctionRegistry.FunctionInvocationWrapper;
 import org.springframework.cloud.function.context.config.FunctionContextUtils;
 import org.springframework.cloud.function.context.config.RoutingFunction;
 import org.springframework.cloud.function.json.JsonMapper;
@@ -138,15 +140,18 @@ public abstract class AbstractSpringFunctionAdapterInitializer<C> implements Clo
 		}
 	}
 
+	@Deprecated
 	protected FunctionInspector getInspector() {
 		return inspector;
 	}
 
 	protected Class<?> getInputType() {
-		if (this.inspector != null) {
+
-			return this.inspector.getInputType(function());
+		Object func =  function();
+		if (func != null && func instanceof FunctionInvocationWrapper) {
+			return FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(((FunctionInvocationWrapper) func).getInputType()));
 		}
-		else if (functionRegistration != null) {
+		if (functionRegistration != null) {
 			return functionRegistration.getType().getInputType();
 		}
 		return Object.class;
@@ -237,7 +242,7 @@ public abstract class AbstractSpringFunctionAdapterInitializer<C> implements Clo
 		}
 		if (getInspector() != null) {
 			return Collection.class
-					.isAssignableFrom(getInspector().getInputType(function));
+					.isAssignableFrom(((FunctionInvocationWrapper) function).getRawInputType());
 		}
 		return ((Collection<?>) input).size() <= 1;
 	}
@@ -247,8 +252,8 @@ public abstract class AbstractSpringFunctionAdapterInitializer<C> implements Clo
 			return true;
 		}
 		if (getInspector() != null) {
-			return Collection.class
+			Class<?> outputType = FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(((FunctionInvocationWrapper) function).getOutputType()));
-					.isAssignableFrom(getInspector().getOutputType(function));
+			return Collection.class.isAssignableFrom(outputType);
 		}
 		return ((Collection<?>) output).size() <= 1;
 	}

spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/FunctionInspector.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-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.
@@ -31,7 +31,10 @@ import org.springframework.cloud.function.context.catalog.SimpleFunctionRegistry
 /**
  * @author Dave Syer
  * @author Oleg Zhurakousky
+ *
+ * @deprecated since 3.1 no longer used by the framework
  */
+@Deprecated
 public interface FunctionInspector {
 
 	FunctionRegistration<?> getRegistration(Object function);
@@ -49,6 +52,11 @@ public interface FunctionInspector {
 		return ((FunctionInvocationWrapper) function).isInputTypeMessage();
 	}
 
+	/**
+	 *
+	 * @deprecated since 3.1 no longer used by the framework
+	 */
+	@Deprecated
 	default Class<?> getInputType(Object function) {
 		if (function == null) {
 			return Object.class;
@@ -69,6 +77,11 @@ public interface FunctionInspector {
 		return inputType;
 	}
 
+	/**
+	 *
+	 * @deprecated since 3.1 no longer used by the framework
+	 */
+	@Deprecated
 	default Class<?> getOutputType(Object function) {
 		if (function == null) {
 			return Object.class;
@@ -89,6 +102,11 @@ public interface FunctionInspector {
 		return outputType;
 	}
 
+	/**
+	 *
+	 * @deprecated since 3.1 no longer used by the framework
+	 */
+	@Deprecated
 	default Class<?> getInputWrapper(Object function) {
 		Class c = function == null ? Object.class : TypeResolver.resolveRawClass(((FunctionInvocationWrapper) function).getInputType(), null);
 		if (Flux.class.isAssignableFrom(c)) {
@@ -102,6 +120,11 @@ public interface FunctionInspector {
 		}
 	}
 
+	/**
+	 *
+	 * @deprecated since 3.1 no longer used by the framework
+	 */
+	@Deprecated
 	default Class<?> getOutputWrapper(Object function) {
 		Class c  = function == null ? Object.class : TypeResolver.resolveRawClass(((FunctionInvocationWrapper) function).getOutputType(), null);
 		if (Flux.class.isAssignableFrom(c)) {
@@ -115,6 +138,11 @@ public interface FunctionInspector {
 		}
 	}
 
+	/**
+	 *
+	 * @deprecated since 3.1 no longer used by the framework
+	 */
+	@Deprecated
 	default String getName(Object function) {
 		if (function == null) {
 			return null;

spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/FunctionTypeUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019-2019 the original author or authors.
+ * 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.
@@ -31,6 +31,8 @@ import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 import net.jodah.typetools.TypeResolver;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.Flux;
 
@@ -50,6 +52,8 @@ import org.springframework.util.ReflectionUtils;
  */
 public final class FunctionTypeUtils {
 
+	private static  Log logger = LogFactory.getLog(FunctionTypeUtils.class);
+
 	private FunctionTypeUtils() {
 
 	}
@@ -86,6 +90,10 @@ public final class FunctionTypeUtils {
 		return type;
 	}
 
+	public static Class<?> getRawType(Type type) {
+		return type != null ? TypeResolver.resolveRawClass(type, null) : null;
+	}
+
 	/**
 	 * Will attempt to discover functional methods on the class. It's applicable for POJOs as well as
 	 * functional classes in `java.util.function` package. For the later the names of the methods are
@@ -188,41 +196,52 @@ public final class FunctionTypeUtils {
 		return outputCount;
 	}
 
+	/**
+	 * Returns input type of function type that represents Function or Consumer.
+	 * @param functionType  the Type of Function or Consumer
+	 * @return the input type as {@link Type}
+	 */
 	@SuppressWarnings("unchecked")
 	public static Type getInputType(Type functionType) {
+		if (isSupplier(functionType)) {
+			logger.debug("Supplier does not have input type, returning null as input type.");
+			return null;
+		}
 		assertSupportedTypes(functionType);
+
+		Type inputType;
 		if (functionType instanceof Class) {
-			Class<?> functionClass  = (Class<?>) functionType;
+			functionType = Function.class.isAssignableFrom((Class<?>) functionType)
-			if (Function.class.isAssignableFrom(functionClass)) {
+					? TypeResolver.reify(Function.class, (Class<Function<?, ?>>) functionType)
-				functionType = TypeResolver.reify(Function.class, (Class<Function<?, ?>>) functionClass);
+					: TypeResolver.reify(Consumer.class, (Class<Consumer<?>>) functionType);
-			}
-			else if (Consumer.class.isAssignableFrom(functionClass)) {
-				functionType = TypeResolver.reify(Consumer.class, (Class<Consumer<?>>) functionClass);
-			}
-			else {
-				return null;
-			}
 		}
 
-		Type inputType = Object.class;
+		inputType = functionType instanceof ParameterizedType
-		if ((isFunction(functionType) || isConsumer(functionType)) && functionType instanceof ParameterizedType) {
+				? ((ParameterizedType) functionType).getActualTypeArguments()[0]
-			inputType = ((ParameterizedType) functionType).getActualTypeArguments()[0];
+				: Object.class;
-		}
 
 		return inputType;
 	}
 
-	public static Type getOutputType(Type functionType, int index) {
+	@SuppressWarnings("unchecked")
+	public static Type getOutputType(Type functionType) {
 		assertSupportedTypes(functionType);
-		if (isFunction(functionType)) {
+		if (isConsumer(functionType)) {
-			return functionType instanceof ParameterizedType ? ((ParameterizedType) functionType).getActualTypeArguments()[1] : Object.class;
+			logger.debug("Consumer does not have output type, returning null as output type.");
-		}
-		else if (isSupplier(functionType)) {
-			return functionType instanceof ParameterizedType ? ((ParameterizedType) functionType).getActualTypeArguments()[0] : Object.class;
-		}
-		else {
 			return null;
 		}
+		Type inputType;
+		if (functionType instanceof Class) {
+			functionType = Function.class.isAssignableFrom((Class<?>) functionType)
+					? TypeResolver.reify(Function.class, (Class<Function<?, ?>>) functionType)
+					: TypeResolver.reify(Function.class, (Class<Supplier<?>>) functionType);
+		}
+
+		inputType = functionType instanceof ParameterizedType
+				? (isSupplier(functionType) ? ((ParameterizedType) functionType).getActualTypeArguments()[0] : ((ParameterizedType) functionType).getActualTypeArguments()[1])
+				: Object.class;
+
+		return inputType;
 	}
 
 	public static Type getImmediateGenericType(Type type, int index) {
@@ -238,8 +257,6 @@ public final class FunctionTypeUtils {
 
 	public static boolean isFlux(Type type) {
 		return TypeResolver.resolveRawClass(type, null) == Flux.class;
-//		type = extractReactiveType(type);
-//		return type.getTypeName().startsWith("reactor.core.publisher.Flux");
 	}
 
 	public static boolean isMessage(Type type) {
@@ -252,23 +269,13 @@ public final class FunctionTypeUtils {
 		return TypeResolver.resolveRawClass(type, null) == Message.class;
 	}
 
-	/**
-	 * Determines if input argument to a Function is an array.
-	 * @param functionType the function type
-	 * @return true if input type is an array, otherwise false
-	 */
-	public static boolean isInputArray(Type functionType) {
-		Type inputType = FunctionTypeUtils.getInputType(functionType);
-		return inputType instanceof GenericArrayType || inputType instanceof Class && ((Class<?>) inputType).isArray();
-	}
-
 	/**
 	 * Determines if input argument to a Function is an array.
 	 * @param functionType the function type
 	 * @return true if input type is an array, otherwise false
 	 */
 	public static boolean isOutputArray(Type functionType) {
-		Type outputType = FunctionTypeUtils.getOutputType(functionType, 0);
+		Type outputType = FunctionTypeUtils.getOutputType(functionType);
 		return outputType instanceof GenericArrayType || outputType instanceof Class && ((Class<?>) outputType).isArray();
 	}
 
@@ -296,7 +303,7 @@ public final class FunctionTypeUtils {
 
 	public static boolean isMono(Type type) {
 		type = extractReactiveType(type);
-		return type.getTypeName().startsWith("reactor.core.publisher.Mono");
+		return type == null ? false : type.getTypeName().startsWith("reactor.core.publisher.Mono");
 	}
 
 	private static boolean isFunctional(Type type) {

spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/SimpleFunctionRegistry.java

@@ -250,7 +250,7 @@ public class SimpleFunctionRegistry implements FunctionRegistry, FunctionInspect
 	private FunctionInvocationWrapper invocationWrapperInstance(String functionDefinition, Object target, Type functionType) {
 		return invocationWrapperInstance(functionDefinition, target,
 				FunctionTypeUtils.isSupplier(functionType) ? null : FunctionTypeUtils.getInputType(functionType),
-				FunctionTypeUtils.getOutputType(functionType, 0));
+				FunctionTypeUtils.getOutputType(functionType));
 	}
 
 	/**
@@ -325,11 +325,11 @@ public class SimpleFunctionRegistry implements FunctionRegistry, FunctionInspect
 		}
 
 		public Class<?> getRawOutputType() {
-			return TypeResolver.resolveRawClass(this.outputType, null);
+			return this.outputType == null ? null : TypeResolver.resolveRawClass(this.outputType, null);
 		}
 
 		public Class<?> getRawInputType() {
-			return TypeResolver.resolveRawClass(this.inputType, null);
+			return this.inputType == null ? null : TypeResolver.resolveRawClass(this.inputType, null);
 		}
 
 		/**

spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfigurationTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-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.
@@ -16,6 +16,7 @@
 
 package org.springframework.cloud.function.context.config;
 
+import java.lang.reflect.Type;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.ArrayList;
@@ -47,7 +48,7 @@ import org.springframework.boot.builder.SpringApplicationBuilder;
 import org.springframework.cloud.function.context.FunctionCatalog;
 import org.springframework.cloud.function.context.FunctionRegistration;
 import org.springframework.cloud.function.context.FunctionRegistry;
-import org.springframework.cloud.function.context.catalog.FunctionInspector;
+import org.springframework.cloud.function.context.catalog.FunctionTypeUtils;
 import org.springframework.cloud.function.context.catalog.SimpleFunctionRegistry.FunctionInvocationWrapper;
 import org.springframework.cloud.function.inject.FooConfiguration;
 import org.springframework.cloud.function.scan.ScannedFunction;
@@ -77,24 +78,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  */
 public class ContextFunctionCatalogAutoConfigurationTests {
 
-	private static String value;
-
 	private ConfigurableApplicationContext context;
 
 	private FunctionCatalog catalog;
 
-	private FunctionInspector inspector;
-
-	public static void set(Object value) {
-		ContextFunctionCatalogAutoConfigurationTests.value = value.toString();
-	}
-
 	@AfterEach
 	public void close() {
 		if (this.context != null) {
 			this.context.close();
 		}
-		ContextFunctionCatalogAutoConfigurationTests.value = null;
 	}
 
 	@Test
@@ -112,11 +104,9 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 		assertThat(f.apply(Flux.just("hello")).blockFirst())
 				.isEqualTo("HELLOfunction2function3");
 		assertThat(this.context.getBean("supplierFoo")).isInstanceOf(Supplier.class);
-//		assertThat((Supplier<?>) this.catalog.lookup(Supplier.class, "supplierFoo"))
+		assertThat((Supplier<?>) this.catalog.lookup(Supplier.class, "supplierFoo"))
-//				.isInstanceOf(Supplier.class);
+				.isInstanceOf(Supplier.class);
-//		assertThat(this.context.getBean("supplier_Foo")).isInstanceOf(Supplier.class);
+		assertThat(this.context.getBean("supplier_Foo")).isInstanceOf(Supplier.class);
-//		assertThat((Supplier<?>) this.catalog.lookup(Supplier.class, "supplier_Foo"))
-//				.isInstanceOf(Supplier.class);
 	}
 
 	@Test
@@ -128,29 +118,23 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 				.isInstanceOf(Function.class);
 		assertThat((Supplier<?>) this.catalog.lookup(Supplier.class, "foos"))
 				.isInstanceOf(Supplier.class);
-		assertThat(
+		Class<?> inputType = ((FunctionInvocationWrapper) this.catalog.lookup(Function.class, "foos")).getRawInputType();
-				this.inspector.getInputType(this.catalog.lookup(Function.class, "foos")))
+		assertThat(inputType).isEqualTo(String.class);
-						.isEqualTo(String.class);
+		FunctionInvocationWrapper function = this.catalog.lookup("foos");
-		assertThat(
+		Type outputType = function.getOutputType();
-				this.inspector.getOutputType(this.catalog.lookup(Supplier.class, "foos")))
+		assertThat((Class<?>) FunctionTypeUtils.getGenericType(outputType)).isEqualTo(Foo.class);
-						.isEqualTo(Foo.class);
 	}
 
 	@Test
 	public void configurationFunction() {
 		create(FunctionConfiguration.class);
 		assertThat(this.context.getBean("foos")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "foos"))
+		FunctionInvocationWrapper function = this.catalog.lookup(Function.class, "foos");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-		assertThat(
+		Type inputType = function.getInputType();
-				this.inspector.getInputType(this.catalog.lookup(Function.class, "foos")))
+		assertThat(FunctionTypeUtils.getGenericType(inputType)).isEqualTo(String.class);
-						.isEqualTo(String.class);
+		Type outputType = function.getOutputType();
-		assertThat(
+		assertThat((Class<?>) FunctionTypeUtils.getGenericType(outputType)).isEqualTo(Foo.class);
-				this.inspector.getOutputType(this.catalog.lookup(Function.class, "foos")))
-						.isEqualTo(Foo.class);
-		assertThat(this.inspector
-				.getInputWrapper(this.catalog.lookup(Function.class, "foos")))
-						.isEqualTo(Flux.class);
 	}
 
 	@Test
@@ -159,9 +143,8 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 		assertThat(this.context.getBean("foos")).isInstanceOf(Function.class);
 		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "foos"))
 				.isInstanceOf(Function.class);
-//		assertThat(
+		Class<?> inputType = ((FunctionInvocationWrapper) this.catalog.lookup(Function.class, "foos")).getRawInputType();
-//				this.inspector.getInputType(this.catalog.lookup(Function.class, "foos")))
+		assertThat(inputType).isEqualTo(String.class);
-//						.isEqualTo(String.class);
 	}
 
 	@Test
@@ -170,200 +153,145 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 		assertThat(this.context.getBean("foos")).isInstanceOf(Function.class);
 		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "foos"))
 				.isInstanceOf(Function.class);
-//		assertThat(
+		Class<?> inputType = ((FunctionInvocationWrapper) this.catalog.lookup(Function.class, "foos")).getRawInputType();
-//				this.inspector.getInputType(this.catalog.lookup(Function.class, "foos")))
+		assertThat(inputType).isEqualTo(String.class);
-//						.isEqualTo(String.class);
 	}
 
 	@Test
 	public void composedFunction() {
 		create(MultipleConfiguration.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "foos,bars"))
+		FunctionInvocationWrapper function = this.catalog.lookup(Function.class, "foos");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-//		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "names,foos"))
+
-//				.isNull();
+		function = this.catalog.lookup(Function.class, "foos,bars");
-//		assertThat(this.inspector
+		Class<?> inputType = function.getRawInputType();
-//				.getInputType(this.catalog.lookup(Function.class, "foos,bars")))
+		assertThat(inputType).isAssignableFrom(String.class);
-//						.isAssignableFrom(String.class);
+		Class<?> outputType = function.getRawOutputType();
-//		assertThat(this.inspector
+		assertThat(outputType).isAssignableFrom(Bar.class);
-//				.getOutputType(this.catalog.lookup(Function.class, "foos,bars")))
-//						.isAssignableFrom(Bar.class);
 	}
 
 	@Test
 	public void composedSupplier() {
 		create(MultipleConfiguration.class);
-		assertThat((Supplier<?>) this.catalog.lookup(Supplier.class, "names,foos"))
+		FunctionInvocationWrapper function = this.catalog.lookup("names,foos");
-				.isInstanceOf(Supplier.class);
+		assertThat(function).isInstanceOf(Supplier.class);
-//		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "names,foos"))
+		assertThat(function.getRawOutputType()).isAssignableFrom(Foo.class);
-//				.isNull();
+		assertThat(function.getRawInputType()).isNull();
-//		assertThat(this.inspector
-//				.getOutputType(this.catalog.lookup(Supplier.class, "names,foos")))
-//						.isAssignableFrom(Foo.class);
-		// The input type is the same as the input type of the first element in the chain
-//		assertThat(this.inspector
-//				.getInputType(this.catalog.lookup(Supplier.class, "names,foos")))
-//						.isAssignableFrom(Void.class);
 	}
 
 	@Test
 	public void composedConsumer() {
 		create(MultipleConfiguration.class);
-		assertThat((Consumer<?>) this.catalog.lookup(Consumer.class, "foos,print"))
+		FunctionInvocationWrapper function = this.catalog.lookup("foos,print");
-			.isInstanceOf(Consumer.class);
+		assertThat(function).isInstanceOf(Consumer.class);
-//				.isNull();
+		assertThat(function).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "foos,print"))
+		assertThat(function.getRawInputType()).isAssignableFrom(String.class);
-				.isInstanceOf(Function.class);
+		assertThat(function.getRawOutputType()).isNull();
-//		assertThat(this.inspector
-//				.getInputType(this.catalog.lookup(Function.class, "foos,print")))
-//						.isAssignableFrom(String.class);
-//		// The output type is the same as the output type of the last element in the chain
-//		assertThat(this.inspector
-//				.getOutputType(this.catalog.lookup(Function.class, "foos,print")))
-//						.isAssignableFrom(Void.class);
 	}
 
 	@Test
 	public void genericFunction() {
 		create(GenericConfiguration.class);
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		assertThat(function).isInstanceOf(Function.class);
-				.isInstanceOf(Function.class);
+		assertThat(function.getRawInputType()).isAssignableFrom(Map.class);
-//		assertThat(this.inspector
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Map.class);
-//		assertThat(this.inspector
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Map.class);
 	}
 
 	@Test
 	public void fluxMessageFunction() {
 		create(FluxMessageConfiguration.class);
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		assertThat(function).isInstanceOf(Function.class);
-				.isInstanceOf(Function.class);
+		assertThat(function.isInputTypeMessage()).isTrue();
-//		assertThat(
+
-//				this.inspector.isMessage(this.catalog.lookup(Function.class, "function")))
+		Type inputType = function.getInputType();
-//						.isTrue();
+
-//		assertThat(this.inspector
+		assertThat((Class<?>) FunctionTypeUtils.getGenericType(inputType)).isAssignableFrom(String.class);
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(String.class);
-//		assertThat(this.inspector
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Flux.class);
 	}
 
 	@Test
 	public void publisherMessageFunction() {
 		create(PublisherMessageConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-//		assertThat(
+		assertThat(function.isInputTypeMessage()).isTrue();
-//				this.inspector.isMessage(this.catalog.lookup(Function.class, "function")))
+
-//						.isTrue();
+		Type inputType = function.getInputType();
-//		assertThat(this.inspector
+		assertThat((Class<?>) FunctionTypeUtils.getGenericType(inputType)).isAssignableFrom(String.class);
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
+		assertThat(FunctionTypeUtils.getRawType(inputType)).isAssignableFrom(Publisher.class);
-//						.isAssignableFrom(String.class);
-//		assertThat(this.inspector
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Publisher.class);
 	}
 
 	@Test
 	public void monoFunction() {
 		create(MonoConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-//		assertThat(
+		assertThat(function.isInputTypeMessage()).isFalse();
-//				this.inspector.isMessage(this.catalog.lookup(Function.class, "function")))
+		Type inputType = function.getInputType();
-//						.isFalse();
+		Type outputType = function.getOutputType();
-//		assertThat(this.inspector
+		assertThat((Class<?>) FunctionTypeUtils.getGenericType(inputType)).isAssignableFrom(String.class);
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
+		assertThat(FunctionTypeUtils.getRawType(inputType)).isAssignableFrom(Flux.class);
-//						.isAssignableFrom(String.class);
+		assertThat(FunctionTypeUtils.getRawType(outputType)).isAssignableFrom(Mono.class);
-//		assertThat(this.inspector
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Flux.class);
-//		assertThat(this.inspector
-//				.getOutputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Mono.class);
 	}
 
-	@SuppressWarnings({ "rawtypes", "unchecked" })
 	@Test
 	public void monoToMonoNonVoidFunction() {
 		create(MonoToMonoNonVoidConfiguration.class);
-		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-//		assertThat(this.inspector
+		assertThat(function).isInstanceOf(Function.class);
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
+		Type inputType = function.getInputType();
-//						.isAssignableFrom(String.class);
+		assertThat((Class<?>) FunctionTypeUtils.getGenericType(inputType)).isAssignableFrom(String.class);
-//		assertThat(this.inspector
+		Type outputType = function.getOutputType();
-//				.getOutputType(this.catalog.lookup(Function.class, "function")))
+		assertThat((Class<?>) FunctionTypeUtils.getGenericType(outputType)).isAssignableFrom(String.class);
-//						.isAssignableFrom(String.class);
-
-		Function function = this.context.getBean(FunctionCatalog.class).lookup("function");
-		Object result = ((Mono) function.apply(Mono.just("flux"))).block();
 	}
 
 	@Test
 	public void messageFunction() {
 		create(MessageConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-//		assertThat(
+		assertThat(function.isInputTypeMessage()).isTrue();
-//				this.inspector.isMessage(this.catalog.lookup(Function.class, "function")))
+		assertThat(function.isOutputTypeMessage()).isTrue();
-//						.isTrue();
+		Type inputType = function.getInputType();
-//		assertThat(this.inspector
+		assertThat((Class<?>) FunctionTypeUtils.getGenericType(inputType)).isAssignableFrom(String.class);
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(String.class);
-//		assertThat(this.inspector
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(String.class);
 	}
 
 	@Test
 	public void genericFluxFunction() {
 		create(GenericFluxConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-//		assertThat(this.inspector
+		Type inputType = function.getInputType();
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
+		assertThat(FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(inputType))).isAssignableFrom(Map.class);
-//						.isAssignableFrom(Map.class);
+		assertThat(FunctionTypeUtils.getRawType(inputType)).isAssignableFrom(Flux.class);
-//		assertThat(this.inspector
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Flux.class);
 	}
 
 	@Test
 	public void externalFunction() {
 		create(ExternalConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-//		assertThat(this.inspector
+		Type inputType = function.getInputType();
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
+		assertThat(FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(inputType))).isAssignableFrom(Map.class);
-//						.isAssignableFrom(Map.class);
-//		assertThat(this.inspector
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Map.class);
 	}
 
 	@Test
 	public void singletonFunction() {
 		create(SingletonConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-//		assertThat(this.inspector
+		assertThat(function.isInputTypePublisher()).isFalse();
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
+		assertThat(function.isOutputTypePublisher()).isFalse();
-//						.isAssignableFrom(Integer.class);
+		Type inputType = function.getInputType();
-//		assertThat(this.inspector
+		assertThat(FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(inputType))).isAssignableFrom(Integer.class);
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Integer.class);
 	}
 
 	@Test
@@ -371,58 +299,41 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void singletonMessageFunction() {
 		create(SingletonMessageConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-		assertThat(this.inspector
+		assertThat(function.isInputTypeMessage()).isTrue();
-				.getInputType(this.catalog.lookup(Function.class, "function")))
+		Type inputType = function.getInputType();
-						.isAssignableFrom(Integer.class);
+		assertThat((Class<?>) FunctionTypeUtils.getGenericType(inputType)).isAssignableFrom(Integer.class);
-		assertThat(this.inspector
-				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-						.isAssignableFrom(Integer.class);
-		assertThat(((FunctionInvocationWrapper) this.catalog.lookup(Function.class, "function")).isInputTypeMessage())
-						.isTrue();
 	}
 
 	@Test
 	public void nonParametericTypeFunction() {
 		create(NonParametricTypeSingletonConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-//		assertThat(this.inspector
+		Type inputType = function.getInputType();
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
+		assertThat((Class<?>) FunctionTypeUtils.getGenericType(inputType)).isAssignableFrom(Integer.class);
-//						.isAssignableFrom(Integer.class);
-//		assertThat(this.inspector
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Integer.class);
 	}
 
 	@Test
 	public void componentScanBeanFunction() {
 		create(ComponentScanBeanConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-//		assertThat(this.inspector
+		Type inputType = function.getInputType();
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
+		assertThat(FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(inputType))).isAssignableFrom(Map.class);
-//						.isAssignableFrom(Map.class);
-//		assertThat(this.inspector
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Map.class);
 	}
 
 	@Test
 	public void componentScanFunction() {
 		create(ComponentScanConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		FunctionInvocationWrapper function = this.catalog.lookup("function");
-				.isInstanceOf(Function.class);
+		assertThat(function).isInstanceOf(Function.class);
-//		assertThat(this.inspector
+		Type inputType = function.getInputType();
-//				.getInputType(this.catalog.lookup(Function.class, "function")))
+		assertThat(FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(inputType))).isAssignableFrom(Map.class);
-//						.isAssignableFrom(Map.class);
-//		assertThat(this.inspector
-//				.getInputWrapper(this.catalog.lookup(Function.class, "function")))
-//						.isAssignableFrom(Map.class);
 	}
 
 	@Test
@@ -430,14 +341,10 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 		try {
 			create("greeter.jar", ComponentScanJarConfiguration.class);
 			assertThat(this.context.getBean("greeter")).isInstanceOf(Function.class);
-			assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "greeter"))
+			FunctionInvocationWrapper function = this.catalog.lookup("greeter");
-					.isInstanceOf(Function.class);
+			assertThat(function).isInstanceOf(Function.class);
-//			assertThat(this.inspector
+			Type inputType = function.getInputType();
-//					.getInputType(this.catalog.lookup(Function.class, "greeter")))
+			assertThat((Class<?>) FunctionTypeUtils.getGenericType(inputType)).isAssignableFrom(String.class);
-//							.isAssignableFrom(String.class);
-//			assertThat(this.inspector
-//					.getInputWrapper(this.catalog.lookup(Function.class, "greeter")))
-//							.isAssignableFrom(String.class);
 		}
 		finally {
 			ClassUtils.overrideThreadContextClassLoader(getClass().getClassLoader());
@@ -465,9 +372,6 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 				.lookup(Function.class, "function");
 		assertThat(function.apply(Flux.just("foo")).blockFirst()).isEqualTo("FOO");
 		assertThat(bean).isNotSameAs(function);
-//		assertThat(this.inspector.getRegistration(function)).isNotNull();
-//		assertThat(this.inspector.getRegistration(function).getType())
-//				.isEqualTo(this.inspector.getRegistration(function).getType());
 	}
 
 	@Test
@@ -494,12 +398,9 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void qualifiedBean() {
 		create(QualifiedConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		assertThat((Function<?, ?>) this.catalog.lookup("function")).isNull();
-				.isNull();
+		assertThat((Function<?, ?>) this.catalog.lookup("other")).isNotNull();
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "other"))
+		assertThat(FunctionTypeUtils.getGenericType(((FunctionInvocationWrapper) this.catalog.lookup("other")).getInputType()))
-				.isInstanceOf(Function.class);
-		assertThat(
-				this.inspector.getInputType(this.catalog.lookup(Function.class, "other")))
 						.isEqualTo(String.class);
 	}
 
@@ -518,12 +419,8 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void registrationBean() {
 		create(RegistrationConfiguration.class);
 		assertThat(this.context.getBean("function")).isInstanceOf(Function.class);
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function"))
+		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "function")).isInstanceOf(Function.class);
-		.isInstanceOf(Function.class);
+		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "registration")).isInstanceOf(Function.class);
-//				.isNull();
-		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "registration"))
-		.isInstanceOf(Function.class);
-//				.isNull();
 		assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "other"))
 				.isInstanceOf(Function.class);
 	}
@@ -557,7 +454,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	private void create(Class<?>[] types, String... props) {
 		this.context = new SpringApplicationBuilder(types).properties(props).run();
 		this.catalog = this.context.getBean(FunctionCatalog.class);
-		this.inspector = this.context.getBean(FunctionInspector.class);
+//		this.inspector = this.context.getBean(FunctionInspector.class);
 	}
 
 	@EnableAutoConfiguration
@@ -616,7 +513,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 
 		@Bean
 		public BeanFactoryPostProcessor someBeanFactoryPostProcessor(Environment environment,
-			@Nullable FunctionRegistry functionCatalog, @Nullable FunctionInspector inspector) {
+			@Nullable FunctionRegistry functionCatalog) {
 			return beanFactory -> { };
 		}
 	}

spring-cloud-function-web/src/main/java/org/springframework/cloud/function/web/BasicStringConverter.java

@@ -17,7 +17,8 @@
 package org.springframework.cloud.function.web;
 
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
-import org.springframework.cloud.function.context.catalog.FunctionInspector;
+import org.springframework.cloud.function.context.catalog.FunctionTypeUtils;
+import org.springframework.cloud.function.context.catalog.SimpleFunctionRegistry.FunctionInvocationWrapper;
 import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.support.DefaultConversionService;
 
@@ -32,11 +33,7 @@ public class BasicStringConverter implements StringConverter {
 
 	private ConfigurableListableBeanFactory registry;
 
-	private FunctionInspector inspector;
+	public BasicStringConverter(ConfigurableListableBeanFactory registry) {
-
-	public BasicStringConverter(FunctionInspector inspector,
-			ConfigurableListableBeanFactory registry) {
-		this.inspector = inspector;
 		this.registry = registry;
 	}
 
@@ -47,7 +44,8 @@ public class BasicStringConverter implements StringConverter {
 			this.conversionService = conversionService != null ? conversionService
 					: new DefaultConversionService();
 		}
-		Class<?> type = this.inspector.getInputType(function);
+		//Class<?> type = this.inspector.getInputType(function);
+		Class<?> type = function == null ? Object.class : FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(((FunctionInvocationWrapper) function).getInputType()));
 		return this.conversionService.canConvert(String.class, type)
 				? this.conversionService.convert(value, type) : value;
 	}

spring-cloud-function-web/src/main/java/org/springframework/cloud/function/web/RequestProcessor.java

@@ -41,7 +41,6 @@ import reactor.core.publisher.Mono;
 
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.cloud.function.context.FunctionCatalog;
-import org.springframework.cloud.function.context.catalog.FunctionInspector;
 import org.springframework.cloud.function.context.catalog.FunctionTypeUtils;
 import org.springframework.cloud.function.context.catalog.SimpleFunctionRegistry.FunctionInvocationWrapper;
 import org.springframework.cloud.function.context.config.RoutingFunction;
@@ -81,7 +80,6 @@ public class RequestProcessor {
 
 	private static Log logger = LogFactory.getLog(RequestProcessor.class);
 
-	private final FunctionInspector inspector;
 
 	private final FunctionCatalog functionCatalog;
 
@@ -91,12 +89,10 @@ public class RequestProcessor {
 
 	private final List<HttpMessageReader<?>> messageReaders;
 
-	public RequestProcessor(FunctionInspector inspector,
+	public RequestProcessor(FunctionCatalog functionCatalog,
-			FunctionCatalog functionCatalog,
 			ObjectProvider<JsonMapper> mapper, StringConverter converter,
 			ObjectProvider<ServerCodecConfigurer> codecs) {
 		this.mapper = mapper.getIfAvailable();
-		this.inspector = inspector;
 		this.functionCatalog = functionCatalog;
 		this.converter = converter;
 		ServerCodecConfigurer source = codecs.getIfAvailable();
@@ -141,7 +137,9 @@ public class RequestProcessor {
 	public Mono<ResponseEntity<?>> post(FunctionWrapper wrapper, String body,
 			boolean stream) {
 		Object function = wrapper.handler();
-		Class<?> inputType = this.inspector.getInputType(function);
+		Class<?> inputType = function == null
+				? Object.class
+				: FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(((FunctionInvocationWrapper) function).getInputType()));
 		Type itemType = getItemType(function);
 
 		Object input = body == null && inputType.isAssignableFrom(String.class) ? "" : body;
@@ -218,9 +216,10 @@ public class RequestProcessor {
 
 		Function function = wrapper.function();
 		Flux<?> flux;
+		Class<?> inputType = function == null ? Object.class : FunctionTypeUtils
+				.getRawType(FunctionTypeUtils.getGenericType(((FunctionInvocationWrapper) wrapper.handler()).getInputType()));
 		if (body != null) {
-			if (Collection.class
+			if (Collection.class.isAssignableFrom(inputType)) {
-					.isAssignableFrom(this.inspector.getInputType(wrapper.handler()))) {
 				flux = Flux.just(body);
 			}
 			else if (body instanceof Flux) {
@@ -233,8 +232,7 @@ public class RequestProcessor {
 				flux = Flux.fromIterable(iterable);
 			}
 		}
-		else if (MultiValueMap.class
+		else if (MultiValueMap.class.isAssignableFrom(inputType)) {
-				.isAssignableFrom(this.inspector.getInputType(wrapper.handler()))) {
 			flux = Flux.just(wrapper.params());
 		}
 		else {
@@ -261,7 +259,6 @@ public class RequestProcessor {
 		}
 		else if (function instanceof FunctionInvocationWrapper) {
 			Publisher<?> result = (Publisher<?>) function.apply(flux);
-//			Publisher<?> result = null;
 			if (((FunctionInvocationWrapper) function).isConsumer()) {
 				if (result != null) {
 					((Mono) result).subscribe();
@@ -342,26 +339,41 @@ public class RequestProcessor {
 
 
 	private boolean isInputMultiple(Object handler) {
-		Class<?> type = this.inspector.getInputType(handler);
+		FunctionInvocationWrapper function = (FunctionInvocationWrapper) handler;
-		Class<?> wrapper = this.inspector.getInputWrapper(handler);
+		Class<?> type = function == null ? Object.class : FunctionTypeUtils
-		return Collection.class.isAssignableFrom(type) || Flux.class.equals(wrapper);
+				.getRawType(FunctionTypeUtils.getGenericType(function.getInputType()));
+		return Collection.class.isAssignableFrom(type) || (function != null && FunctionTypeUtils.isFlux(function.getInputType()));
+
 	}
 
 	private boolean isOutputSingle(Object handler) {
-		Class<?> type = this.inspector.getOutputType(handler);
+		FunctionInvocationWrapper function = (FunctionInvocationWrapper) handler;
-		Class<?> wrapper = this.inspector.getOutputWrapper(handler);
+		Type outputType = function.getOutputType();
+//		if (function.isOutputTypePublisher()) {
+//			outputType = FunctionTypeUtils.getGenericType(outputType);
+//		}
+//		if (function.isOutputTypeMessage()) {
+//			outputType = FunctionTypeUtils.getGenericType(outputType);
+//		}
+		Class<?> type =  FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(outputType));
+//		Class<?> type1 = this.inspector.getOutputType(handler);
+//		Class<?> wrapper1 = this.inspector.getOutputWrapper(handler);
+		Class<?> wrapper = function.isOutputTypePublisher() ? FunctionTypeUtils.getRawType(outputType) : type;
 		if (Stream.class.isAssignableFrom(type)) {
 			return false;
 		}
 		else {
+
 			return wrapper == type || Mono.class.equals(wrapper)
 					|| Optional.class.equals(wrapper);
 		}
 	}
 
 	private Publisher<?> body(Object handler, ServerWebExchange exchange) {
-		ResolvableType elementType = ResolvableType
+		FunctionInvocationWrapper function = (FunctionInvocationWrapper) handler;
-				.forClass(this.inspector.getInputType(handler));
+		Class<?> inputType = FunctionTypeUtils
+				.getRawType(FunctionTypeUtils.getGenericType(function.getInputType()));
+		ResolvableType elementType = ResolvableType.forClass(inputType);
 
 		// we effectively delegate type conversion to FunctionCatalog
 		elementType = ResolvableType.forClass(String.class);

spring-cloud-function-web/src/main/java/org/springframework/cloud/function/web/flux/ReactorAutoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-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.
@@ -27,7 +27,6 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplicat
 import org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration;
 import org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration;
 import org.springframework.cloud.function.context.FunctionCatalog;
-import org.springframework.cloud.function.context.catalog.FunctionInspector;
 import org.springframework.cloud.function.web.BasicStringConverter;
 import org.springframework.cloud.function.web.RequestProcessor;
 import org.springframework.cloud.function.web.StringConverter;
@@ -55,9 +54,8 @@ public class ReactorAutoConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
-	public StringConverter functionStringConverter(FunctionInspector inspector,
+	public StringConverter functionStringConverter(ConfigurableListableBeanFactory beanFactory) {
-			ConfigurableListableBeanFactory beanFactory) {
+		return new BasicStringConverter(beanFactory);
-		return new BasicStringConverter(inspector, beanFactory);
 	}
 
 }

spring-cloud-function-web/src/main/java/org/springframework/cloud/function/web/function/FunctionEndpointInitializer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-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.
@@ -38,7 +38,7 @@ import org.springframework.boot.web.reactive.error.DefaultErrorAttributes;
 import org.springframework.boot.web.reactive.error.ErrorAttributes;
 import org.springframework.cloud.function.context.FunctionCatalog;
 import org.springframework.cloud.function.context.FunctionalSpringApplication;
-import org.springframework.cloud.function.context.catalog.FunctionInspector;
+import org.springframework.cloud.function.context.catalog.FunctionTypeUtils;
 import org.springframework.cloud.function.context.catalog.SimpleFunctionRegistry.FunctionInvocationWrapper;
 import org.springframework.cloud.function.context.config.ContextFunctionCatalogInitializer;
 import org.springframework.cloud.function.json.JsonMapper;
@@ -104,15 +104,14 @@ class FunctionEndpointInitializer implements ApplicationContextInitializer<Gener
 
 	private void registerEndpoint(GenericApplicationContext context) {
 		context.registerBean(StringConverter.class,
-				() -> new BasicStringConverter(context.getBean(FunctionInspector.class), context.getBeanFactory()));
+				() -> new BasicStringConverter(context.getBeanFactory()));
 		context.registerBean(RequestProcessor.class,
-				() -> new RequestProcessor(context.getBean(FunctionInspector.class),
+				() -> new RequestProcessor(
 						context.getBean(FunctionCatalog.class),
 						context.getBeanProvider(JsonMapper.class), context.getBean(StringConverter.class),
 						context.getBeanProvider(ServerCodecConfigurer.class)));
 		context.registerBean(FunctionEndpointFactory.class,
-				() -> new FunctionEndpointFactory(context.getBean(FunctionCatalog.class),
+				() -> new FunctionEndpointFactory(context.getBean(FunctionCatalog.class), context.getBean(RequestProcessor.class),
-						context.getBean(FunctionInspector.class), context.getBean(RequestProcessor.class),
 						context.getEnvironment()));
 		context.registerBean(RouterFunction.class,
 				() -> context.getBean(FunctionEndpointFactory.class).functionEndpoints());
@@ -199,18 +198,18 @@ class FunctionEndpointFactory {
 
 	private final String handler;
 
-	private final FunctionInspector inspector;
+//	private final FunctionInspector inspector;
 
 	private final RequestProcessor processor;
 
-	FunctionEndpointFactory(FunctionCatalog functionCatalog, FunctionInspector inspector, RequestProcessor processor,
+	FunctionEndpointFactory(FunctionCatalog functionCatalog, RequestProcessor processor,
 			Environment environment) {
 		String handler = environment.resolvePlaceholders("${function.handler}");
 		if (handler.startsWith("$")) {
 			handler = null;
 		}
 		this.processor = processor;
-		this.inspector = inspector;
+//		this.inspector = inspector;
 		this.functionCatalog = functionCatalog;
 		this.handler = handler;
 	}
@@ -233,9 +232,12 @@ class FunctionEndpointFactory {
 	@SuppressWarnings({ "unchecked" })
 	public <T> RouterFunction<?> functionEndpoints() {
 		return route(POST("/**"), request -> {
-			Function<Flux<?>, Flux<?>> function = (Function<Flux<?>, Flux<?>>) extract(request);
+			Object function = extract(request);
-			Class<T> outputType = (Class<T>) this.inspector.getOutputType(function);
+			FunctionInvocationWrapper funcWrapper = (FunctionInvocationWrapper) function;
-			FunctionWrapper wrapper = RequestProcessor.wrapper(function, null, null);
+			Class<?> outputType = funcWrapper == null
+					? Object.class
+					: FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(funcWrapper.getOutputType()));
+			FunctionWrapper wrapper = RequestProcessor.wrapper((Function<Flux<?>, Flux<?>>) function, null, null);
 			Mono<ResponseEntity<?>> stream = request.bodyToMono(String.class)
 					.flatMap(content -> this.processor.post(wrapper, content, false));
 			return stream.flatMap(entity -> {
@@ -245,7 +247,8 @@ class FunctionEndpointFactory {
 		})
 		.andRoute(GET("/**"), request -> {
 			Object functionComponent = extract(request);
-			Class<T> outputType = (Class<T>) this.inspector.getOutputType(functionComponent);
+			FunctionInvocationWrapper funcWrapper = (FunctionInvocationWrapper) functionComponent;
+			Class<?> outputType = FunctionTypeUtils.getRawType(FunctionTypeUtils.getGenericType(funcWrapper.getOutputType()));
 			if (((FunctionInvocationWrapper) functionComponent).isSupplier()) {
 				Supplier<? extends Flux<?>> supplier = (Supplier<Flux<?>>) functionComponent;
 				FunctionWrapper wrapper = RequestProcessor.wrapper(null, null, supplier);

spring-cloud-function-web/src/main/java/org/springframework/cloud/function/web/mvc/ReactorAutoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-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.
@@ -27,7 +27,6 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplicat
 import org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration;
 import org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration;
 import org.springframework.cloud.function.context.FunctionCatalog;
-import org.springframework.cloud.function.context.catalog.FunctionInspector;
 import org.springframework.cloud.function.web.BasicStringConverter;
 import org.springframework.cloud.function.web.RequestProcessor;
 import org.springframework.cloud.function.web.StringConverter;
@@ -55,9 +54,8 @@ public class ReactorAutoConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
-	public StringConverter functionStringConverter(FunctionInspector inspector,
+	public StringConverter functionStringConverter(ConfigurableListableBeanFactory beanFactory) {
-			ConfigurableListableBeanFactory beanFactory) {
+		return new BasicStringConverter(beanFactory);
-		return new BasicStringConverter(inspector, beanFactory);
 	}
 
 }