Examples with ManagedMap org.springframework.beans.factory.support.ManagedMap used on opensource projects

Example 41 with ManagedMap

use of org.springframework.beans.factory.support.ManagedMap in project spring-integration by spring-projects.

the class EnricherParser method parseHandler.

@Override
protected BeanDefinitionBuilder parseHandler(Element element, ParserContext parserContext) {
    final BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(ContentEnricher.class);
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "request-channel");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "reply-channel");
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, "error-channel");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "request-timeout");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "reply-timeout");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "requires-reply");
    List<Element> subElements = DomUtils.getChildElementsByTagName(element, "property");
    if (!CollectionUtils.isEmpty(subElements)) {
        ManagedMap<String, Object> expressions = new ManagedMap<String, Object>();
        ManagedMap<String, Object> nullResultExpressions = new ManagedMap<String, Object>();
        for (Element subElement : subElements) {
            String name = subElement.getAttribute("name");
            String value = subElement.getAttribute("value");
            String type = subElement.getAttribute("type");
            String expression = subElement.getAttribute("expression");
            String nullResultExpression = subElement.getAttribute("null-result-expression");
            boolean hasAttributeValue = StringUtils.hasText(value);
            boolean hasAttributeExpression = StringUtils.hasText(expression);
            boolean hasAttributeNullResultExpression = StringUtils.hasText(nullResultExpression);
            if (hasAttributeValue && hasAttributeExpression) {
                parserContext.getReaderContext().error("Only one of 'value' or 'expression' is allowed", element);
            }
            if (!hasAttributeValue && !hasAttributeExpression && !hasAttributeNullResultExpression) {
                parserContext.getReaderContext().error("One of 'value' or 'expression' or 'null-result-expression' is required", element);
            }
            BeanDefinition expressionDef = null;
            BeanDefinition nullResultExpressionExpressionDef;
            if (hasAttributeValue) {
                BeanDefinitionBuilder expressionBuilder = BeanDefinitionBuilder.genericBeanDefinition(ValueExpression.class);
                if (StringUtils.hasText(type)) {
                    expressionBuilder.addConstructorArgValue(new TypedStringValue(value, type));
                } else {
                    expressionBuilder.addConstructorArgValue(value);
                }
                expressionDef = expressionBuilder.getBeanDefinition();
            } else if (hasAttributeExpression) {
                if (StringUtils.hasText(type)) {
                    parserContext.getReaderContext().error("The 'type' attribute for '<property>' of '<enricher>' " + "is not allowed with an 'expression' attribute.", element);
                }
                expressionDef = BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class).addConstructorArgValue(expression).getBeanDefinition();
            }
            if (expressionDef != null) {
                expressions.put(name, expressionDef);
            }
            if (hasAttributeNullResultExpression) {
                nullResultExpressionExpressionDef = BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class).addConstructorArgValue(nullResultExpression).getBeanDefinition();
                nullResultExpressions.put(name, nullResultExpressionExpressionDef);
            }
        }
        if (expressions.size() > 0) {
            builder.addPropertyValue("propertyExpressions", expressions);
        }
        if (nullResultExpressions.size() > 0) {
            builder.addPropertyValue("nullResultPropertyExpressions", nullResultExpressions);
        }
    }
    subElements = DomUtils.getChildElementsByTagName(element, "header");
    if (!CollectionUtils.isEmpty(subElements)) {
        ManagedMap<String, Object> expressions = new ManagedMap<String, Object>();
        ManagedMap<String, Object> nullResultHeaderExpressions = new ManagedMap<String, Object>();
        for (Element subElement : subElements) {
            String name = subElement.getAttribute("name");
            String nullResultHeaderExpression = subElement.getAttribute("null-result-expression");
            String valueElementValue = subElement.getAttribute("value");
            String expressionElementValue = subElement.getAttribute("expression");
            boolean hasAttributeValue = StringUtils.hasText(valueElementValue);
            boolean hasAttributeExpression = StringUtils.hasText(expressionElementValue);
            boolean hasAttributeNullResultExpression = StringUtils.hasText(nullResultHeaderExpression);
            if (hasAttributeValue && hasAttributeExpression) {
                parserContext.getReaderContext().error("Only one of '" + "value" + "' or '" + "expression" + "' is allowed", subElement);
            }
            if (!hasAttributeValue && !hasAttributeExpression && !hasAttributeNullResultExpression) {
                parserContext.getReaderContext().error("One of 'value' or 'expression' or 'null-result-expression' is required", subElement);
            }
            BeanDefinition expressionDef = null;
            if (hasAttributeValue) {
                expressionDef = new RootBeanDefinition(LiteralExpression.class);
                expressionDef.getConstructorArgumentValues().addGenericArgumentValue(valueElementValue);
            } else if (hasAttributeExpression) {
                expressionDef = IntegrationNamespaceUtils.createExpressionDefIfAttributeDefined("expression", subElement);
            }
            if (StringUtils.hasText(subElement.getAttribute("expression")) && StringUtils.hasText(subElement.getAttribute("type"))) {
                parserContext.getReaderContext().warning("The use of a 'type' attribute is deprecated since 4.0 " + "when using 'expression'", subElement);
            }
            if (expressionDef != null) {
                BeanDefinitionBuilder valueProcessorBuilder = BeanDefinitionBuilder.genericBeanDefinition(ExpressionEvaluatingHeaderValueMessageProcessor.class).addConstructorArgValue(expressionDef).addConstructorArgValue(subElement.getAttribute("type"));
                IntegrationNamespaceUtils.setValueIfAttributeDefined(valueProcessorBuilder, subElement, "overwrite");
                expressions.put(name, valueProcessorBuilder.getBeanDefinition());
            }
            if (hasAttributeNullResultExpression) {
                BeanDefinition nullResultExpressionDefinition = IntegrationNamespaceUtils.createExpressionDefIfAttributeDefined("null-result-expression", subElement);
                BeanDefinitionBuilder nullResultValueProcessorBuilder = BeanDefinitionBuilder.genericBeanDefinition(ExpressionEvaluatingHeaderValueMessageProcessor.class).addConstructorArgValue(nullResultExpressionDefinition).addConstructorArgValue(subElement.getAttribute("type"));
                IntegrationNamespaceUtils.setValueIfAttributeDefined(nullResultValueProcessorBuilder, subElement, "overwrite");
                nullResultHeaderExpressions.put(name, nullResultValueProcessorBuilder.getBeanDefinition());
            }
        }
        if (expressions.size() > 0) {
            builder.addPropertyValue("headerExpressions", expressions);
        }
        if (nullResultHeaderExpressions.size() > 0) {
            builder.addPropertyValue("nullResultHeaderExpressions", nullResultHeaderExpressions);
        }
    }
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "should-clone-payload");
    String requestPayloadExpression = element.getAttribute("request-payload-expression");
    if (StringUtils.hasText(requestPayloadExpression)) {
        BeanDefinitionBuilder expressionBuilder = BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class).addConstructorArgValue(requestPayloadExpression);
        builder.addPropertyValue("requestPayloadExpression", expressionBuilder.getBeanDefinition());
    }
    return builder;
}

Example 42 with ManagedMap

use of org.springframework.beans.factory.support.ManagedMap in project spring-integration by spring-projects.

the class MessagingGatewayRegistrar method parse.

public BeanDefinitionHolder parse(Map<String, Object> gatewayAttributes) {
    String defaultPayloadExpression = (String) gatewayAttributes.get("defaultPayloadExpression");
    @SuppressWarnings("unchecked") Map<String, Object>[] defaultHeaders = (Map<String, Object>[]) gatewayAttributes.get("defaultHeaders");
    String defaultRequestChannel = (String) gatewayAttributes.get("defaultRequestChannel");
    String defaultReplyChannel = (String) gatewayAttributes.get("defaultReplyChannel");
    String errorChannel = (String) gatewayAttributes.get("errorChannel");
    String asyncExecutor = (String) gatewayAttributes.get("asyncExecutor");
    String mapper = (String) gatewayAttributes.get("mapper");
    boolean hasMapper = StringUtils.hasText(mapper);
    boolean hasDefaultPayloadExpression = StringUtils.hasText(defaultPayloadExpression);
    Assert.state(!hasMapper || !hasDefaultPayloadExpression, "'defaultPayloadExpression' is not allowed when a 'mapper' is provided");
    boolean hasDefaultHeaders = !ObjectUtils.isEmpty(defaultHeaders);
    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);
        if (hasDefaultPayloadExpression) {
            methodMetadataBuilder.addPropertyValue("payloadExpression", defaultPayloadExpression);
        }
        Map<String, Object> headerExpressions = new ManagedMap<String, Object>();
        for (Map<String, Object> header : defaultHeaders) {
            String headerValue = (String) header.get("value");
            String headerExpression = (String) header.get("expression");
            boolean hasValue = StringUtils.hasText(headerValue);
            if (hasValue == StringUtils.hasText(headerExpression)) {
                throw new BeanDefinitionStoreException("exactly one of 'value' or 'expression' " + "is required on a gateway's header.");
            }
            BeanDefinition expressionDef = new RootBeanDefinition(hasValue ? LiteralExpression.class : ExpressionFactoryBean.class);
            expressionDef.getConstructorArgumentValues().addGenericArgumentValue(hasValue ? headerValue : headerExpression);
            headerExpressions.put((String) header.get("name"), expressionDef);
        }
        methodMetadataBuilder.addPropertyValue("headerExpressions", headerExpressions);
        gatewayProxyBuilder.addPropertyValue("globalMethodMetadata", methodMetadataBuilder.getBeanDefinition());
    }
    if (StringUtils.hasText(defaultRequestChannel)) {
        gatewayProxyBuilder.addPropertyValue("defaultRequestChannelName", defaultRequestChannel);
    }
    if (StringUtils.hasText(defaultReplyChannel)) {
        gatewayProxyBuilder.addPropertyValue("defaultReplyChannelName", defaultReplyChannel);
    }
    if (StringUtils.hasText(errorChannel)) {
        gatewayProxyBuilder.addPropertyValue("errorChannelName", errorChannel);
    }
    if (asyncExecutor == null || AnnotationConstants.NULL.equals(asyncExecutor)) {
        gatewayProxyBuilder.addPropertyValue("asyncExecutor", null);
    } else if (StringUtils.hasText(asyncExecutor)) {
        gatewayProxyBuilder.addPropertyReference("asyncExecutor", asyncExecutor);
    }
    if (StringUtils.hasText(mapper)) {
        gatewayProxyBuilder.addPropertyReference("mapper", mapper);
    }
    gatewayProxyBuilder.addPropertyValue("defaultRequestTimeoutExpressionString", gatewayAttributes.get("defaultRequestTimeout"));
    gatewayProxyBuilder.addPropertyValue("defaultReplyTimeoutExpressionString", gatewayAttributes.get("defaultReplyTimeout"));
    gatewayProxyBuilder.addPropertyValue("methodMetadataMap", gatewayAttributes.get("methods"));
    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));
    }
    gatewayProxyBuilder.addConstructorArgValue(serviceInterface);
    AbstractBeanDefinition beanDefinition = gatewayProxyBuilder.getBeanDefinition();
    beanDefinition.addMetadataAttribute(new BeanMetadataAttribute(IntegrationConfigUtils.FACTORY_BEAN_OBJECT_TYPE, serviceInterface));
    return new BeanDefinitionHolder(beanDefinition, id);
}

Example 43 with ManagedMap

use of org.springframework.beans.factory.support.ManagedMap in project spring-integration by spring-projects.

the class IdempotentReceiverAutoProxyCreatorInitializer method initialize.

@Override
public void initialize(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    List<Map<String, String>> idempotentEndpointsMapping = new ManagedList<Map<String, String>>();
    for (String beanName : registry.getBeanDefinitionNames()) {
        BeanDefinition beanDefinition = registry.getBeanDefinition(beanName);
        if (IdempotentReceiverInterceptor.class.getName().equals(beanDefinition.getBeanClassName())) {
            Object value = beanDefinition.removeAttribute(IDEMPOTENT_ENDPOINTS_MAPPING);
            Assert.isInstanceOf(String.class, value, "The 'mapping' of BeanDefinition 'IDEMPOTENT_ENDPOINTS_MAPPING' must be String.");
            String mapping = (String) value;
            String[] endpoints = StringUtils.tokenizeToStringArray(mapping, ",");
            for (String endpoint : endpoints) {
                Map<String, String> idempotentEndpoint = new ManagedMap<String, String>();
                idempotentEndpoint.put(beanName, beanFactory.resolveEmbeddedValue(endpoint) + IntegrationConfigUtils.HANDLER_ALIAS_SUFFIX);
                idempotentEndpointsMapping.add(idempotentEndpoint);
            }
        } else if (beanDefinition instanceof AnnotatedBeanDefinition) {
            if (beanDefinition.getSource() instanceof MethodMetadata) {
                MethodMetadata beanMethod = (MethodMetadata) beanDefinition.getSource();
                String annotationType = IdempotentReceiver.class.getName();
                if (beanMethod.isAnnotated(annotationType)) {
                    Object value = beanMethod.getAnnotationAttributes(annotationType).get("value");
                    if (value != null) {
                        Class<?> returnType;
                        if (beanMethod instanceof StandardMethodMetadata) {
                            returnType = ((StandardMethodMetadata) beanMethod).getIntrospectedMethod().getReturnType();
                        } else {
                            try {
                                returnType = ClassUtils.forName(beanMethod.getReturnTypeName(), beanFactory.getBeanClassLoader());
                            } catch (ClassNotFoundException e) {
                                throw new CannotLoadBeanClassException(beanDefinition.getDescription(), beanName, beanMethod.getReturnTypeName(), e);
                            }
                        }
                        String endpoint = beanName;
                        if (!MessageHandler.class.isAssignableFrom(returnType)) {
                            /*
								   MessageHandler beans, populated from @Bean methods, have a complex id,
								   including @Configuration bean name, method name and the Messaging annotation name.
								   The following pattern matches the bean name, regardless of the annotation name.
								*/
                            endpoint = beanDefinition.getFactoryBeanName() + "." + beanName + ".*" + IntegrationConfigUtils.HANDLER_ALIAS_SUFFIX;
                        }
                        String[] interceptors = (String[]) value;
                        for (String interceptor : interceptors) {
                            Map<String, String> idempotentEndpoint = new ManagedMap<String, String>();
                            idempotentEndpoint.put(interceptor, endpoint);
                            idempotentEndpointsMapping.add(idempotentEndpoint);
                        }
                    }
                }
            }
        }
    }
    if (!idempotentEndpointsMapping.isEmpty()) {
        BeanDefinition bd = BeanDefinitionBuilder.rootBeanDefinition(IdempotentReceiverAutoProxyCreator.class).addPropertyValue("idempotentEndpointsMapping", idempotentEndpointsMapping).getBeanDefinition();
        registry.registerBeanDefinition(IDEMPOTENT_RECEIVER_AUTO_PROXY_CREATOR_BEAN_NAME, bd);
    }
}

Example 44 with ManagedMap

use of org.springframework.beans.factory.support.ManagedMap in project spring-integration by spring-projects.

the class HttpAdapterParsingUtils method configureUriVariableExpressions.

static void configureUriVariableExpressions(BeanDefinitionBuilder builder, ParserContext parserContext, Element element) {
    String uriVariablesExpression = element.getAttribute("uri-variables-expression");
    List<Element> uriVariableElements = DomUtils.getChildElementsByTagName(element, "uri-variable");
    boolean hasUriVariableExpressions = !CollectionUtils.isEmpty(uriVariableElements);
    if (StringUtils.hasText(uriVariablesExpression)) {
        if (hasUriVariableExpressions) {
            parserContext.getReaderContext().error("'uri-variables-expression' attribute " + "and 'uri-variable' sub-elements are mutually exclusive.", element);
        }
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class).addConstructorArgValue(uriVariablesExpression);
        builder.addPropertyValue("uriVariablesExpression", beanDefinitionBuilder.getBeanDefinition());
    }
    if (hasUriVariableExpressions) {
        ManagedMap<String, Object> uriVariableExpressions = new ManagedMap<String, Object>();
        for (Element uriVariableElement : uriVariableElements) {
            String name = uriVariableElement.getAttribute("name");
            String expression = uriVariableElement.getAttribute("expression");
            BeanDefinitionBuilder factoryBeanBuilder = BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class);
            factoryBeanBuilder.addConstructorArgValue(expression);
            uriVariableExpressions.put(name, factoryBeanBuilder.getBeanDefinition());
        }
        builder.addPropertyValue("uriVariableExpressions", uriVariableExpressions);
    }
}

Example 45 with ManagedMap

use of org.springframework.beans.factory.support.ManagedMap in project spring-integration by spring-projects.

the class StoredProcParserUtils method getReturningResultsetBeanDefinitions.

/**
 * @param storedProcComponent The element.
 * @param parserContext The parser context.
 * @return The list of bean metadata objects.
 */
public static ManagedMap<String, BeanMetadataElement> getReturningResultsetBeanDefinitions(Element storedProcComponent, ParserContext parserContext) {
    List<Element> returningResultsetChildElements = DomUtils.getChildElementsByTagName(storedProcComponent, "returning-resultset");
    ManagedMap<String, BeanMetadataElement> returningResultsetMap = new ManagedMap<String, BeanMetadataElement>();
    for (Element childElement : returningResultsetChildElements) {
        String name = childElement.getAttribute("name");
        String rowMapperAsString = childElement.getAttribute("row-mapper");
        BeanMetadataElement rowMapperBeanDefinition = null;
        try {
            // Backward compatibility
            ClassUtils.forName(rowMapperAsString, parserContext.getReaderContext().getBeanClassLoader());
            rowMapperBeanDefinition = BeanDefinitionBuilder.genericBeanDefinition(rowMapperAsString).getBeanDefinition();
        } catch (ClassNotFoundException e) {
            // Ignore it and fallback to bean reference
            rowMapperBeanDefinition = new RuntimeBeanReference(rowMapperAsString);
        }
        returningResultsetMap.put(name, rowMapperBeanDefinition);
    }
    return returningResultsetMap;
}