From 30187b583b6858f64fb94531b2ed6f255bf90500 Mon Sep 17 00:00:00 2001 From: Oleg Zhurakousky Date: Wed, 15 Aug 2018 17:55:22 +0200 Subject: [PATCH] GH-199 Added support for typeless lookup in FunctionCatalog Updated both the interface as well as InMemoryFunctionCatalog BeanFactoryFunctionCatalog and SingleEntryFunctionRegistry implementations Added tests Resolves #199 --- .../function/context/FunctionCatalog.java | 24 ++++- .../context/FunctionRegistration.java | 8 +- .../catalog/InMemoryFunctionCatalog.java | 13 ++- ...ntextFunctionCatalogAutoConfiguration.java | 30 ++++--- .../catalog/InMemoryFunctionCatalogTests.java | 20 +++++ .../BeanFactoryFunctionCatalogTests.java | 7 ++ ...FunctionCatalogAutoConfigurationTests.java | 88 ++++++++++--------- ...ontextFunctionCatalogInitializerTests.java | 12 +-- .../deployer/SingleEntryFunctionRegistry.java | 4 +- 9 files changed, 138 insertions(+), 68 deletions(-) diff --git a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionCatalog.java b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionCatalog.java index 9ef56c7b5..47fd69ce7 100644 --- a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionCatalog.java +++ b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionCatalog.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2017 the original author or authors. + * Copyright 2016-2018 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. @@ -20,10 +20,30 @@ import java.util.Set; /** * @author Dave Syer + * @author Oleg Zhurakousky */ public interface FunctionCatalog { - T lookup(Class type, String name); + /** + * Will look up the instance of the functional interface by name only + * + * @param name the name of the functional interface. Must not be null; + * @return instance of the functional interface registered with this catalog + */ + default public T lookup(String name) { + return this.lookup(null, name); + } + + /** + * Will look up the instance of the functional interface by name and type + * which can only be Supplier, Consumer or Function. If type is not provided, the lookup + * will be made based on name only + * + * @param type the type of functional interface. Can be null + * @param name the name of the functional interface. Must not be null; + * @return instance of the functional interface registered with this catalog + */ + T lookup(Class type, String name); Set getNames(Class type); diff --git a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionRegistration.java b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionRegistration.java index 0ec2add66..8fe933c05 100644 --- a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionRegistration.java +++ b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionRegistration.java @@ -31,6 +31,7 @@ import org.springframework.cloud.function.core.FluxConsumer; import org.springframework.cloud.function.core.FluxFunction; import org.springframework.cloud.function.core.FluxSupplier; import org.springframework.util.Assert; +import org.springframework.util.ObjectUtils; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; @@ -58,6 +59,7 @@ public class FunctionRegistration { this.target = target; } + /** * Creates instance of FunctionRegistration. * @@ -66,11 +68,11 @@ public class FunctionRegistration { * @param names additional set of names for this registration. Additional names * can be provided {@link #name(String)} or {@link #names(String...)} operations. */ - public FunctionRegistration(T target, String name, String... additionalNames) { + public FunctionRegistration(T target, String... names) { Assert.notNull(target, "'target' must not be null"); + Assert.notEmpty(names, "'names' must not be null or empty"); this.target = target; - this.names(name); - this.names(additionalNames); + this.names(names); } public Map getProperties() { diff --git a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalog.java b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalog.java index 0a44a1b65..6841bcea8 100644 --- a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalog.java +++ b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalog.java @@ -19,6 +19,7 @@ package org.springframework.cloud.function.context.catalog; import java.util.Collections; import java.util.HashMap; import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.function.Consumer; import java.util.function.Function; @@ -117,9 +118,15 @@ public class InMemoryFunctionCatalog @Override @SuppressWarnings("unchecked") - public T lookup(Class type, String name) { - Map map = this.extractTypeMap(type); - return (T) map.get(name); + public T lookup(Class type, String name) { + T function = null; + if (type == null) { + function = (T) functions.values().stream().filter(map -> map.get(name) != null).map(map -> map.get(name)).findFirst().orElse(null); + } + else { + function = (T) this.extractTypeMap(type).get(name); + } + return function; } @Override diff --git a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfiguration.java b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfiguration.java index df0467bec..90df6b145 100644 --- a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfiguration.java +++ b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfiguration.java @@ -135,17 +135,27 @@ public class ContextFunctionCatalogAutoConfiguration { @Override @SuppressWarnings("unchecked") - public T lookup(Class type, String name) { - if (Supplier.class.isAssignableFrom(type)) { - return (T) processor.lookupSupplier(name); + public T lookup(Class type, String name) { + T function = null; + if (type == null) { + function = (T) processor.lookupFunction(name); + if (function == null) { + function = (T) processor.lookupConsumer(name); + } + if (function == null) { + function = (T) processor.lookupSupplier(name); + } } - if (Consumer.class.isAssignableFrom(type)) { - return (T) processor.lookupConsumer(name); + else if (Supplier.class.isAssignableFrom(type)) { + function = (T) processor.lookupSupplier(name); } - if (Function.class.isAssignableFrom(type)) { - return (T) processor.lookupFunction(name); + else if (Consumer.class.isAssignableFrom(type)) { + function = (T) processor.lookupConsumer(name); } - return null; + else if (Function.class.isAssignableFrom(type)) { + function = (T) processor.lookupFunction(name); + } + return function; } @Override @@ -233,7 +243,7 @@ public class ContextFunctionCatalogAutoConfiguration { if (function == null || !names.containsKey(function)) { return null; } - return new FunctionRegistration<>(function).name(names.get(function)) + return new FunctionRegistration<>(function, names.get(function)) .type(findType(function).getType()); } @@ -390,7 +400,7 @@ public class ContextFunctionCatalogAutoConfiguration { .forEach(entry -> { if (!targets.containsKey(entry.getValue())) { FunctionRegistration target = new FunctionRegistration( - entry.getValue()).names(getAliases(entry.getKey())); + entry.getValue(), getAliases(entry.getKey()).toArray(new String[] {})); targets.put(target.getTarget(), entry.getKey()); registrations.add(target); } diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalogTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalogTests.java index 282f20c07..3e9104df6 100644 --- a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalogTests.java +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalogTests.java @@ -16,13 +16,17 @@ package org.springframework.cloud.function.context.catalog; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; import java.util.function.Function; import org.junit.Test; import org.springframework.cloud.function.context.FunctionRegistration; import org.springframework.cloud.function.context.FunctionType; +import org.springframework.cloud.function.core.FluxFunction; /** * @@ -42,6 +46,22 @@ public class InMemoryFunctionCatalogTests { assertSame(registration, registration2); } + @Test + public void testFunctionLookup() { + TestFunction function = new TestFunction(); + FunctionRegistration registration = new FunctionRegistration<>(function, "foo") + .type(FunctionType.of(TestFunction.class).getType()); + InMemoryFunctionCatalog catalog = new InMemoryFunctionCatalog(); + catalog.register(registration); + + Object lookedUpFunction = catalog.lookup("hello"); + assertNull(lookedUpFunction); + + lookedUpFunction = catalog.lookup("foo"); + assertNotNull(lookedUpFunction); + assertTrue(lookedUpFunction instanceof FluxFunction); + } + private static class TestFunction implements Function { @Override public String apply(Integer t) { diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/BeanFactoryFunctionCatalogTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/BeanFactoryFunctionCatalogTests.java index 7d3cd3eaa..55e0fdac5 100644 --- a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/BeanFactoryFunctionCatalogTests.java +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/BeanFactoryFunctionCatalogTests.java @@ -60,6 +60,13 @@ public class BeanFactoryFunctionCatalogTests { assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4"); } + @Test + public void lookupFunctionWithNoType() { + processor.register(new FunctionRegistration<>(new Foos(), "foos")); + Function, Flux> foos = processor.lookup("foos"); + assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4"); + } + @Test public void registerFunctionWithType() { processor.register(new FunctionRegistration>( diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfigurationTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfigurationTests.java index 984d1b479..109b14efb 100644 --- a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfigurationTests.java +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfigurationTests.java @@ -89,14 +89,15 @@ public class ContextFunctionCatalogAutoConfigurationTests { ContextFunctionCatalogAutoConfigurationTests.value = null; } + @SuppressWarnings("unchecked") @Test public void lookUps() { create(SimpleConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(context.getBean("function2")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function,function2")) + assertThat(catalog.lookup(Function.class, "function,function2")) .isInstanceOf(Function.class); Function, Flux> f = catalog.lookup(Function.class, "function,function2,function3"); @@ -104,10 +105,10 @@ public class ContextFunctionCatalogAutoConfigurationTests { assertThat(f.apply(Flux.just("hello")).blockFirst()) .isEqualTo("HELLOfunction2function3"); assertThat(context.getBean("supplierFoo")).isInstanceOf(Supplier.class); - assertThat(catalog.>lookup(Supplier.class, "supplierFoo")) + assertThat(catalog.lookup(Supplier.class, "supplierFoo")) .isInstanceOf(Supplier.class); assertThat(context.getBean("supplier_Foo")).isInstanceOf(Supplier.class); - assertThat(catalog.>lookup(Supplier.class, "supplier_Foo")) + assertThat(catalog.lookup(Supplier.class, "supplier_Foo")) .isInstanceOf(Supplier.class); } @@ -115,9 +116,9 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void ambiguousFunction() { create(AmbiguousConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "foos")) + assertThat(catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); - assertThat(catalog.>lookup(Supplier.class, "foos")) + assertThat(catalog.lookup(Supplier.class, "foos")) .isInstanceOf(Supplier.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -129,7 +130,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void configurationFunction() { create(FunctionConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "foos")) + assertThat(catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -143,7 +144,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void dependencyInjection() { create(DependencyInjectionConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "foos")) + assertThat(catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -153,7 +154,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void externalDependencyInjection() { create(ExternalDependencyConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "foos")) + assertThat(catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -162,9 +163,9 @@ public class ContextFunctionCatalogAutoConfigurationTests { @Test public void composedFunction() { create(MultipleConfiguration.class); - assertThat(catalog.>lookup(Function.class, "foos,bars")) + assertThat(catalog.lookup(Function.class, "foos,bars")) .isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "names,foos")).isNull(); + assertThat(catalog.lookup(Function.class, "names,foos")).isNull(); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos,bars"))) .isAssignableFrom(String.class); assertThat(inspector.getOutputType(catalog.lookup(Function.class, "foos,bars"))) @@ -174,9 +175,9 @@ public class ContextFunctionCatalogAutoConfigurationTests { @Test public void composedSupplier() { create(MultipleConfiguration.class); - assertThat(catalog.>lookup(Supplier.class, "names,foos")) + assertThat(catalog.lookup(Supplier.class, "names,foos")) .isInstanceOf(Supplier.class); - assertThat(catalog.>lookup(Function.class, "names,foos")).isNull(); + assertThat(catalog.lookup(Function.class, "names,foos")).isNull(); assertThat(inspector.getOutputType(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 @@ -187,8 +188,8 @@ public class ContextFunctionCatalogAutoConfigurationTests { @Test public void composedConsumer() { create(MultipleConfiguration.class); - assertThat(catalog.>lookup(Consumer.class, "foos,print")).isNull(); - assertThat(catalog.>lookup(Function.class, "foos,print")) + assertThat(catalog.lookup(Consumer.class, "foos,print")).isNull(); + assertThat(catalog.lookup(Function.class, "foos,print")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos,print"))) .isAssignableFrom(String.class); @@ -201,7 +202,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void genericFunction() { create(GenericConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Map.class); @@ -213,7 +214,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void fluxMessageFunction() { create(FluxMessageConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) .isTrue(); @@ -227,7 +228,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void publisherMessageFunction() { create(PublisherMessageConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) .isTrue(); @@ -241,7 +242,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void monoFunction() { create(MonoConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) .isFalse(); @@ -257,7 +258,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void messageFunction() { create(MessageConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) .isTrue(); @@ -271,7 +272,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void genericFluxFunction() { create(GenericFluxConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Map.class); @@ -283,7 +284,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void externalFunction() { create(ExternalConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Map.class); @@ -295,7 +296,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void singletonFunction() { create(SingletonConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Integer.class); @@ -307,7 +308,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void singletonMessageFunction() { create(SingletonMessageConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Integer.class); @@ -321,7 +322,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void nonParametericTypeFunction() { create(NonParametricTypeSingletonConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Integer.class); @@ -333,7 +334,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void componentScanBeanFunction() { create(ComponentScanBeanConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Map.class); @@ -345,7 +346,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void componentScanFunction() { create(ComponentScanConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Map.class); @@ -358,7 +359,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { try { create("greeter.jar", ComponentScanJarConfiguration.class); assertThat(context.getBean("greeter")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "greeter")) + assertThat(catalog.lookup(Function.class, "greeter")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "greeter"))) .isAssignableFrom(String.class); @@ -383,6 +384,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { } } + @SuppressWarnings("unchecked") @Test public void simpleFunction() { create(SimpleConfiguration.class); @@ -397,6 +399,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { .isEqualTo(inspector.getRegistration(function).getType()); } + @SuppressWarnings("unchecked") @Test public void simpleSupplier() { create(SimpleConfiguration.class); @@ -405,6 +408,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { assertThat(supplier.get().blockFirst()).isEqualTo("hello"); } + @SuppressWarnings("unchecked") @Test public void simpleConsumer() { create(SimpleConfiguration.class); @@ -419,8 +423,8 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void qualifiedBean() { create(QualifiedConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")).isNull(); - assertThat(catalog.>lookup(Function.class, "other")) + assertThat(catalog.lookup(Function.class, "function")).isNull(); + assertThat(catalog.lookup(Function.class, "other")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "other"))) .isEqualTo(String.class); @@ -430,9 +434,9 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void aliasBean() { create(AliasConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isNotNull(); - assertThat(catalog.>lookup(Function.class, "other")) + assertThat(catalog.lookup(Function.class, "other")) .isInstanceOf(Function.class); } @@ -440,10 +444,10 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void registrationBean() { create(RegistrationConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "function")).isNull(); - assertThat(catalog.>lookup(Function.class, "registration")) + assertThat(catalog.lookup(Function.class, "function")).isNull(); + assertThat(catalog.lookup(Function.class, "registration")) .isNull(); - assertThat(catalog.>lookup(Function.class, "other")) + assertThat(catalog.lookup(Function.class, "other")) .isInstanceOf(Function.class); } @@ -454,7 +458,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { "spring.cloud.function.compile.foos.inputType=String", "spring.cloud.function.compile.foos.outputType=String"); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "foos")) + assertThat(catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -470,7 +474,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { create(EmptyConfiguration.class, "spring.cloud.function.imports.foos.location=file:./target/foos.fun"); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "foos")) + assertThat(catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -483,7 +487,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { + "::set", "spring.cloud.function.compile.foos.type=consumer", "spring.cloud.function.compile.foos.inputType=String"); - assertThat(catalog.>lookup(Function.class, "foos")) + assertThat(catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -499,7 +503,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { "spring.cloud.function.compile.foos.lambda=f -> f.subscribe(" + getClass().getName() + "::set)", "spring.cloud.function.compile.foos.type=consumer"); - assertThat(catalog.>lookup(Consumer.class, "foos")) + assertThat(catalog.lookup(Consumer.class, "foos")) .isInstanceOf(Consumer.class); assertThat(inspector.getInputWrapper(catalog.lookup(Consumer.class, "foos"))) .isEqualTo(Flux.class); @@ -510,11 +514,12 @@ public class ContextFunctionCatalogAutoConfigurationTests { assertThat(ContextFunctionCatalogAutoConfigurationTests.value).isEqualTo("hello"); } + @SuppressWarnings("unchecked") @Test public void factoryBeanFunction() { create(FactoryBeanConfiguration.class); assertThat(this.context.getBean("function")).isInstanceOf(Function.class); - assertThat(this.catalog.>lookup(Function.class, "function")) + assertThat(this.catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); Function, Flux> f = this.catalog.lookup(Function.class, "function"); @@ -816,8 +821,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { protected static class RegistrationConfiguration { @Bean public FunctionRegistration> registration() { - return new FunctionRegistration>(function()) - .name("other"); + return new FunctionRegistration>(function(), "other"); } @Bean diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogInitializerTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogInitializerTests.java index afc8c93da..7e27c1807 100644 --- a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogInitializerTests.java +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogInitializerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2017 the original author or authors. + * Copyright 2017-2018 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. @@ -44,7 +44,7 @@ import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; /** - * @author Dave Syert + * @author Dave Syer * */ public class ContextFunctionCatalogInitializerTests { @@ -64,7 +64,7 @@ public class ContextFunctionCatalogInitializerTests { public void lookUps() { create(SimpleConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(FunctionRegistration.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); // TODO: support for function composition } @@ -73,7 +73,7 @@ public class ContextFunctionCatalogInitializerTests { public void missingType() { create(MissingTypeConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(FunctionRegistration.class); - assertThat(catalog.>lookup(Function.class, "function")) + assertThat(catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); // TODO: support for type inference from functional bean regsitrations } @@ -82,7 +82,7 @@ public class ContextFunctionCatalogInitializerTests { public void configurationFunction() { create(FunctionConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.>lookup(Function.class, "foos")) + assertThat(catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -96,7 +96,7 @@ public class ContextFunctionCatalogInitializerTests { public void dependencyInjection() { create(DependencyInjectionConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(FunctionRegistration.class); - assertThat(catalog.>lookup(Function.class, "foos")) + assertThat(catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); diff --git a/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/SingleEntryFunctionRegistry.java b/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/SingleEntryFunctionRegistry.java index 33de0e927..b398e25db 100644 --- a/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/SingleEntryFunctionRegistry.java +++ b/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/SingleEntryFunctionRegistry.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2017 the original author or authors. + * Copyright 2016-2018 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. @@ -37,7 +37,7 @@ public class SingleEntryFunctionRegistry implements FunctionRegistry { } @Override - public T lookup(Class type, String name) { + public T lookup(Class type, String name) { return this.name.equals(name) ? this.delegate.lookup(type, name) : null; }