SpringCloud/spring-cloud-function
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

GH-364 Fix type discovery on Kotlin lambdas

Browse Source 
Added FunctionRegistration for each Kotlin lambdas with the correct types
Resolve #364
This commit is contained in:
Oleg Zhurakousky
2019-09-06 20:04:24 +02:00
parent 6c722e59ec
commit 11ac6cd679
4 changed files with 157 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

237
spring-cloud-function-kotlin/src/main/java/org/springframework/cloud/function/context/config/KotlinLambdaToFunctionAutoConfiguration.java
View File

@@ -16,17 +16,26 @@
package org.springframework.cloud.function.context.config;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import kotlin.Unit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.functions.Function2;
import kotlin.jvm.functions.Function3;
import kotlin.jvm.functions.Function4;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
@@ -34,10 +43,11 @@ import org.springframework.beans.factory.config.ConstructorArgumentValues;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.cloud.function.context.FunctionType;
import org.springframework.cloud.function.context.FunctionRegistration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.type.MethodMetadata;
import org.springframework.core.ResolvableType;
import org.springframework.util.ObjectUtils;
/**
* Configuration class which defines the required infrastructure to bootstrap Kotlin
@@ -52,11 +62,12 @@ class KotlinLambdaToFunctionAutoConfiguration {
protected final Log logger = LogFactory.getLog(getClass());
/**
* Will transform all discovered Kotlin's Function1 and Function0 lambdas to java
* Will transform all discovered Kotlin's Function lambdas to java
* Supplier, Function and Consumer, retaining the original Kotlin type
* characteristics. In other words the resulting bean could be cast to both java and
* kotlin types (i.e., java Function<I,O> vs. kotlin Function1<I,O>)
* characteristics.
*
* @return the bean factory post processor
*/
@Bean
@@ -69,134 +80,122 @@ class KotlinLambdaToFunctionAutoConfiguration {
String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
for (String beanDefinitionName : beanDefinitionNames) {
BeanDefinition beanDefinition = beanFactory
.getBeanDefinition(beanDefinitionName);
Object source = beanDefinition.getSource();
if (source instanceof MethodMetadata) {
String returnTypeName = ((MethodMetadata) source)
.getReturnTypeName();
if (returnTypeName.startsWith("kotlin.jvm.functions.Function")) {
FunctionType functionType = new FunctionType(
FunctionContextUtils.findType(beanDefinitionName,
beanFactory));
if (returnTypeName.equals("kotlin.jvm.functions.Function1")) {
if (Unit.class
.isAssignableFrom(functionType.getOutputType())) {
KotlinLambdaToFunctionAutoConfiguration.this.logger
.debug("Transforming Kotlin lambda "
+ beanDefinitionName
+ " to java Consumer");
this.register(beanDefinitionName, beanDefinition,
KotlinConsumer.class,
(BeanDefinitionRegistry) beanFactory);
}
else {
KotlinLambdaToFunctionAutoConfiguration.this.logger
.debug("Transforming Kotlin lambda "
+ beanDefinitionName
+ " to java Function");
this.register(beanDefinitionName, beanDefinition,
KotlinFunction.class,
(BeanDefinitionRegistry) beanFactory);
}
}
else {
KotlinLambdaToFunctionAutoConfiguration.this.logger.debug(
"Transforming Kotlin lambda " + beanDefinitionName
+ " to java Supplier");
this.register(beanDefinitionName, beanDefinition,
KotlinSupplier.class,
(BeanDefinitionRegistry) beanFactory);
}
}
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanDefinitionName);
ResolvableType rt = beanDefinition.getResolvableType();
if (rt.getType().getTypeName().startsWith("kotlin.jvm.functions.Function")) {
RootBeanDefinition cbd = new RootBeanDefinition(KotlinFunctionWrapper.class);
ConstructorArgumentValues ca = new ConstructorArgumentValues();
ca.addGenericArgumentValue(beanDefinition);
cbd.setConstructorArgumentValues(ca);
((BeanDefinitionRegistry) beanFactory).registerBeanDefinition("_" + beanDefinitionName, cbd);
}
}
}
private void register(String originalName, BeanDefinition originalDefinition,
Class<?> clazz, BeanDefinitionRegistry registry) {
RootBeanDefinition cbd = new RootBeanDefinition(clazz);
ConstructorArgumentValues ca = new ConstructorArgumentValues();
ca.addGenericArgumentValue(originalDefinition);
cbd.setConstructorArgumentValues(ca);
registry.removeBeanDefinition(originalName);
registry.registerBeanDefinition(originalName, cbd);
}
};
}
/**
* Wrapper for Kotlin lambda to be represented as both Java Function&lt;I,O&gt; as
* well as Kotlin's Function1&lt;I,O&gt;.
*/
private static final class KotlinFunction<I, O>
implements Function<I, O>, Function1<I, O> {
private final Function1<I, O> kotlinLambda;
@SuppressWarnings({ "unchecked", "rawtypes" })
private static final class KotlinFunctionWrapper implements Function<Object, Object>, Supplier<Object>, Consumer<Object[]>,
Function0<Object>, Function1<Object, Object>, Function2<Object, Object, Object>,
Function3<Object, Object, Object, Object>, Function4<Object, Object, Object, Object, Object>,
FactoryBean<FunctionRegistration>,
BeanNameAware,
BeanFactoryAware {
private KotlinFunction(Function1<I, O> kotlinLambda) {
this.kotlinLambda = kotlinLambda;
private final Object kotlinLambdaTarget;
private String name;
private ConfigurableListableBeanFactory beanFactory;
private KotlinFunctionWrapper(Object kotlinLambdaTarget) {
this.kotlinLambdaTarget = kotlinLambdaTarget;
}
@Override
public O apply(I i) {
return this.kotlinLambda.invoke(i);
public Object apply(Object input) {
if (ObjectUtils.isEmpty(input)) {
return this.invoke();
}
else if (ObjectUtils.isArray(input)) {
return null;
}
else {
return this.invoke(input);
}
}
@Override
public O invoke(I i) {
return this.apply(i);
public Object invoke(Object arg0, Object arg1, Object arg2, Object arg3) {
return ((Function4) this.kotlinLambdaTarget).invoke(arg0, arg1, arg2, arg3);
}
@Override
public Object invoke(Object arg0, Object arg1, Object arg2) {
return ((Function3) this.kotlinLambdaTarget).invoke(arg0, arg1, arg2);
}
@Override
public Object invoke(Object arg0, Object arg1) {
return ((Function2) this.kotlinLambdaTarget).invoke(arg0, arg1);
}
@Override
public Object invoke(Object arg0) {
return ((Function1) this.kotlinLambdaTarget).invoke(arg0);
}
@Override
public Object invoke() {
return ((Function0) this.kotlinLambdaTarget).invoke();
}
@Override
public void accept(Object[] input) {
this.apply(input);
}
@Override
public Object get() {
return this.apply(null);
}
@Override
public FunctionRegistration getObject() throws Exception {
Type functionType = FunctionContextUtils.findType(this.name.substring(1), this.beanFactory);
FunctionRegistration<?> registration = new FunctionRegistration<>(this, name);
Type[] types = ((ParameterizedType) functionType).getActualTypeArguments();
if (functionType.getTypeName().contains("Function0")) {
functionType = ResolvableType.forClassWithGenerics(Supplier.class, ResolvableType.forType(types[0]))
.getType();
}
else if (functionType.getTypeName().contains("Function1")) {
functionType = ResolvableType.forClassWithGenerics(Function.class, ResolvableType.forType(types[0]),
ResolvableType.forType(types[1])).getType();
}
else {
throw new UnsupportedOperationException("Multi argument Kotlin functions are not currently supported");
}
registration = registration.type(functionType);
return registration;
}
@Override
public Class<?> getObjectType() {
return FunctionRegistration.class;
}
@Override
public void setBeanName(String name) {
this.name = name;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}
}
/**
* Wrapper for Kotlin lambda to be represented as both Java Consumer&lt;I&gt; as well
* as Kotlin's Function1&lt;I,Unit&gt;.
*/
private static final class KotlinConsumer<I, U>
implements Consumer<I>, Function1<I, U> {
private final Function1<I, U> kotlinLambda;
private KotlinConsumer(Function1<I, U> kotlinLambda) {
this.kotlinLambda = kotlinLambda;
}
@Override
public U invoke(I i) {
return this.kotlinLambda.invoke(i);
}
@Override
public void accept(I i) {
this.kotlinLambda.invoke(i);
}
}
/**
* Wrapper for Kotlin lambda to be represented as both Java Supplier&lt;O&gt; as well
* as Kotlin's Function0&lt;O&gt;.
*/
private static final class KotlinSupplier<O> implements Supplier<O>, Function0<O> {
private final Function0<O> kotlinLambda;
private KotlinSupplier(Function0<O> kotlinLambda) {
this.kotlinLambda = kotlinLambda;
}
@Override
public O get() {
return this.invoke();
}
@Override
public O invoke() {
return this.kotlinLambda.invoke();
}
}
}

21
spring-cloud-function-kotlin/src/test/java/org/springframework/cloud/function/kotlin/ContextFunctionCatalogAutoConfigurationKotlinTests.java
View File

@@ -16,16 +16,13 @@
package org.springframework.cloud.function.kotlin;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import org.junit.After;
import org.junit.Ignore;
import org.junit.Test;
import reactor.core.publisher.Flux;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
@@ -57,12 +54,10 @@ public class ContextFunctionCatalogAutoConfigurationKotlinTests {
}
@Test
@Ignore
public void kotlinLambdas() {
create(new Class[] { KotlinLambdasConfiguration.class,
SimpleConfiguration.class });
assertThat(this.context.getBean("kotlinFunction")).isInstanceOf(Function.class);
assertThat(this.context.getBean("kotlinFunction")).isInstanceOf(Function1.class);
assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "kotlinFunction"))
.isInstanceOf(Function.class);
@@ -73,7 +68,6 @@ public class ContextFunctionCatalogAutoConfigurationKotlinTests {
.getOutputType(this.catalog.lookup(Function.class, "kotlinFunction")))
.isAssignableFrom(String.class);
assertThat(this.context.getBean("kotlinConsumer")).isInstanceOf(Consumer.class);
assertThat(this.context.getBean("kotlinConsumer")).isInstanceOf(Function1.class);
assertThat((Function<?, ?>) this.catalog.lookup(Function.class, "kotlinConsumer"))
.isInstanceOf(Function.class);
@@ -81,21 +75,24 @@ public class ContextFunctionCatalogAutoConfigurationKotlinTests {
.getInputType(this.catalog.lookup(Function.class, "kotlinConsumer")))
.isAssignableFrom(String.class);
assertThat(this.context.getBean("kotlinSupplier")).isInstanceOf(Supplier.class);
assertThat(this.context.getBean("kotlinSupplier")).isInstanceOf(Function0.class);
Supplier<Flux<String>> supplier = this.catalog.lookup(Supplier.class,
"kotlinSupplier");
assertThat(supplier.get().blockFirst()).isEqualTo("Hello");
Supplier<String> supplier = this.catalog.lookup(Supplier.class, "kotlinSupplier");
assertThat(supplier.get()).isEqualTo("Hello");
assertThat((Supplier<?>) this.catalog.lookup(Supplier.class, "kotlinSupplier"))
.isInstanceOf(Supplier.class);
assertThat(this.inspector
.getOutputType(this.catalog.lookup(Supplier.class, "kotlinSupplier")))
.isAssignableFrom(String.class);
Function<Flux<String>, Flux<String>> function = this.catalog
Function<String, String> function = this.catalog
.lookup(Function.class, "kotlinFunction|function2");
assertThat(function.apply(Flux.just("Hello")).blockFirst())
assertThat(function.apply("Hello"))
.isEqualTo("HELLOfunction2");
Function<String, String> javaFunction = this.catalog
.lookup(Function.class, "javaFunction");
assertThat(javaFunction.apply("Hello"))
.isEqualTo("Hello");
}
private void create(Class<?>[] types, String... props) {

6
spring-cloud-function-kotlin/src/test/kotlin/org/springframework/cloud/function/kotlin/KotlinLambdasConfiguration.kt
View File

@@ -19,6 +19,7 @@ package org.springframework.cloud.function.kotlin
import org.springframework.boot.autoconfigure.EnableAutoConfiguration
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import java.util.function.Function
/**
* @author Oleg Zhurakousky
@@ -41,4 +42,9 @@ open class KotlinLambdasConfiguration {
open fun kotlinSupplier(): () -> String {
return { "Hello" }
}
@Bean
open fun javaFunction(): Function<String, String> {
return Function { x -> x }
}
}