Deffer Messaging annotations process

The `AbstractMethodAnnotationPostProcessor` and its implementations
have a `beanFactory.getBean()` call for the `@Bean` methods with
Messaging annotations.
This is done, actually, from the
`MessagingAnnotationPostProcessor.postProcessAfterInitialization()`
which might be still too early in some scenarios, like Spring Cloud Feign
with its child application contexts being initialized from the
`FeignClientFactoryBean`, causing a `BeanCurrentlyInCreationException`

See https://stackoverflow.com/questions/54887963/beancurrentlyincreationexception-when-using-spring-integration-with-spring-cloud

* Implement a `SmartInitializingSingleton` for the `MessagingAnnotationPostProcessor`
and gather `Runnable` wrappers for newly introduced `postProcessMethodAndRegisterEndpointIfAny()`
to be called later in the `afterSingletonsInstantiated()` when context is
still in the initialization phase.
All runtime-registered beans are going to be processed normally from the
regular `postProcessAfterInitialization()`

Author: artembilan

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -18,6 +18,7 @@
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -36,6 +37,7 @@
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.SmartInitializingSingleton;
 import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
@@ -71,7 +73,8 @@
  * @author Gary Russell
  * @author Rick Hogge
  */
-public class MessagingAnnotationPostProcessor implements BeanPostProcessor, BeanFactoryAware, InitializingBean {
+public class MessagingAnnotationPostProcessor implements BeanPostProcessor, BeanFactoryAware, InitializingBean,
+		SmartInitializingSingleton {
 
 	protected final Log logger = LogFactory.getLog(this.getClass()); // NOSONAR
 
@@ -81,6 +84,10 @@ public class MessagingAnnotationPostProcessor implements BeanPostProcessor, Bean
 
 	private final Set<Class<?>> noAnnotationsCache = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
 
+	private final List<Runnable> methodsToPostProcessAfterContextInitialization = new ArrayList<>();
+
+	private volatile boolean initialized;
+
 	@Override
 	public void setBeanFactory(BeanFactory beanFactory) {
 		Assert.isAssignable(ConfigurableListableBeanFactory.class, beanFactory.getClass(),
@@ -125,6 +132,12 @@ public <A extends Annotation> void addMessagingAnnotationPostProcessor(Class<A>
 		this.postProcessors.put(annotation, postProcessor);
 	}
 
+	@Override
+	public void afterSingletonsInstantiated() {
+		this.initialized = true;
+		this.methodsToPostProcessAfterContextInitialization.forEach(Runnable::run);
+	}
+
 	@Override
 	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
 		return bean;
@@ -173,6 +186,7 @@ public Object postProcessAfterInitialization(final Object bean, final String bea
 
 	protected void processAnnotationTypeOnMethod(Object bean, String beanName, Method method,
 			Class<? extends Annotation> annotationType, List<Annotation> annotations) {
+
 		MethodAnnotationPostProcessor<?> postProcessor =
 				MessagingAnnotationPostProcessor.this.postProcessors.get(annotationType);
 		if (postProcessor != null && postProcessor.shouldCreateEndpoint(method, annotations)) {
@@ -187,36 +201,53 @@ protected void processAnnotationTypeOnMethod(Object bean, String beanName, Metho
 							+ "and its method: '" + method + "'", e);
 				}
 			}
-			Object result = postProcessor.postProcess(bean, beanName, targetMethod, annotations);
-			if (result != null && result instanceof AbstractEndpoint) {
-				AbstractEndpoint endpoint = (AbstractEndpoint) result;
-				String autoStartup = MessagingAnnotationUtils.resolveAttribute(annotations, "autoStartup",
-						String.class);
+
+			if (this.initialized) {
+				postProcessMethodAndRegisterEndpointIfAny(bean, beanName, method, annotationType, annotations,
+						postProcessor, targetMethod);
+			}
+			else {
+				Method methodToPostProcess = targetMethod;
+				this.methodsToPostProcessAfterContextInitialization.add(() ->
+						postProcessMethodAndRegisterEndpointIfAny(bean, beanName, method, annotationType, annotations,
+								postProcessor, methodToPostProcess));
+			}
+		}
+	}
+
+	private void postProcessMethodAndRegisterEndpointIfAny(Object bean, String beanName, Method method,
+			Class<? extends Annotation> annotationType, List<Annotation> annotations,
+			MethodAnnotationPostProcessor<?> postProcessor, Method targetMethod) {
+
+		Object result = postProcessor.postProcess(bean, beanName, targetMethod, annotations);
+		if (result instanceof AbstractEndpoint) {
+			AbstractEndpoint endpoint = (AbstractEndpoint) result;
+			String autoStartup = MessagingAnnotationUtils.resolveAttribute(annotations, "autoStartup",
+					String.class);
+			if (StringUtils.hasText(autoStartup)) {
+				autoStartup = getBeanFactory().resolveEmbeddedValue(autoStartup);
 				if (StringUtils.hasText(autoStartup)) {
-					autoStartup = getBeanFactory().resolveEmbeddedValue(autoStartup);
-					if (StringUtils.hasText(autoStartup)) {
-						endpoint.setAutoStartup(Boolean.parseBoolean(autoStartup));
-					}
+					endpoint.setAutoStartup(Boolean.parseBoolean(autoStartup));
 				}
+			}
 
-				String phase = MessagingAnnotationUtils.resolveAttribute(annotations, "phase", String.class);
+			String phase = MessagingAnnotationUtils.resolveAttribute(annotations, "phase", String.class);
+			if (StringUtils.hasText(phase)) {
+				phase = getBeanFactory().resolveEmbeddedValue(phase);
 				if (StringUtils.hasText(phase)) {
-					phase = getBeanFactory().resolveEmbeddedValue(phase);
-					if (StringUtils.hasText(phase)) {
-						endpoint.setPhase(Integer.parseInt(phase));
-					}
-				}
-
-				Role role = AnnotationUtils.findAnnotation(method, Role.class);
-				if (role != null) {
-					endpoint.setRole(role.value());
+					endpoint.setPhase(Integer.parseInt(phase));
 				}
+			}
 
-				String endpointBeanName = generateBeanName(beanName, method, annotationType);
-				endpoint.setBeanName(endpointBeanName);
-				getBeanFactory().registerSingleton(endpointBeanName, endpoint);
-				getBeanFactory().initializeBean(endpoint, endpointBeanName);
+			Role role = AnnotationUtils.findAnnotation(method, Role.class);
+			if (role != null) {
+				endpoint.setRole(role.value());
 			}
+
+			String endpointBeanName = generateBeanName(beanName, method, annotationType);
+			endpoint.setBeanName(endpointBeanName);
+			getBeanFactory().registerSingleton(endpointBeanName, endpoint);
+			getBeanFactory().initializeBean(endpoint, endpointBeanName);
 		}
 	}