Skip to content

Functional gateway bean definitions #3586

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jul 6, 2021
Merged

Functional gateway bean definitions #3586

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
202 changes: 135 additions & 67 deletions ...-core/src/main/java/org/springframework/integration/config/MessagingGatewayRegistrar.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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.
Expand All @@ -18,30 +18,39 @@

import java.beans.Introspector;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.Executor;
import java.util.stream.Collectors;

import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.config.EmbeddedValueResolver;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
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.ManagedMap;
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.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.common.LiteralExpression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.integration.annotation.AnnotationConstants;
import org.springframework.integration.annotation.MessagingGateway;
import org.springframework.integration.gateway.GatewayMethodMetadata;
import org.springframework.integration.gateway.GatewayProxyFactoryBean;
import org.springframework.integration.gateway.MethodArgsMessageMapper;
import org.springframework.integration.util.MessagingAnnotationUtils;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.MultiValueMap;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
Expand All @@ -58,6 +67,8 @@
*/
public class MessagingGatewayRegistrar implements ImportBeanDefinitionRegistrar {

private static final ExpressionParser EXPRESSION_PARSER = new SpelExpressionParser();

private static final String PROXY_DEFAULT_METHODS_ATTR = "proxyDefaultMethods";

@Override
Expand All @@ -72,11 +83,14 @@ public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, B
annotationAttributes.put("serviceInterface", importingClassMetadata.getClassName());
annotationAttributes.put(PROXY_DEFAULT_METHODS_ATTR,
"" + annotationAttributes.remove(PROXY_DEFAULT_METHODS_ATTR));
BeanDefinitionReaderUtils.registerBeanDefinition(parse(annotationAttributes), registry);
BeanDefinitionReaderUtils.registerBeanDefinition(gatewayProxyBeanDefinition(annotationAttributes, registry),
registry);
}
}

public BeanDefinitionHolder parse(Map<String, Object> gatewayAttributes) { // NOSONAR complexity
public BeanDefinitionHolder gatewayProxyBeanDefinition(Map<String, Object> gatewayAttributes,
BeanDefinitionRegistry registry) {

String defaultPayloadExpression = (String) gatewayAttributes.get("defaultPayloadExpression");

@SuppressWarnings("unchecked")
Expand All @@ -98,89 +112,143 @@ public BeanDefinitionHolder parse(Map<String, Object> gatewayAttributes) { // NO
Assert.state(!hasMapper || !hasDefaultHeaders,
"'defaultHeaders' are not allowed when a 'mapper' is provided");

BeanDefinitionBuilder gatewayProxyBuilder =
BeanDefinitionBuilder.genericBeanDefinition(GatewayProxyFactoryBean.class);

if (hasDefaultHeaders || hasDefaultPayloadExpression) {
BeanDefinitionBuilder methodMetadataBuilder =
BeanDefinitionBuilder.genericBeanDefinition(GatewayMethodMetadata.class);
ConfigurableBeanFactory beanFactory = obtainBeanFactory(registry);
EmbeddedValueResolver embeddedValueResolver = new EmbeddedValueResolver(beanFactory);
Class<?> serviceInterface = getServiceInterface((String) gatewayAttributes.get("serviceInterface"), beanFactory);

if (hasDefaultPayloadExpression) {
methodMetadataBuilder.addPropertyValue("payloadExpression",
BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class)
.addConstructorArgValue(defaultPayloadExpression)
.getBeanDefinition());
}
@SuppressWarnings("unchecked")
AbstractBeanDefinition beanDefinition = new RootBeanDefinition(GatewayProxyFactoryBean.class,
() -> {
GatewayProxyFactoryBean proxyFactoryBean = new GatewayProxyFactoryBean(serviceInterface);
if (StringUtils.hasText(defaultRequestChannel)) {
proxyFactoryBean.setDefaultRequestChannelName(defaultRequestChannel);
}
if (StringUtils.hasText(defaultReplyChannel)) {
proxyFactoryBean.setDefaultReplyChannelName(defaultReplyChannel);
}
if (StringUtils.hasText(errorChannel)) {
proxyFactoryBean.setErrorChannelName(errorChannel);
}
if (StringUtils.hasText(proxyDefaultMethods)) {
boolean actualProxyDefaultMethods =
Boolean.parseBoolean(embeddedValueResolver.resolveStringValue(proxyDefaultMethods));
proxyFactoryBean.setProxyDefaultMethods(actualProxyDefaultMethods);
}
if (StringUtils.hasText(mapper)) {
proxyFactoryBean.setMapper(beanFactory.getBean(mapper, MethodArgsMessageMapper.class));
}

if (hasDefaultHeaders) {
Map<String, Object> headerExpressions = new ManagedMap<>();
for (Map<String, Object> header : defaultHeaders) {
String headerValue = (String) header.get("value");
String headerExpression = (String) header.get("expression");
boolean hasValue = StringUtils.hasText(headerValue);
if (asyncExecutor == null || AnnotationConstants.NULL.equals(asyncExecutor)) {
proxyFactoryBean.setAsyncExecutor(null);
}
else if (StringUtils.hasText(asyncExecutor)) {
proxyFactoryBean.setAsyncExecutor(beanFactory.getBean(asyncExecutor, Executor.class));
}

if (hasValue == StringUtils.hasText(headerExpression)) {
throw new BeanDefinitionStoreException("exactly one of 'value' or 'expression' " +
"is required on a gateway's header.");
if (hasDefaultHeaders || hasDefaultPayloadExpression) {
GatewayMethodMetadata globalMethodMetadata =
createGlobalMethodMetadata(defaultPayloadExpression, defaultHeaders,
hasDefaultPayloadExpression, hasDefaultHeaders, embeddedValueResolver);
proxyFactoryBean.setGlobalMethodMetadata(globalMethodMetadata);
}

BeanDefinition expressionDef =
new RootBeanDefinition(hasValue ? LiteralExpression.class : ExpressionFactoryBean.class);
expressionDef.getConstructorArgumentValues()
.addGenericArgumentValue(hasValue ? headerValue : headerExpression);
Map<String, AbstractBeanDefinition> methodDefinitions =
(Map<String, AbstractBeanDefinition>) gatewayAttributes.get("methods");

headerExpressions.put((String) header.get("name"), expressionDef);
}
methodMetadataBuilder.addPropertyValue("headerExpressions", headerExpressions);
}
if (methodDefinitions != null) {
Map<String, GatewayMethodMetadata> methodMetadataMap =
methodDefinitions.entrySet()
.stream()
.collect(Collectors.toMap(Entry::getKey,
entry -> (GatewayMethodMetadata) entry.getValue().getInstanceSupplier().get()));

gatewayProxyBuilder.addPropertyValue("globalMethodMetadata", methodMetadataBuilder.getBeanDefinition());
}
proxyFactoryBean.setMethodMetadataMap(methodMetadataMap);
}

String actualDefaultRequestTimeout =
embeddedValueResolver.resolveStringValue(
(String) gatewayAttributes.get("defaultRequestTimeout"));
if (actualDefaultRequestTimeout != null) {
proxyFactoryBean.setDefaultRequestTimeoutExpressionString(actualDefaultRequestTimeout);
}
String actualDefaultReplyTimeout =
embeddedValueResolver.resolveStringValue(
(String) gatewayAttributes.get("defaultReplyTimeout"));
if (actualDefaultReplyTimeout != null) {
proxyFactoryBean.setDefaultReplyTimeoutExpressionString(actualDefaultReplyTimeout);
}
return proxyFactoryBean;
});

if (StringUtils.hasText(defaultRequestChannel)) {
gatewayProxyBuilder.addPropertyValue("defaultRequestChannelName", defaultRequestChannel);
}
if (StringUtils.hasText(defaultReplyChannel)) {
gatewayProxyBuilder.addPropertyValue("defaultReplyChannelName", defaultReplyChannel);
String id = (String) gatewayAttributes.get("name");
if (!StringUtils.hasText(id)) {
String serviceInterfaceName = serviceInterface.getName();
id = Introspector.decapitalize(serviceInterfaceName.substring(serviceInterfaceName.lastIndexOf('.') + 1));
}
if (StringUtils.hasText(errorChannel)) {
gatewayProxyBuilder.addPropertyValue("errorChannelName", errorChannel);

beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, serviceInterface);
return new BeanDefinitionHolder(beanDefinition, id);
}

private static ConfigurableBeanFactory obtainBeanFactory(BeanDefinitionRegistry registry) {
if (registry instanceof ConfigurableBeanFactory) {
return (ConfigurableBeanFactory) registry;
}
if (asyncExecutor == null || AnnotationConstants.NULL.equals(asyncExecutor)) {
gatewayProxyBuilder.addPropertyValue("asyncExecutor", null);
else if (registry instanceof ConfigurableApplicationContext) {
return ((ConfigurableApplicationContext) registry).getBeanFactory();
}
else if (StringUtils.hasText(asyncExecutor)) {
gatewayProxyBuilder.addPropertyReference("asyncExecutor", asyncExecutor);
throw new IllegalArgumentException("The provided 'BeanDefinitionRegistry' must be an instance " +
"of 'ConfigurableBeanFactory' or 'ConfigurableApplicationContext', but given is: "
+ registry.getClass());
}

private static Class<?> getServiceInterface(String serviceInterface, ConfigurableBeanFactory beanFactory) {
String actualServiceInterface = beanFactory.resolveEmbeddedValue(serviceInterface);
if (!StringUtils.hasText(actualServiceInterface)) {
return org.springframework.integration.gateway.RequestReplyExchanger.class;
}
if (StringUtils.hasText(mapper)) {
gatewayProxyBuilder.addPropertyReference("mapper", mapper);
try {
return ClassUtils.forName(actualServiceInterface, beanFactory.getBeanClassLoader());
}
if (StringUtils.hasText(proxyDefaultMethods)) {
gatewayProxyBuilder.addPropertyValue(PROXY_DEFAULT_METHODS_ATTR, proxyDefaultMethods);
catch (ClassNotFoundException ex) {
throw new BeanDefinitionStoreException("Cannot parse class for service interface", ex);
}
}

gatewayProxyBuilder.addPropertyValue("defaultRequestTimeoutExpressionString",
gatewayAttributes.get("defaultRequestTimeout"));
gatewayProxyBuilder.addPropertyValue("defaultReplyTimeoutExpressionString",
gatewayAttributes.get("defaultReplyTimeout"));
gatewayProxyBuilder.addPropertyValue("methodMetadataMap", gatewayAttributes.get("methods"));
private static GatewayMethodMetadata createGlobalMethodMetadata(String defaultPayloadExpression,
Map<String, Object>[] defaultHeaders, boolean hasDefaultPayloadExpression,
boolean hasDefaultHeaders, EmbeddedValueResolver embeddedValueResolver) {

GatewayMethodMetadata gatewayMethodMetadata = new GatewayMethodMetadata();

String serviceInterface = (String) gatewayAttributes.get("serviceInterface");
if (!StringUtils.hasText(serviceInterface)) {
serviceInterface = "org.springframework.integration.gateway.RequestReplyExchanger";
}
String id = (String) gatewayAttributes.get("name");
if (!StringUtils.hasText(id)) {
id = Introspector.decapitalize(serviceInterface.substring(serviceInterface.lastIndexOf('.') + 1));
if (hasDefaultPayloadExpression) {
String actualPayloadExpression = embeddedValueResolver.resolveStringValue(defaultPayloadExpression);
gatewayMethodMetadata.setPayloadExpression(EXPRESSION_PARSER.parseExpression(actualPayloadExpression));
}

gatewayProxyBuilder.addConstructorArgValue(serviceInterface);
if (hasDefaultHeaders) {
Map<String, Expression> headerExpressions = new HashMap<>();
for (Map<String, Object> header : defaultHeaders) {
String headerValue = (String) header.get("value");
String headerExpression = (String) header.get("expression");
boolean hasValue = StringUtils.hasText(headerValue);

AbstractBeanDefinition beanDefinition = gatewayProxyBuilder.getBeanDefinition();
beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, serviceInterface);
return new BeanDefinitionHolder(beanDefinition, id);
if (hasValue == StringUtils.hasText(headerExpression)) {
throw new BeanDefinitionStoreException("exactly one of 'value' or 'expression' " +
"is required on a gateway's header.");
}

Expression expression =
hasValue
? new LiteralExpression(embeddedValueResolver.resolveStringValue(headerValue))
: EXPRESSION_PARSER.parseExpression(
embeddedValueResolver.resolveStringValue(headerExpression));

headerExpressions.put((String) header.get("name"), expression);
}
gatewayMethodMetadata.setHeaderExpressions(headerExpressions);
}
return gatewayMethodMetadata;
}

/**
Expand Down
Loading