Example usage for org.springframework.beans.factory.support BeanDefinitionBuilder getBeanDefinition

List of usage examples for org.springframework.beans.factory.support BeanDefinitionBuilder getBeanDefinition

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.support.*
  5. BeanDefinitionBuilder
  6. getBeanDefinition

Introduction

In this page you can find the example usage for org.springframework.beans.factory.support BeanDefinitionBuilder getBeanDefinition.

Prototype

public AbstractBeanDefinition getBeanDefinition()

Source Link

Document

Validate and return the created BeanDefinition object.

Usage

From source file:org.springframework.integration.config.IntegrationRegistrar.java

/**
 * Register {@link MessagingAnnotationPostProcessor} and {@link PublisherAnnotationBeanPostProcessor}, if necessary.
 * Inject {@code defaultPublishedChannel} from provided {@link AnnotationMetadata}, if any.
 * @param meta The {@link AnnotationMetadata} to get additional properties for {@link BeanDefinition}s.
 * @param registry The {@link BeanDefinitionRegistry} to register additional {@link BeanDefinition}s.
 *///from   ww w.j av a2 s. com
private void registerMessagingAnnotationPostProcessors(AnnotationMetadata meta,
        BeanDefinitionRegistry registry) {
    if (!registry.containsBeanDefinition(IntegrationContextUtils.MESSAGING_ANNOTATION_POSTPROCESSOR_NAME)) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(MessagingAnnotationPostProcessor.class)
                .setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

        registry.registerBeanDefinition(IntegrationContextUtils.MESSAGING_ANNOTATION_POSTPROCESSOR_NAME,
                builder.getBeanDefinition());
    }

    new PublisherRegistrar().registerBeanDefinitions(meta, registry);
}

From source file:org.springframework.integration.config.IntegrationRegistrar.java

/**
 * Register {@link IntegrationConfigurationBeanFactoryPostProcessor}
 * to process the external Integration infrastructure.
 *///from   www .  ja va2  s .c  o  m
private void registerIntegrationConfigurationBeanFactoryPostProcessor(BeanDefinitionRegistry registry) {
    if (!registry.containsBeanDefinition(
            IntegrationContextUtils.INTEGRATION_CONFIGURATION_POST_PROCESSOR_BEAN_NAME)) {
        BeanDefinitionBuilder postProcessorBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(IntegrationConfigurationBeanFactoryPostProcessor.class)
                .setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        registry.registerBeanDefinition(
                IntegrationContextUtils.INTEGRATION_CONFIGURATION_POST_PROCESSOR_BEAN_NAME,
                postProcessorBuilder.getBeanDefinition());
    }
}

From source file:org.springframework.integration.config.IntegrationRegistrar.java

/**
 * Register the default datatype channel MessageConverter.
 * @param registry the registry.//from w  w w  . j  ava2 s  . com
 */
private void registerDefaultDatatypeChannelMessageConverter(BeanDefinitionRegistry registry) {
    boolean alreadyRegistered = false;
    if (registry instanceof ListableBeanFactory) {
        alreadyRegistered = ((ListableBeanFactory) registry)
                .containsBean(IntegrationContextUtils.INTEGRATION_DATATYPE_CHANNEL_MESSAGE_CONVERTER_BEAN_NAME);
    } else {
        alreadyRegistered = registry.isBeanNameInUse(
                IntegrationContextUtils.INTEGRATION_DATATYPE_CHANNEL_MESSAGE_CONVERTER_BEAN_NAME);
    }
    if (!alreadyRegistered) {
        BeanDefinitionBuilder converterBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(DefaultDatatypeChannelMessageConverter.class);
        registry.registerBeanDefinition(
                IntegrationContextUtils.INTEGRATION_DATATYPE_CHANNEL_MESSAGE_CONVERTER_BEAN_NAME,
                converterBuilder.getBeanDefinition());
    }

}

From source file:org.springframework.integration.config.IntegrationRegistrar.java

/**
 * Register the default {@link CompositeMessageConverter} for argument resolvers
 * during handler method invocation./*from www. j  ava2 s .com*/
 * @param registry the registry.
 */
private void registerArgumentResolverMessageConverter(BeanDefinitionRegistry registry) {
    if (!registry
            .containsBeanDefinition(IntegrationContextUtils.ARGUMENT_RESOLVER_MESSAGE_CONVERTER_BEAN_NAME)) {
        BeanDefinitionBuilder postProcessorBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(ConfigurableCompositeMessageConverter.class);
        registry.registerBeanDefinition(IntegrationContextUtils.ARGUMENT_RESOLVER_MESSAGE_CONVERTER_BEAN_NAME,
                postProcessorBuilder.getBeanDefinition());
    }
}

From source file:org.springframework.integration.config.IntegrationRegistrar.java

private void registerMessageBuilderFactory(BeanDefinitionRegistry registry) {
    boolean alreadyRegistered = false;
    if (registry instanceof ListableBeanFactory) {
        alreadyRegistered = ((ListableBeanFactory) registry)
                .containsBean(IntegrationUtils.INTEGRATION_MESSAGE_BUILDER_FACTORY_BEAN_NAME);
    } else {/*  w w w  . j av a 2  s  . c  om*/
        alreadyRegistered = registry
                .isBeanNameInUse(IntegrationUtils.INTEGRATION_MESSAGE_BUILDER_FACTORY_BEAN_NAME);
    }
    if (!alreadyRegistered) {
        BeanDefinitionBuilder mbfBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(DefaultMessageBuilderFactory.class).addPropertyValue("readOnlyHeaders",
                        IntegrationProperties.getExpressionFor(IntegrationProperties.READ_ONLY_HEADERS));
        registry.registerBeanDefinition(IntegrationUtils.INTEGRATION_MESSAGE_BUILDER_FACTORY_BEAN_NAME,
                mbfBuilder.getBeanDefinition());
    }

}

From source file:org.springframework.integration.config.MessagingGatewayRegistrar.java

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);
        }/*  w w w. j  a  v a 2 s . c o m*/
        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.addPropertyReference("defaultRequestChannel", defaultRequestChannel);
    }
    if (StringUtils.hasText(defaultReplyChannel)) {
        gatewayProxyBuilder.addPropertyReference("defaultReplyChannel", defaultReplyChannel);
    }
    if (StringUtils.hasText(errorChannel)) {
        gatewayProxyBuilder.addPropertyReference("errorChannel", errorChannel);
    }
    if (StringUtils.hasText(asyncExecutor)) {
        gatewayProxyBuilder.addPropertyReference("asyncExecutor", asyncExecutor);
    }
    if (StringUtils.hasText(mapper)) {
        gatewayProxyBuilder.addPropertyReference("mapper", mapper);
    }

    gatewayProxyBuilder.addPropertyValue("defaultRequestTimeout",
            gatewayAttributes.get("defaultRequestTimeout"));
    gatewayProxyBuilder.addPropertyValue("defaultReplyTimeout", 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);

    return new BeanDefinitionHolder(gatewayProxyBuilder.getBeanDefinition(), id);
}

From source file:org.springframework.integration.config.PublisherRegistrar.java

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
        BeanDefinitionRegistry registry) {
    Map<String, Object> annotationAttributes = importingClassMetadata
            .getAnnotationAttributes(EnablePublisher.class.getName());

    String value = (annotationAttributes == null
            ? (String) AnnotationUtils.getDefaultValue(EnablePublisher.class)
            : (String) annotationAttributes.get("value"));
    if (!registry.containsBeanDefinition(IntegrationContextUtils.PUBLISHER_ANNOTATION_POSTPROCESSOR_NAME)) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(PublisherAnnotationBeanPostProcessor.class)
                .setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

        if (StringUtils.hasText(value)) {
            builder.addPropertyValue("defaultChannelName", value);
            if (logger.isInfoEnabled()) {
                logger.info("Setting '@Publisher' default-output-channel to '" + value + "'.");
            }//from   w  w  w  .j  a  va2s .  c om
        }

        registry.registerBeanDefinition(IntegrationContextUtils.PUBLISHER_ANNOTATION_POSTPROCESSOR_NAME,
                builder.getBeanDefinition());
    } else {
        BeanDefinition beanDefinition = registry
                .getBeanDefinition(IntegrationContextUtils.PUBLISHER_ANNOTATION_POSTPROCESSOR_NAME);
        MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
        PropertyValue defaultChannelPropertyValue = propertyValues.getPropertyValue("defaultChannelName");
        if (StringUtils.hasText(value)) {
            if (defaultChannelPropertyValue == null) {
                propertyValues.addPropertyValue("defaultChannelName", value);
                if (logger.isInfoEnabled()) {
                    logger.info("Setting '@Publisher' default-output-channel to '" + value + "'.");
                }
            } else if (!value.equals(defaultChannelPropertyValue.getValue())) {
                throw new BeanDefinitionStoreException("When more than one enable publisher definition "
                        + "(@EnablePublisher or <annotation-config>)"
                        + " is found in the context, they all must have the same 'default-publisher-channel' value.");
            }
        }
    }
}

From source file:org.springframework.integration.config.xml.ChainParser.java

@Override
protected BeanDefinitionBuilder parseHandler(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MessageHandlerChain.class);

    if (!StringUtils.hasText(element.getAttribute(ID_ATTRIBUTE))) {
        logger.info("It is useful to provide an explicit 'id' attribute on 'chain' elements "
                + "to simplify the identification of child elements in logs etc.");
    }//from   ww  w .j  a  va  2 s. c om

    String chainHandlerId = this.resolveId(element, builder.getRawBeanDefinition(), parserContext);
    List<BeanMetadataElement> handlerList = new ManagedList<BeanMetadataElement>();
    Set<String> handlerBeanNameSet = new HashSet<String>();
    NodeList children = element.getChildNodes();

    int childOrder = 0;
    for (int i = 0; i < children.getLength(); i++) {
        Node child = children.item(i);
        if (child.getNodeType() == Node.ELEMENT_NODE && !"poller".equals(child.getLocalName())) {
            BeanMetadataElement childBeanMetadata = this.parseChild(chainHandlerId, (Element) child,
                    childOrder++, parserContext, builder.getBeanDefinition());
            if (childBeanMetadata instanceof RuntimeBeanReference) {
                String handlerBeanName = ((RuntimeBeanReference) childBeanMetadata).getBeanName();
                if (!handlerBeanNameSet.add(handlerBeanName)) {
                    parserContext.getReaderContext().error("A bean definition is already registered for "
                            + "beanName: '" + handlerBeanName + "' within the current <chain>.", element);
                    return null;
                }
            }
            if ("gateway".equals(child.getLocalName())) {
                BeanDefinitionBuilder gwBuilder = BeanDefinitionBuilder.genericBeanDefinition(
                        IntegrationNamespaceUtils.BASE_PACKAGE + ".gateway.RequestReplyMessageHandlerAdapter");
                gwBuilder.addConstructorArgValue(childBeanMetadata);
                handlerList.add(gwBuilder.getBeanDefinition());
            } else {
                handlerList.add(childBeanMetadata);
            }
        }
    }
    builder.addPropertyValue("handlers", handlerList);
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "send-timeout");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "auto-startup");
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "phase");
    return builder;
}

From source file:org.springframework.integration.config.xml.DefaultConfiguringBeanFactoryPostProcessor.java

/**
 * Register an error channel in the given BeanDefinitionRegistry.
 *//*  w ww .j a va  2s.  c  o  m*/
private void registerErrorChannel(BeanDefinitionRegistry registry) {
    if (logger.isInfoEnabled()) {
        logger.info("No bean named '" + IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME
                + "' has been explicitly defined. Therefore, a default PublishSubscribeChannel will be created.");
    }
    RootBeanDefinition errorChannelDef = new RootBeanDefinition();
    errorChannelDef
            .setBeanClassName(IntegrationNamespaceUtils.BASE_PACKAGE + ".channel.PublishSubscribeChannel");
    BeanDefinitionHolder errorChannelHolder = new BeanDefinitionHolder(errorChannelDef,
            IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME);
    BeanDefinitionReaderUtils.registerBeanDefinition(errorChannelHolder, registry);
    BeanDefinitionBuilder loggingHandlerBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(IntegrationNamespaceUtils.BASE_PACKAGE + ".handler.LoggingHandler");
    loggingHandlerBuilder.addConstructorArgValue("ERROR");
    BeanDefinitionBuilder loggingEndpointBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(IntegrationNamespaceUtils.BASE_PACKAGE + ".endpoint.EventDrivenConsumer");
    loggingEndpointBuilder.addConstructorArgReference(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME);
    loggingEndpointBuilder.addConstructorArgValue(loggingHandlerBuilder.getBeanDefinition());
    BeanComponentDefinition componentDefinition = new BeanComponentDefinition(
            loggingEndpointBuilder.getBeanDefinition(), ERROR_LOGGER_BEAN_NAME);
    BeanDefinitionReaderUtils.registerBeanDefinition(componentDefinition, registry);
}

From source file:org.springframework.integration.config.xml.DefaultConfiguringBeanFactoryPostProcessor.java

/**
 * Register a TaskScheduler in the given BeanDefinitionRegistry.
 *///  w w  w.  j a  v  a 2s.c  o m
private void registerTaskScheduler(BeanDefinitionRegistry registry) {
    if (logger.isInfoEnabled()) {
        logger.info("No bean named '" + IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME
                + "' has been explicitly defined. Therefore, a default ThreadPoolTaskScheduler will be created.");
    }
    BeanDefinitionBuilder schedulerBuilder = BeanDefinitionBuilder
            .genericBeanDefinition("org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler");
    schedulerBuilder.addPropertyValue("poolSize", 10);
    schedulerBuilder.addPropertyValue("threadNamePrefix", "task-scheduler-");
    schedulerBuilder.addPropertyValue("rejectedExecutionHandler", new CallerRunsPolicy());
    BeanDefinitionBuilder errorHandlerBuilder = BeanDefinitionBuilder.genericBeanDefinition(
            IntegrationNamespaceUtils.BASE_PACKAGE + ".channel.MessagePublishingErrorHandler");
    errorHandlerBuilder.addPropertyReference("defaultErrorChannel",
            IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME);
    schedulerBuilder.addPropertyValue("errorHandler", errorHandlerBuilder.getBeanDefinition());
    BeanComponentDefinition schedulerComponent = new BeanComponentDefinition(
            schedulerBuilder.getBeanDefinition(), IntegrationContextUtils.TASK_SCHEDULER_BEAN_NAME);
    BeanDefinitionReaderUtils.registerBeanDefinition(schedulerComponent, registry);
}