From 41d1dfa6bc4836f39fadbde91919ce6954aa1e95 Mon Sep 17 00:00:00 2001 From: Dave Syer Date: Mon, 13 Nov 2017 09:27:36 +0000 Subject: [PATCH] Add public registration method to bean post processor Also simplifies logic of looking up message types --- ...ntextFunctionCatalogAutoConfiguration.java | 27 +++--- .../ContextFunctionPostProcessorTests.java | 97 +++++++++++++++++++ 2 files changed, 111 insertions(+), 13 deletions(-) create mode 100644 spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/ContextFunctionPostProcessorTests.java diff --git a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/ContextFunctionCatalogAutoConfiguration.java b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/ContextFunctionCatalogAutoConfiguration.java index 98d8af3cc..adbfbef01 100644 --- a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/ContextFunctionCatalogAutoConfiguration.java +++ b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/ContextFunctionCatalogAutoConfiguration.java @@ -318,6 +318,12 @@ public class ContextFunctionCatalogAutoConfiguration { } } + @SuppressWarnings("unchecked") + public void register(FunctionRegistration function) { + wrap((FunctionRegistration) function, + function.getNames().iterator().next()); + } + public Set> merge( Map> initial, Map> consumers, Map> suppliers, @@ -387,7 +393,7 @@ public class ContextFunctionCatalogAutoConfiguration { private Collection getAliases(String key) { Collection names = new LinkedHashSet<>(); String value = getQualifier(key); - if (value.equals(key)) { + if (value.equals(key) && registry != null) { names.addAll(Arrays.asList(registry.getAliases(key))); } names.add(value); @@ -416,7 +422,7 @@ public class ContextFunctionCatalogAutoConfiguration { } private String getQualifier(String key) { - if (registry.containsBeanDefinition(key)) { + if (registry != null && registry.containsBeanDefinition(key)) { BeanDefinition beanDefinition = registry.getBeanDefinition(key); Object source = beanDefinition.getSource(); if (source instanceof StandardMethodMetadata) { @@ -658,16 +664,10 @@ public class ContextFunctionCatalogAutoConfiguration { } private boolean isMessage(Object function) { - String name = registrations.get(function); - if (name == null || !registry.containsBeanDefinition(name)) { - return false; - } - return Message.class.isAssignableFrom(findType(name, - (AbstractBeanDefinition) registry.getBeanDefinition(name), - ParamType.INPUT_INNER_WRAPPER)) - || Message.class.isAssignableFrom(findType(name, - (AbstractBeanDefinition) registry.getBeanDefinition(name), - ParamType.OUTPUT_INNER_WRAPPER)); + return Message.class + .isAssignableFrom(findType(function, ParamType.INPUT_INNER_WRAPPER)) + || Message.class.isAssignableFrom( + findType(function, ParamType.OUTPUT_INNER_WRAPPER)); } private Class findType(Object function, ParamType type) { @@ -678,7 +678,8 @@ public class ContextFunctionCatalogAutoConfiguration { return values.get(type); } } - if (name == null || !registry.containsBeanDefinition(name)) { + if (name == null || registry == null + || !registry.containsBeanDefinition(name)) { if (function != null) { Type param = findTypeFromBeanClass(function.getClass(), type); if (param != null) { diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/ContextFunctionPostProcessorTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/ContextFunctionPostProcessorTests.java new file mode 100644 index 000000000..cdfe6cb6f --- /dev/null +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/ContextFunctionPostProcessorTests.java @@ -0,0 +1,97 @@ +/* + * Copyright 2016-2017 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 + * + * http://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.springframework.cloud.function.context; + +import java.util.Collections; +import java.util.function.Function; + +import org.junit.Test; + +import org.springframework.cloud.function.context.ContextFunctionCatalogAutoConfiguration.ContextFunctionPostProcessor; + +import static org.assertj.core.api.Assertions.assertThat; + +import reactor.core.publisher.Flux; + +/** + * @author Dave Syer + * + */ +public class ContextFunctionPostProcessorTests { + + private ContextFunctionPostProcessor processor = new ContextFunctionPostProcessor(); + + @Test + public void basicRegistrationFeatures() { + processor.register(new FunctionRegistration<>(new Foos()).names("foos")); + @SuppressWarnings("unchecked") + Function, Flux> foos = (Function, Flux>) processor + .compose("foos"); + assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4"); + } + + @Test + public void registrationThroughMerge() { + FunctionRegistration registration = new FunctionRegistration<>(new Foos()) + .names("foos"); + processor.merge(Collections.singletonMap("foos", registration), + Collections.emptyMap(), Collections.emptyMap(), Collections.emptyMap()); + @SuppressWarnings("unchecked") + Function, Flux> foos = (Function, Flux>) processor + .compose("foos"); + assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4"); + } + + @Test + public void registrationThroughMergeFromNamedFunction() { + processor.merge(Collections.emptyMap(), Collections.emptyMap(), + Collections.emptyMap(), Collections.singletonMap("foos", new Foos())); + @SuppressWarnings("unchecked") + Function, Flux> foos = (Function, Flux>) processor + .compose("foos"); + assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4"); + } + + @Test + public void compose() { + processor.register(new FunctionRegistration<>(new Foos()).names("foos")); + processor.register(new FunctionRegistration<>(new Bars()).names("bars")); + @SuppressWarnings("unchecked") + Function, Flux> foos = (Function, Flux>) processor + .compose("foos,bars"); + assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("Hello 4"); + } + + protected static class Foos implements Function { + + @Override + public String apply(Integer t) { + return "" + 2 * t; + } + + } + + protected static class Bars implements Function { + + @Override + public String apply(String t) { + return "Hello " + t; + } + + } + +}