Converter supports lambda and method references

Author: viviel

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/convert/ApplicationConversionService.java

@@ -16,11 +16,21 @@
 
 package org.springframework.boot.convert;
 
+import java.util.Collections;
 import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 
 import org.springframework.beans.factory.ListableBeanFactory;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.core.ResolvableType;
 import org.springframework.core.convert.ConversionService;
+import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.core.convert.converter.ConditionalConverter;
+import org.springframework.core.convert.converter.ConditionalGenericConverter;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.convert.converter.ConverterRegistry;
 import org.springframework.core.convert.converter.GenericConverter;
@@ -44,6 +54,7 @@
  * against registry instance.
  *
  * @author Phillip Webb
+ * @author 郭世雄 Viviel
  * @since 2.0.0
  */
 public class ApplicationConversionService extends FormattingConversionService {
@@ -157,17 +168,30 @@ public static void addApplicationFormatters(FormatterRegistry registry) {
 	 * @since 2.2.0
 	 */
 	public static void addBeans(FormatterRegistry registry, ListableBeanFactory beanFactory) {
-		Set<Object> beans = new LinkedHashSet<>();
-		beans.addAll(beanFactory.getBeansOfType(GenericConverter.class).values());
-		beans.addAll(beanFactory.getBeansOfType(Converter.class).values());
-		beans.addAll(beanFactory.getBeansOfType(Printer.class).values());
-		beans.addAll(beanFactory.getBeansOfType(Parser.class).values());
-		for (Object bean : beans) {
+		Set<Map.Entry<String, ?>> entries = new LinkedHashSet<>();
+		entries.addAll(beanFactory.getBeansOfType(GenericConverter.class).entrySet());
+		entries.addAll(beanFactory.getBeansOfType(Converter.class).entrySet());
+		entries.addAll(beanFactory.getBeansOfType(Printer.class).entrySet());
+		entries.addAll(beanFactory.getBeansOfType(Parser.class).entrySet());
+		for (Map.Entry<String, ?> entity : entries) {
+			Object bean = entity.getValue();
 			if (bean instanceof GenericConverter) {
 				registry.addConverter((GenericConverter) bean);
 			}
 			else if (bean instanceof Converter) {
-				registry.addConverter((Converter<?, ?>) bean);
+				if (beanFactory instanceof ConfigurableListableBeanFactory) {
+					ConverterAdapter adapter = getConverterAdapter((ConfigurableListableBeanFactory) beanFactory,
+							entity);
+					if (!Objects.isNull(adapter)) {
+						registry.addConverter(adapter);
+					}
+					else {
+						registry.addConverter((Converter<?, ?>) bean);
+					}
+				}
+				else {
+					registry.addConverter((Converter<?, ?>) bean);
+				}
 			}
 			else if (bean instanceof Formatter) {
 				registry.addFormatter((Formatter<?>) bean);
@@ -181,4 +205,87 @@ else if (bean instanceof Parser) {
 		}
 	}
 
+	private static ConverterAdapter getConverterAdapter(ConfigurableListableBeanFactory beanFactory,
+			Map.Entry<String, ?> beanEntity) {
+		BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanEntity.getKey());
+		ResolvableType resolvableType = beanDefinition.getResolvableType();
+		ResolvableType[] types = resolvableType.getGenerics();
+		if (types.length < 2) {
+			return null;
+		}
+		return new ConverterAdapter((Converter<?, ?>) beanEntity.getValue(), types[0], types[1]);
+	}
+
+	/**
+	 * Adapts a {@link Converter} to a {@link GenericConverter}.
+	 */
+	@SuppressWarnings("unchecked")
+	private static final class ConverterAdapter implements ConditionalGenericConverter {
+
+		private final Converter<Object, Object> converter;
+
+		private final ConvertiblePair typeInfo;
+
+		private final ResolvableType targetType;
+
+		ConverterAdapter(Converter<?, ?> converter, ResolvableType sourceType, ResolvableType targetType) {
+			this.converter = (Converter<Object, Object>) converter;
+			this.typeInfo = new ConvertiblePair(sourceType.toClass(), targetType.toClass());
+			this.targetType = targetType;
+		}
+
+		@Override
+		public Set<ConvertiblePair> getConvertibleTypes() {
+			return Collections.singleton(this.typeInfo);
+		}
+
+		@Override
+		public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
+			// Check raw type first...
+			if (this.typeInfo.getTargetType() != targetType.getObjectType()) {
+				return false;
+			}
+			// Full check for complex generic type match required?
+			ResolvableType rt = targetType.getResolvableType();
+			if (!(rt.getType() instanceof Class) && !rt.isAssignableFrom(this.targetType)
+					&& !this.targetType.hasUnresolvableGenerics()) {
+				return false;
+			}
+			return !(this.converter instanceof ConditionalConverter)
+					|| ((ConditionalConverter) this.converter).matches(sourceType, targetType);
+		}
+
+		@Override
+		public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
+			if (source == null) {
+				return convertNullSource(sourceType, targetType);
+			}
+			return this.converter.convert(source);
+		}
+
+		@Override
+		public String toString() {
+			return (this.typeInfo + " : " + this.converter);
+		}
+
+		/**
+		 * Template method to convert a {@code null} source.
+		 * <p>
+		 * The default implementation returns {@code null} or the Java 8
+		 * {@link java.util.Optional#empty()} instance if the target type is
+		 * {@code java.util.Optional}. Subclasses may override this to return custom
+		 * {@code null} objects for specific target types.
+		 * @param sourceType the source type to convert from
+		 * @param targetType the target type to convert to
+		 * @return the converted null object
+		 */
+		private Object convertNullSource(TypeDescriptor sourceType, TypeDescriptor targetType) {
+			if (targetType.getObjectType() == Optional.class) {
+				return Optional.empty();
+			}
+			return null;
+		}
+
+	}
+
 }

spring-boot-project/spring-boot/src/test/java/org/springframework/boot/convert/ApplicationConversionServiceTests.java

@@ -24,6 +24,8 @@
 
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.convert.converter.GenericConverter;
@@ -64,6 +66,26 @@ void addBeansWhenHasConverterBeanAddConverter() {
 		}
 	}
 
+	@Test
+	void addBeansWhenHasLambdaConverterBeanAddConverter() {
+		try (ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(
+				ExampleLambdaConverter.class)) {
+			ApplicationConversionService.addBeans(this.registry, context);
+			verify(this.registry).addConverter(context.getBean(Converter.class));
+			verifyNoMoreInteractions(this.registry);
+		}
+	}
+
+	@Test
+	void addBeansWhenHasMethodReferenceConverterBeanAddConverter() {
+		try (ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(
+				ExampleMethodReferenceConverter.class)) {
+			ApplicationConversionService.addBeans(this.registry, context);
+			verify(this.registry).addConverter(context.getBean(Converter.class));
+			verifyNoMoreInteractions(this.registry);
+		}
+	}
+
 	@Test
 	void addBeansWhenHasFormatterBeanAddsOnlyFormatter() {
 		try (ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(ExampleFormatter.class)) {
@@ -114,6 +136,26 @@ public Integer convert(String source) {
 
 	}
 
+	@Configuration
+	static class ExampleLambdaConverter {
+
+		@Bean
+		public Converter<String, Integer> converter() {
+			return e -> Integer.valueOf(e);
+		}
+
+	}
+
+	@Configuration
+	static class ExampleMethodReferenceConverter {
+
+		@Bean
+		public Converter<String, Integer> converter() {
+			return Integer::valueOf;
+		}
+
+	}
+
 	static class ExampleFormatter implements Formatter<Integer> {
 
 		@Override