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.flex.config.HibernateSerializationConfigPostProcessor.java

@SuppressWarnings("unchecked")
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    if (isHibernateDetected(beanFactory.getBeanClassLoader())) {

        //Make sure there is a MessageBrokerFactoryBean present
        BeanDefinition messageBrokerBeanDef = findMessageBrokerFactoryBeanDefinition(beanFactory);
        Assert.notNull(/*w  w  w . j  a va  2 s. c  om*/
                "Could not find an appropriate bean definition for MessageBrokerBeanDefinitionFactoryBean.");

        MutablePropertyValues brokerProps = messageBrokerBeanDef.getPropertyValues();
        ManagedSet<RuntimeBeanReference> configProcessors;
        if (brokerProps.getPropertyValue(CONFIG_PROCESSORS_PROPERTY) != null) {
            configProcessors = (ManagedSet<RuntimeBeanReference>) brokerProps
                    .getPropertyValue(CONFIG_PROCESSORS_PROPERTY).getValue();
        } else {
            configProcessors = new ManagedSet<RuntimeBeanReference>();
        }

        //Abort if HibernateConfigProcessor is already present
        if (isAmfConversionServiceProcessorConfigured(beanFactory, configProcessors)) {
            return;
        }

        if (!ClassUtils.isAssignableValue(BeanDefinitionRegistry.class, beanFactory)) {
            if (log.isWarnEnabled()) {
                log.warn(
                        "Hibernate AMF serialization support could not be auto-configured because the current BeanFactory does not implement "
                                + "BeanDefinitionRegistry.  In order for this support to be enabled, you must manually configure an instance of "
                                + HIBERNATE_CONFIG_PROCESSOR_CLASS);
            }
        }

        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

        //Add the appropriate HibernateConfigProcessor bean definition
        BeanDefinitionBuilder processorBuilder;
        if (isJpaDetected(beanFactory.getBeanClassLoader())) {
            processorBuilder = BeanDefinitionBuilder.rootBeanDefinition(JPA_HIBERNATE_CONFIG_PROCESSOR_CLASS);
        } else {
            processorBuilder = BeanDefinitionBuilder.rootBeanDefinition(HIBERNATE_CONFIG_PROCESSOR_CLASS);
        }

        String processorId = BeanDefinitionReaderUtils
                .registerWithGeneratedName(processorBuilder.getBeanDefinition(), registry);

        configProcessors.add(new RuntimeBeanReference(processorId));
    }
}

From source file:org.springframework.flex.config.RemotingAnnotationPostProcessor.java

/**
 * //from  ww w  .ja va  2s . c o m
 * {@inheritDoc}
 */
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    Set<RemotingDestinationMetadata> remoteBeans = findRemotingDestinations(beanFactory);

    if (remoteBeans.size() > 0) {
        Assert.isInstanceOf(BeanDefinitionRegistry.class, beanFactory,
                "In order for services to be exported via the @RemotingDestination annotation, the current BeanFactory must be a BeanDefinitionRegistry.");
    }

    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

    for (RemotingDestinationMetadata remotingDestinationConfig : remoteBeans) {

        BeanDefinitionBuilder exporterBuilder = BeanDefinitionBuilder
                .rootBeanDefinition(RemotingDestinationExporter.class);
        exporterBuilder.getRawBeanDefinition().setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

        RemotingDestination remotingDestination = remotingDestinationConfig.getRemotingDestination();

        String messageBrokerId = StringUtils.hasText(remotingDestination.messageBroker())
                ? remotingDestination.messageBroker()
                : BeanIds.MESSAGE_BROKER;
        String destinationId = StringUtils.hasText(remotingDestination.value()) ? remotingDestination.value()
                : remotingDestinationConfig.getBeanName();

        String[] channels = null;
        for (String channelValue : remotingDestination.channels()) {
            channelValue = beanFactory.resolveEmbeddedValue(channelValue);
            String[] parsedChannels = StringUtils
                    .trimArrayElements(StringUtils.commaDelimitedListToStringArray(channelValue));
            channels = StringUtils.mergeStringArrays(channels, parsedChannels);
        }

        exporterBuilder.addPropertyReference(MESSAGE_BROKER_PROPERTY, messageBrokerId);
        exporterBuilder.addPropertyValue(SERVICE_PROPERTY, remotingDestinationConfig.getBeanName());
        exporterBuilder.addDependsOn(remotingDestinationConfig.getBeanName());
        exporterBuilder.addPropertyValue(DESTINATION_ID_PROPERTY, destinationId);
        exporterBuilder.addPropertyValue(CHANNELS_PROPERTY, channels);
        exporterBuilder.addPropertyValue(INCLUDE_METHODS_PROPERTY,
                remotingDestinationConfig.getIncludeMethods());
        exporterBuilder.addPropertyValue(EXCLUDE_METHODS_PROPERTY,
                remotingDestinationConfig.getExcludeMethods());
        exporterBuilder.addPropertyValue(SERVICE_ADAPTER_PROPERTY, remotingDestination.serviceAdapter());

        BeanDefinitionReaderUtils.registerWithGeneratedName(exporterBuilder.getBeanDefinition(), registry);
    }

}

From source file:org.springframework.integration.aws.sqs.config.AmazonSQSInboundChannelAdapterParser.java

@Override
protected BeanMetadataElement parseSource(Element element, ParserContext parserContext) {
    String awsCredentials = registerAmazonWSCredentials(element, parserContext);
    //Mandated at xsd level, so has to be present
    String sqsQueue = element.getAttribute(SQS_QUEUE);
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(AmazonSQSMessageSource.class)
            .addConstructorArgReference(awsCredentials).addConstructorArgValue(sqsQueue);
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, IS_TRANSACTIONAL);
    IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, MAX_REDELIVERY_ATTEMPTS);
    IntegrationNamespaceUtils.setReferenceIfAttributeDefined(builder, element, SQS_OPERATIONS);
    String messageTransformerRef = element.getAttribute(MESSAGE_TRANSFORMER);
    boolean hasMessageTransformerRef = StringUtils.hasText(messageTransformerRef);

    boolean hasSnsHeaderPrefix = false;
    String snsNotificationAttribute = element.getAttribute(CHECK_SNS_NOTIFICATION);
    boolean checkSnsNotification = StringUtils.hasText(snsNotificationAttribute);
    String snsHeaderPrefix = null;
    if (checkSnsNotification) {
        snsHeaderPrefix = element.getAttribute(SNS_HEADER_PREFIX);
        hasSnsHeaderPrefix = StringUtils.hasText(snsHeaderPrefix);
    }/*from   www  . ja  v a2s . co m*/

    if (!element.hasAttribute(SQS_OPERATIONS)) {
        BeanDefinitionBuilder sqsOperationsBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(AmazonSQSOperationsImpl.class)
                .addConstructorArgReference(awsCredentials);
        if (hasMessageTransformerRef) {
            sqsOperationsBuilder.addPropertyReference("messageTransformer", messageTransformerRef);
        }

        if (checkSnsNotification) {
            sqsOperationsBuilder.addPropertyValue("checkSnsNotification", true);
            if (hasSnsHeaderPrefix) {
                sqsOperationsBuilder.addPropertyValue("snsHeaderPrefix", snsHeaderPrefix);
            }
        }

        //sqs_operations attribute not defined, register the default one
        String operationsBean = BeanDefinitionReaderUtils.registerWithGeneratedName(
                sqsOperationsBuilder.getBeanDefinition(), parserContext.getRegistry());
        builder.addPropertyReference("sqsOperations", operationsBean);
    } else {
        if (hasMessageTransformerRef) {
            //This means, we have a reference to both sqs operations and message transformer provided
            throw new BeanDefinitionStoreException(
                    "Both the attributes,  \"sqs-operations\" and \"message-transformer\" are "
                            + "not supported together. Consider injecting the messageTransformer in the sqsOperation's bean definition"
                            + " and provide \"sqs-operations\" attribute only");
        }
        if (checkSnsNotification) {
            logger.warn("check-sns-notification and sns-header-prefix attributes are supported"
                    + " only when default implementation of sqs operations is used");
        }

    }
    return builder.getBeanDefinition();
}

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

/**
 * Register an error channel in the given BeanDefinitionRegistry.
 *//*  w  ww.  ja  v a2  s .  c  o m*/
private void registerErrorChannel(BeanDefinitionRegistry registry) {
    if (this.logger.isInfoEnabled()) {
        this.logger.info("No bean named '" + IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME
                + "' has been explicitly defined. Therefore, a default PublishSubscribeChannel will be created.");
    }
    registry.registerBeanDefinition(IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME,
            new RootBeanDefinition(PublishSubscribeChannel.class));

    BeanDefinition loggingHandler = BeanDefinitionBuilder.genericBeanDefinition(LoggingHandler.class)
            .addConstructorArgValue("ERROR").getBeanDefinition();

    String errorLoggerBeanName = ERROR_LOGGER_BEAN_NAME + IntegrationConfigUtils.HANDLER_ALIAS_SUFFIX;
    registry.registerBeanDefinition(errorLoggerBeanName, loggingHandler);

    BeanDefinitionBuilder loggingEndpointBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(ConsumerEndpointFactoryBean.class)
            .addPropertyReference("handler", errorLoggerBeanName)
            .addPropertyValue("inputChannelName", IntegrationContextUtils.ERROR_CHANNEL_BEAN_NAME);

    BeanComponentDefinition componentDefinition = new BeanComponentDefinition(
            loggingEndpointBuilder.getBeanDefinition(), ERROR_LOGGER_BEAN_NAME);
    BeanDefinitionReaderUtils.registerBeanDefinition(componentDefinition, registry);
}

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

/**
 * This method will auto-register a ChannelInitializer which could also be overridden by the user
 * by simply registering a ChannelInitializer {@code <bean>} with its {@code autoCreate} property
 * set to false to suppress channel creation.
 * It will also register a ChannelInitializer$AutoCreateCandidatesCollector
 * which simply collects candidate channel names.
 * @param registry The {@link BeanDefinitionRegistry} to register additional {@link BeanDefinition}s.
 *//*from w w w. j  a v a2 s.  c  o m*/
private void registerImplicitChannelCreator(BeanDefinitionRegistry registry) {
    if (!registry.containsBeanDefinition(IntegrationContextUtils.CHANNEL_INITIALIZER_BEAN_NAME)) {
        String channelsAutoCreateExpression = IntegrationProperties
                .getExpressionFor(IntegrationProperties.CHANNELS_AUTOCREATE);
        BeanDefinitionBuilder channelDef = BeanDefinitionBuilder.genericBeanDefinition(ChannelInitializer.class)
                .addPropertyValue("autoCreate", channelsAutoCreateExpression);
        BeanDefinitionHolder channelCreatorHolder = new BeanDefinitionHolder(channelDef.getBeanDefinition(),
                IntegrationContextUtils.CHANNEL_INITIALIZER_BEAN_NAME);
        BeanDefinitionReaderUtils.registerBeanDefinition(channelCreatorHolder, registry);
    }

    if (!registry.containsBeanDefinition(IntegrationContextUtils.AUTO_CREATE_CHANNEL_CANDIDATES_BEAN_NAME)) {
        BeanDefinitionBuilder channelRegistryBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(ChannelInitializer.AutoCreateCandidatesCollector.class);
        channelRegistryBuilder.addConstructorArgValue(new ManagedSet<String>());
        channelRegistryBuilder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); //SPR-12761
        BeanDefinitionHolder channelRegistryHolder = new BeanDefinitionHolder(
                channelRegistryBuilder.getBeanDefinition(),
                IntegrationContextUtils.AUTO_CREATE_CHANNEL_CANDIDATES_BEAN_NAME);
        BeanDefinitionReaderUtils.registerBeanDefinition(channelRegistryHolder, registry);
    }
}

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

/**
 * Register {@code integrationGlobalProperties} bean if necessary.
 * @param registry The {@link BeanDefinitionRegistry} to register additional {@link BeanDefinition}s.
 *//*w ww.  j  av  a2s.  co m*/
private void registerIntegrationProperties(BeanDefinitionRegistry registry) {
    boolean alreadyRegistered = false;
    if (registry instanceof ListableBeanFactory) {
        alreadyRegistered = ((ListableBeanFactory) registry)
                .containsBean(IntegrationContextUtils.INTEGRATION_GLOBAL_PROPERTIES_BEAN_NAME);
    } else {
        alreadyRegistered = registry
                .isBeanNameInUse(IntegrationContextUtils.INTEGRATION_GLOBAL_PROPERTIES_BEAN_NAME);
    }
    if (!alreadyRegistered) {
        ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver(this.classLoader);
        try {
            Resource[] defaultResources = resourceResolver
                    .getResources("classpath*:META-INF/spring.integration.default.properties");
            Resource[] userResources = resourceResolver
                    .getResources("classpath*:META-INF/spring.integration.properties");

            List<Resource> resources = new LinkedList<Resource>(Arrays.asList(defaultResources));
            resources.addAll(Arrays.asList(userResources));

            BeanDefinitionBuilder integrationPropertiesBuilder = BeanDefinitionBuilder
                    .genericBeanDefinition(PropertiesFactoryBean.class)
                    .addPropertyValue("locations", resources);

            registry.registerBeanDefinition(IntegrationContextUtils.INTEGRATION_GLOBAL_PROPERTIES_BEAN_NAME,
                    integrationPropertiesBuilder.getBeanDefinition());
        } catch (IOException e) {
            logger.warn("Cannot load 'spring.integration.properties' Resources.", e);
        }
    }
}

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

/**
 * Register {@link IntegrationEvaluationContextFactoryBean} bean, if necessary.
 * @param registry The {@link BeanDefinitionRegistry} to register additional {@link BeanDefinition}s.
 *//*from  w w w  .  ja v a 2  s .  com*/
private void registerIntegrationEvaluationContext(BeanDefinitionRegistry registry) {
    if (!registry.containsBeanDefinition(IntegrationContextUtils.INTEGRATION_EVALUATION_CONTEXT_BEAN_NAME)) {
        BeanDefinitionBuilder integrationEvaluationContextBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(IntegrationEvaluationContextFactoryBean.class);
        integrationEvaluationContextBuilder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

        BeanDefinitionHolder integrationEvaluationContextHolder = new BeanDefinitionHolder(
                integrationEvaluationContextBuilder.getBeanDefinition(),
                IntegrationContextUtils.INTEGRATION_EVALUATION_CONTEXT_BEAN_NAME);

        BeanDefinitionReaderUtils.registerBeanDefinition(integrationEvaluationContextHolder, registry);
    }
}

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

/**
 * Register {@code DefaultConfiguringBeanFactoryPostProcessor}, if necessary.
 * @param registry The {@link BeanDefinitionRegistry} to register additional {@link BeanDefinition}s.
 *///  ww w .j a  v a  2  s.  c  o m
private void registerDefaultConfiguringBeanFactoryPostProcessor(BeanDefinitionRegistry registry) {
    boolean alreadyRegistered = false;
    if (registry instanceof ListableBeanFactory) {
        alreadyRegistered = ((ListableBeanFactory) registry)
                .containsBean(IntegrationContextUtils.DEFAULT_CONFIGURING_POSTPROCESSOR_BEAN_NAME);
    } else {
        alreadyRegistered = registry
                .isBeanNameInUse(IntegrationContextUtils.DEFAULT_CONFIGURING_POSTPROCESSOR_BEAN_NAME);
    }
    if (!alreadyRegistered) {
        BeanDefinitionBuilder postProcessorBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(DefaultConfiguringBeanFactoryPostProcessor.class);
        BeanDefinitionHolder postProcessorHolder = new BeanDefinitionHolder(
                postProcessorBuilder.getBeanDefinition(),
                IntegrationContextUtils.DEFAULT_CONFIGURING_POSTPROCESSOR_BEAN_NAME);
        BeanDefinitionReaderUtils.registerBeanDefinition(postProcessorHolder, registry);
    }
}

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

/**
 * Register a {@link DefaultHeaderChannelRegistry} in the given {@link BeanDefinitionRegistry}, if necessary.
 * @param registry The {@link BeanDefinitionRegistry} to register additional {@link BeanDefinition}s.
 *///  w ww  .  j  a va 2 s  .  c  o m
private void registerHeaderChannelRegistry(BeanDefinitionRegistry registry) {
    boolean alreadyRegistered = false;
    if (registry instanceof ListableBeanFactory) {
        alreadyRegistered = ((ListableBeanFactory) registry)
                .containsBean(IntegrationContextUtils.INTEGRATION_HEADER_CHANNEL_REGISTRY_BEAN_NAME);
    } else {
        alreadyRegistered = registry
                .isBeanNameInUse(IntegrationContextUtils.INTEGRATION_HEADER_CHANNEL_REGISTRY_BEAN_NAME);
    }
    if (!alreadyRegistered) {
        if (logger.isInfoEnabled()) {
            logger.info(
                    "No bean named '" + IntegrationContextUtils.INTEGRATION_HEADER_CHANNEL_REGISTRY_BEAN_NAME
                            + "' has been explicitly defined. "
                            + "Therefore, a default DefaultHeaderChannelRegistry will be created.");
        }
        BeanDefinitionBuilder schedulerBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(DefaultHeaderChannelRegistry.class);
        BeanDefinitionHolder replyChannelRegistryComponent = new BeanDefinitionHolder(
                schedulerBuilder.getBeanDefinition(),
                IntegrationContextUtils.INTEGRATION_HEADER_CHANNEL_REGISTRY_BEAN_NAME);
        BeanDefinitionReaderUtils.registerBeanDefinition(replyChannelRegistryComponent, registry);
    }
}

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

/**
 * Register a {@link GlobalChannelInterceptorProcessor} in the given {@link BeanDefinitionRegistry}, if necessary.
 * @param registry The {@link BeanDefinitionRegistry} to register additional {@link BeanDefinition}s.
 *///from  w w w  . j  a v  a 2 s. c  o  m
private void registerGlobalChannelInterceptorProcessor(BeanDefinitionRegistry registry) {
    if (!registry
            .containsBeanDefinition(IntegrationContextUtils.GLOBAL_CHANNEL_INTERCEPTOR_PROCESSOR_BEAN_NAME)) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(GlobalChannelInterceptorProcessor.class)
                .setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

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