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

GH-235 Moved Kotlin support to a separate module

Browse Source 
Resolves #235
This commit is contained in:
Oleg Zhurakousky
2018-11-30 18:47:36 +01:00
parent f0f957b96a
commit 6a16a44aa0
10 changed files with 214 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,177 +0,0 @@
/*
* Copyright 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.
* 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.config;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.type.MethodMetadata;
import kotlin.Unit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
/**
* Configuration class which defines the required infrastructure to bootstrap Kotlin
* lambdas as invocable functions within the context of the framework.
*
* @author Oleg Zhurakousky
*
* @since 2.0
*/
@Configuration
@ConditionalOnClass(name = "kotlin.jvm.functions.Function1")
class KotlinLambdaToFunctionAutoConfiguration {
protected final Log logger = LogFactory.getLog(getClass());
/**
* Will transform all discovered Kotlin's Function1 and Function0 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>)
*/
@Bean
public BeanFactoryPostProcessor kotlinToFunctionTransformer() {
return new BeanFactoryPostProcessor() {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
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())) {
logger.debug("Transforming Kotlin lambda " + beanDefinitionName + " to java Consumer");
this.register(beanDefinitionName, beanDefinition, KotlinConsumer.class, (BeanDefinitionRegistry) beanFactory);
}
else {
logger.debug("Transforming Kotlin lambda " + beanDefinitionName + " to java Function");
this.register(beanDefinitionName, beanDefinition, KotlinFunction.class, (BeanDefinitionRegistry) beanFactory);
}
}
else {
logger.debug("Transforming Kotlin lambda " + beanDefinitionName + " to java Supplier");
this.register(beanDefinitionName, beanDefinition, KotlinSupplier.class, (BeanDefinitionRegistry) beanFactory);
}
}
}
}
}
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<I,O> as well as
* Kotlin's Function1<I,O>
*/
private static class KotlinFunction<I, O> implements Function<I, O>, Function1<I, O> {
private final Function1<I, O> kotlinLambda;
private KotlinFunction(Function1<I, O> kotlinLambda) {
this.kotlinLambda = kotlinLambda;
}
@Override
public O apply(I i) {
return this.kotlinLambda.invoke(i);
}
@Override
public O invoke(I i) {
return this.apply(i);
}
}
/**
* Wrapper for Kotlin lambda to be represented as both Java Consumer<I> as well as
* Kotlin's Function1<I,Unit>
*/
private static 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<O> as well as
* Kotlin's Function0<O>
*/
private static 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();
}
}
}

3
spring-cloud-function-context/src/main/resources/META-INF/spring.factories
View File

@@ -1,6 +1,5 @@
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.function.context.config.ContextFunctionCatalogAutoConfiguration,\
org.springframework.cloud.function.context.config.KotlinLambdaToFunctionAutoConfiguration
org.springframework.cloud.function.context.config.ContextFunctionCatalogAutoConfiguration
org.springframework.cloud.function.context.WrapperDetector=\
org.springframework.cloud.function.context.config.FluxWrapperDetector

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

@@ -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.
@@ -28,7 +28,6 @@ import java.util.function.Supplier;
import java.util.stream.Collectors;
import org.junit.After;
import org.junit.Ignore;
import org.junit.Test;
import org.reactivestreams.Publisher;
@@ -67,15 +66,13 @@ import org.springframework.util.StreamUtils;
import static org.assertj.core.api.Assertions.assertThat;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
* @author Dave Syer
* @author Artem Bilan
*
* @author Oleg Zhurakousky
*/
public class ContextFunctionCatalogAutoConfigurationTests {
@@ -376,47 +373,6 @@ public class ContextFunctionCatalogAutoConfigurationTests {
}
}
@Test
@Ignore("Cannot make this work in Eclipse (since the tools upgraded to 0.8.9)")
public void kotlinLambdas() {
create("org.springframework.cloud.function.context.config.KotlinLambdasConfiguration",
new Class[] { SimpleConfiguration.class });
assertThat(context.getBean("kotlinFunction")).isInstanceOf(Function.class);
assertThat(context.getBean("kotlinFunction")).isInstanceOf(Function1.class);
assertThat((Function<?, ?>) catalog.lookup(Function.class, "kotlinFunction"))
.isInstanceOf(Function.class);
assertThat(
inspector.getInputType(catalog.lookup(Function.class, "kotlinFunction")))
.isAssignableFrom(String.class);
assertThat(
inspector.getOutputType(catalog.lookup(Function.class, "kotlinFunction")))
.isAssignableFrom(String.class);
assertThat(context.getBean("kotlinConsumer")).isInstanceOf(Consumer.class);
assertThat(context.getBean("kotlinConsumer")).isInstanceOf(Function1.class);
assertThat((Function<?, ?>) catalog.lookup(Function.class, "kotlinConsumer"))
.isInstanceOf(Function.class);
assertThat(
inspector.getInputType(catalog.lookup(Function.class, "kotlinConsumer")))
.isAssignableFrom(String.class);
assertThat(context.getBean("kotlinSupplier")).isInstanceOf(Supplier.class);
assertThat(context.getBean("kotlinSupplier")).isInstanceOf(Function0.class);
Supplier<Flux<String>> supplier = catalog.lookup(Supplier.class,
"kotlinSupplier");
assertThat(supplier.get().blockFirst()).isEqualTo("Hello");
assertThat((Supplier<?>) catalog.lookup(Supplier.class, "kotlinSupplier"))
.isInstanceOf(Supplier.class);
assertThat(
inspector.getOutputType(catalog.lookup(Supplier.class, "kotlinSupplier")))
.isAssignableFrom(String.class);
Function<Flux<String>, Flux<String>> function = catalog.lookup(Function.class,
"kotlinFunction|function2");
assertThat(function.apply(Flux.just("Hello")).blockFirst())
.isEqualTo("HELLOfunction2");
}
private void create(String jarfile, Class<?> config, String... props) {
try {
@@ -572,13 +528,6 @@ public class ContextFunctionCatalogAutoConfigurationTests {
create(new Class<?>[] { type }, props);
}
private void create(String typeName, Class<?>[] types, String... props) {
Class<?>[] typesToUse = new Class<?>[types.length + 1];
typesToUse[0] = ClassUtils.resolveClassName(typeName, null);
System.arraycopy(types, 0, typesToUse, 1, types.length);
create(typesToUse, props);
}
private void create(Class<?>[] types, String... props) {
context = new SpringApplicationBuilder(types).properties(props).run();
catalog = context.getBean(FunctionCatalog.class);

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

@@ -1,44 +0,0 @@
/*
* Copyright 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.
* 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.kotlin
import org.springframework.boot.autoconfigure.EnableAutoConfiguration
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
/**
* @author Oleg Zhurakousky
*
*/
@EnableAutoConfiguration
@Configuration
open class KotlinLambdasConfiguration {
@Bean
open fun kotlinFunction(): (String) -> String {
return { it.toUpperCase() }
}
@Bean
open fun kotlinConsumer(): (String) -> Unit {
return { println(it) }
}
@Bean
open fun kotlinSupplier(): () -> String {
return { "Hello" }
}
}