BeanDefinitions: Mix instanceSupplier and props

Author: artembilan

spring-integration-core/src/main/java/org/springframework/integration/config/DefaultConfiguringBeanFactoryPostProcessor.java

@@ -16,18 +16,15 @@
 
 package org.springframework.integration.config;
 
-import java.util.Arrays;
 import java.util.Map;
 
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.beans.factory.config.BeanExpressionContext;
-import org.springframework.beans.factory.config.BeanExpressionResolver;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
-import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.core.type.MethodMetadata;
 import org.springframework.integration.channel.interceptor.GlobalChannelInterceptorWrapper;
@@ -50,13 +47,10 @@ public class GlobalChannelInterceptorInitializer implements IntegrationConfigura
 
 	private ConfigurableListableBeanFactory beanFactory;
 
-	private BeanExpressionContext beanExpressionContext;
-
 	@Override
 	public void initialize(ConfigurableListableBeanFactory beanFactory) throws BeansException {
 		this.beanFactory = beanFactory;
 		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
-		this.beanExpressionContext = new BeanExpressionContext(beanFactory, null);
 		for (String beanName : registry.getBeanDefinitionNames()) {
 			BeanDefinition beanDefinition = registry.getBeanDefinition(beanName);
 			if (beanDefinition instanceof AnnotatedBeanDefinition) {
@@ -71,44 +65,22 @@ public void initialize(ConfigurableListableBeanFactory beanFactory) throws Beans
 				}
 
 				if (!CollectionUtils.isEmpty(annotationAttributes)) {
-					Map<String, Object> attributes = annotationAttributes;
-					RootBeanDefinition channelInterceptorWrapper =
-							new RootBeanDefinition(GlobalChannelInterceptorWrapper.class,
-									() -> createGlobalChannelInterceptorWrapper(beanName, attributes));
+					BeanDefinitionBuilder builder =
+							BeanDefinitionBuilder.genericBeanDefinition(GlobalChannelInterceptorWrapper.class,
+											() -> createGlobalChannelInterceptorWrapper(beanName))
+									.addConstructorArgReference(beanName)
+									.addPropertyValue("patterns", annotationAttributes.get("patterns"))
+									.addPropertyValue("order", annotationAttributes.get("order"));
 
-					BeanDefinitionReaderUtils.registerWithGeneratedName(channelInterceptorWrapper, registry);
+					BeanDefinitionReaderUtils.registerWithGeneratedName(builder.getBeanDefinition(), registry);
 				}
 			}
 		}
 	}
 
-	private GlobalChannelInterceptorWrapper createGlobalChannelInterceptorWrapper(String interceptorBeanName,
-			Map<String, Object> annotationAttributes) {
-
+	private GlobalChannelInterceptorWrapper createGlobalChannelInterceptorWrapper(String interceptorBeanName) {
 		ChannelInterceptor interceptor = this.beanFactory.getBean(interceptorBeanName, ChannelInterceptor.class);
-		GlobalChannelInterceptorWrapper interceptorWrapper = new GlobalChannelInterceptorWrapper(interceptor);
-		String[] patterns =
-				Arrays.stream((String[]) annotationAttributes.get("patterns"))
-						.map(this::resolveEmbeddedValue)
-						.toArray(String[]::new);
-		interceptorWrapper.setPatterns(patterns);
-		interceptorWrapper.setOrder((Integer) annotationAttributes.get("order"));
-		return interceptorWrapper;
-	}
-
-	private String resolveEmbeddedValue(String value) {
-		String valueToReturn = this.beanFactory.resolveEmbeddedValue(value);
-		if (valueToReturn == null || !(valueToReturn.startsWith("#{") && value.endsWith("}"))) {
-			return valueToReturn;
-		}
-
-		BeanExpressionResolver beanExpressionResolver = this.beanFactory.getBeanExpressionResolver();
-		if (beanExpressionResolver != null) {
-			Object result = beanExpressionResolver.evaluate(valueToReturn, this.beanExpressionContext);
-			return result != null ? result.toString() : null;
-		}
-
-		return null;
+		return new GlobalChannelInterceptorWrapper(interceptor);
 	}
 
 }

spring-integration-core/src/main/java/org/springframework/integration/config/GlobalChannelInterceptorInitializer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2019 the original author or authors.
+ * Copyright 2014-2021 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.
@@ -45,6 +45,7 @@
  * to Consumer Endpoints are present.
  *
  * @author Artem Bilan
+ *
  * @since 4.1
  */
 public class IdempotentReceiverAutoProxyCreatorInitializer implements IntegrationConfigurationInitializer {
@@ -58,7 +59,7 @@ public class IdempotentReceiverAutoProxyCreatorInitializer implements Integratio
 	public void initialize(ConfigurableListableBeanFactory beanFactory) throws BeansException {
 		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
 
-		List<Map<String, String>> idempotentEndpointsMapping = new ManagedList<Map<String, String>>();
+		List<Map<String, String>> idempotentEndpointsMapping = new ManagedList<>();
 
 		for (String beanName : registry.getBeanDefinitionNames()) {
 			BeanDefinition beanDefinition = registry.getBeanDefinition(beanName);
@@ -69,7 +70,7 @@ public void initialize(ConfigurableListableBeanFactory beanFactory) throws Beans
 				String mapping = (String) value;
 				String[] endpoints = StringUtils.tokenizeToStringArray(mapping, ",");
 				for (String endpoint : endpoints) {
-					Map<String, String> idempotentEndpoint = new ManagedMap<String, String>();
+					Map<String, String> idempotentEndpoint = new ManagedMap<>();
 					idempotentEndpoint.put(beanName,
 							beanFactory.resolveEmbeddedValue(endpoint) + IntegrationConfigUtils.HANDLER_ALIAS_SUFFIX);
 					idempotentEndpointsMapping.add(idempotentEndpoint);
@@ -81,16 +82,19 @@ else if (beanDefinition instanceof AnnotatedBeanDefinition) {
 		}
 
 		if (!idempotentEndpointsMapping.isEmpty()) {
-			BeanDefinition bd = BeanDefinitionBuilder.rootBeanDefinition(IdempotentReceiverAutoProxyCreator.class)
-					.addPropertyValue("idempotentEndpointsMapping", idempotentEndpointsMapping)
-					.getBeanDefinition();
+			BeanDefinition bd =
+					BeanDefinitionBuilder.rootBeanDefinition(IdempotentReceiverAutoProxyCreator.class,
+									IdempotentReceiverAutoProxyCreator::new)
+							.addPropertyValue("idempotentEndpointsMapping", idempotentEndpointsMapping)
+							.getBeanDefinition();
 			registry.registerBeanDefinition(IDEMPOTENT_RECEIVER_AUTO_PROXY_CREATOR_BEAN_NAME, bd);
 		}
 	}
 
 	private void annotated(ConfigurableListableBeanFactory beanFactory,
 			List<Map<String, String>> idempotentEndpointsMapping, String beanName, BeanDefinition beanDefinition)
 			throws LinkageError {
+
 		if (beanDefinition.getSource() instanceof MethodMetadata) {
 			MethodMetadata beanMethod = (MethodMetadata) beanDefinition.getSource();
 			String annotationType = IdempotentReceiver.class.getName();
@@ -127,7 +131,7 @@ private void annotated(ConfigurableListableBeanFactory beanFactory,
 
 					String[] interceptors = (String[]) value;
 					for (String interceptor : interceptors) {
-						Map<String, String> idempotentEndpoint = new ManagedMap<String, String>();
+						Map<String, String> idempotentEndpoint = new ManagedMap<>();
 						idempotentEndpoint.put(interceptor, endpoint);
 						idempotentEndpointsMapping.add(idempotentEndpoint);
 					}

spring-integration-core/src/main/java/org/springframework/integration/config/IdempotentReceiverAutoProxyCreatorInitializer.java

@@ -59,8 +59,12 @@ public static void registerSpelFunctionBean(BeanDefinitionRegistry registry, Str
 	public static void registerSpelFunctionBean(BeanDefinitionRegistry registry, String functionId, Class<?> aClass,
 			String methodSignature) {
 
-		registry.registerBeanDefinition(functionId, new RootBeanDefinition(SpelFunctionFactoryBean.class,
-				() -> new SpelFunctionFactoryBean(aClass, methodSignature)));
+		BeanDefinitionBuilder builder =
+				BeanDefinitionBuilder.genericBeanDefinition(SpelFunctionFactoryBean.class,
+								() -> new SpelFunctionFactoryBean(aClass, methodSignature))
+						.addConstructorArgValue(aClass)
+						.addConstructorArgValue(methodSignature);
+		registry.registerBeanDefinition(functionId, builder.getBeanDefinition());
 	}
 
 	public static void autoCreateDirectChannel(String channelName, BeanDefinitionRegistry registry) {

spring-integration-core/src/main/java/org/springframework/integration/config/IntegrationConfigUtils.java

@@ -16,19 +16,16 @@
 
 package org.springframework.integration.config;
 
-import java.util.Arrays;
 import java.util.Map;
 
 import org.springframework.beans.factory.BeanDefinitionStoreException;
-import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
-import org.springframework.beans.factory.support.RootBeanDefinition;
-import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.integration.context.IntegrationContextUtils;
 import org.springframework.integration.history.MessageHistoryConfigurer;
-import org.springframework.util.StringUtils;
 
 /**
  * Registers the {@link MessageHistoryConfigurer} {@link org.springframework.beans.factory.config.BeanDefinition}
@@ -63,35 +60,14 @@ public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, B
 			patterns = (String) componentNamePatterns;
 		}
 
-		registry.registerBeanDefinition(IntegrationContextUtils.INTEGRATION_MESSAGE_HISTORY_CONFIGURER_BEAN_NAME,
-				new RootBeanDefinition(MessageHistoryConfigurer.class,
-						() -> createMessageHistoryConfigurer(registry, patterns)));
-	}
-
-	private MessageHistoryConfigurer createMessageHistoryConfigurer(BeanDefinitionRegistry registry, String patterns) {
-		MessageHistoryConfigurer messageHistoryConfigurer = new MessageHistoryConfigurer();
-		if (StringUtils.hasText(patterns)) {
-			ConfigurableBeanFactory beanFactory = null;
-			if (registry instanceof ConfigurableBeanFactory) {
-				beanFactory = (ConfigurableBeanFactory) registry;
-			}
-			else if (registry instanceof ConfigurableApplicationContext) {
-				beanFactory = ((ConfigurableApplicationContext) registry).getBeanFactory();
-			}
+		BeanDefinition messageHistoryConfigurer =
+				BeanDefinitionBuilder.genericBeanDefinition(MessageHistoryConfigurer.class,
+								MessageHistoryConfigurer::new)
+						.addPropertyValue("componentNamePatterns", patterns)
+						.getBeanDefinition();
 
-			String[] patternsToSet = StringUtils.delimitedListToStringArray(patterns, ",", " ");
-			if (beanFactory != null) {
-				patternsToSet =
-						Arrays.stream(patternsToSet)
-								.map(beanFactory::resolveEmbeddedValue)
-								.flatMap((pattern) ->
-										Arrays.stream(StringUtils.delimitedListToStringArray(pattern, ",", " ")))
-								.toArray(String[]::new);
-			}
-			messageHistoryConfigurer.setComponentNamePatterns(patternsToSet);
-		}
-
-		return messageHistoryConfigurer;
+		registry.registerBeanDefinition(IntegrationContextUtils.INTEGRATION_MESSAGE_HISTORY_CONFIGURER_BEAN_NAME,
+				messageHistoryConfigurer);
 	}
 
 }