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

Introduction

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

Prototype

public static BeanDefinitionBuilder rootBeanDefinition(Class<?> beanClass) 

Source Link

Document

Create a new BeanDefinitionBuilder used to construct a RootBeanDefinition .

Usage

From source file:org.springframework.beans.factory.DefaultListableBeanFactoryTests.java

@Test
public void testContainsBeanReturnsTrueEvenForAbstractBeanDefinition() {
    DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
    bf.registerBeanDefinition("abs",
            BeanDefinitionBuilder.rootBeanDefinition(TestBean.class).setAbstract(true).getBeanDefinition());
    assertThat(bf.containsBean("abs"), equalTo(true));
    assertThat(bf.containsBean("bogus"), equalTo(false));
}

---

From source file:org.springframework.data.elasticsearch.config.TransportClientBeanDefinitionParser.java

@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(TransportClientFactoryBean.class);
    setConfigurations(element, builder);
    return getSourcedBeanDefinition(builder, element, parserContext);
}

---

From source file:org.springframework.data.gemfire.function.config.AbstractFunctionExecutionBeanDefinitionBuilder.java

/**
 * Build the bean definition/* w ww .  j av  a 2 s.c  o  m*/
 * @param registry
 * @return
 */
BeanDefinition build(BeanDefinitionRegistry registry) {

    BeanDefinitionBuilder builder = BeanDefinitionBuilder
            .rootBeanDefinition(getFunctionProxyFactoryBeanClass());

    builder.addConstructorArgValue(configuration.getFunctionExecutionInterface());

    BeanDefinitionBuilder functionTemplateBuilder = getGemfireOperationsBeanDefinitionBuilder(registry);
    functionTemplateBuilder.setLazyInit(true);

    String resultCollectorRef = (String) configuration.getAttribute("resultCollector");
    if (StringUtils.hasText(resultCollectorRef)) {
        functionTemplateBuilder.addPropertyReference("resultCollector", resultCollectorRef);
    }

    AbstractBeanDefinition functionTemplate = functionTemplateBuilder.getBeanDefinition();

    String functionTemplateName = BeanDefinitionReaderUtils.registerWithGeneratedName(functionTemplate,
            registry);

    builder.addConstructorArgReference(functionTemplateName);

    return builder.getBeanDefinition();
}

---

From source file:org.springframework.data.repository.config.AbstractRepositoryConfigDefinitionParser.java

/**
 * Registers a generic repository factory bean for a bean with the given name and the provided configuration context.
 * //from   w  w w.ja v  a  2s .c  o m
 * @param parser
 * @param name
 * @param context
 */
private void registerGenericRepositoryFactoryBean(ParserContext parser, T context) {

    try {

        Object beanSource = parser.extractSource(context.getSource());

        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .rootBeanDefinition(context.getRepositoryFactoryBeanClassName());

        builder.addPropertyValue("repositoryInterface", context.getInterfaceName());
        builder.addPropertyValue("queryLookupStrategyKey", context.getQueryLookupStrategyKey());
        builder.addPropertyValue("namedQueries",
                new NamedQueriesBeanDefinitionParser(context.getNamedQueriesLocation())
                        .parse(context.getSource(), parser));

        String customImplementationBeanName = registerCustomImplementation(context, parser, beanSource);

        if (customImplementationBeanName != null) {
            builder.addPropertyReference("customImplementation", customImplementationBeanName);
        }

        postProcessBeanDefinition(context, builder, parser.getRegistry(), beanSource);

        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
        beanDefinition.setSource(beanSource);

        if (LOG.isDebugEnabled()) {
            LOG.debug("Registering repository: " + context.getBeanId() + " - Interface: "
                    + context.getInterfaceName() + " - Factory: " + context.getRepositoryFactoryBeanClassName()
                    + ", - Custom implementation: " + customImplementationBeanName);
        }

        BeanComponentDefinition definition = new BeanComponentDefinition(beanDefinition, context.getBeanId());
        parser.registerBeanComponent(definition);
    } catch (RuntimeException e) {
        handleError(e, context.getSource(), parser.getReaderContext());
    }
}

---

From source file:org.springframework.data.repository.config.AbstractRepositoryConfigDefinitionParser.java

/**
 * Callback to register additional bean definitions for a {@literal repositories} root node. This usually includes
 * beans you have to set up once independently of the number of repositories to be created. Will be called before any
 * repositories bean definitions have been registered.
 * /*from  ww w.j av  a2  s .co  m*/
 * @param registry
 * @param source
 */
protected void registerBeansForRoot(BeanDefinitionRegistry registry, Object source) {

    AbstractBeanDefinition definition = BeanDefinitionBuilder
            .rootBeanDefinition(REPOSITORY_INTERFACE_POST_PROCESSOR).getBeanDefinition();

    registerWithSourceAndGeneratedBeanName(registry, definition, source);
}

---

From source file:org.springframework.data.repository.config.RepositoryBeanDefinitionBuilder.java

/**
 * Builds a new {@link BeanDefinitionBuilder} from the given {@link BeanDefinitionRegistry} and {@link ResourceLoader}
 * ./*from   w w w  . j av a  2  s  . co  m*/
 * 
 * @param registry must not be {@literal null}.
 * @param resourceLoader must not be {@literal null}.
 * @return
 */
public BeanDefinitionBuilder build(BeanDefinitionRegistry registry, ResourceLoader resourceLoader) {

    Assert.notNull(registry, "BeanDefinitionRegistry must not be null!");
    Assert.notNull(resourceLoader, "ResourceLoader must not be null!");

    String factoryBeanName = configuration.getRepositoryFactoryBeanName();
    factoryBeanName = StringUtils.hasText(factoryBeanName) ? factoryBeanName
            : extension.getRepositoryFactoryClassName();

    BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(factoryBeanName);

    builder.addPropertyValue("repositoryInterface", configuration.getRepositoryInterface());
    builder.addPropertyValue("queryLookupStrategyKey", configuration.getQueryLookupStrategyKey());

    NamedQueriesBeanDefinitionBuilder definitionBuilder = new NamedQueriesBeanDefinitionBuilder(
            extension.getDefaultNamedQueryLocation());

    if (StringUtils.hasText(configuration.getNamedQueriesLocation())) {
        definitionBuilder.setLocations(configuration.getNamedQueriesLocation());
    }

    builder.addPropertyValue("namedQueries", definitionBuilder.build(configuration.getSource()));

    String customImplementationBeanName = registerCustomImplementation(registry, resourceLoader);

    if (customImplementationBeanName != null) {
        builder.addPropertyReference("customImplementation", customImplementationBeanName);
        builder.addDependsOn(customImplementationBeanName);
    }

    return builder;
}

---

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(/*from   ww  w. j  a v a 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

/**
 * //ww  w.j a  va2s. 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.context.ConversionServiceCreator.java

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    if (!beanFactory.containsBean(IntegrationContextUtils.INTEGRATION_CONVERSION_SERVICE_BEAN_NAME)) {
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionBuilder conversionServiceBuilder = BeanDefinitionBuilder
                    .rootBeanDefinition(CustomConversionServiceFactoryBean.class);
            BeanDefinitionHolder beanDefinitionHolder = new BeanDefinitionHolder(
                    conversionServiceBuilder.getBeanDefinition(),
                    IntegrationContextUtils.INTEGRATION_CONVERSION_SERVICE_BEAN_NAME);
            BeanDefinitionReaderUtils.registerBeanDefinition(beanDefinitionHolder,
                    (BeanDefinitionRegistry) beanFactory);
        } else if (logger.isWarnEnabled()) {
            logger.warn(//from  w  ww . j  a va2s. c  om
                    "BeanFactory is not a BeanDefinitionRegistry implementation. Cannot register a default ConversionService.");
        }
    }
}

---

From source file:org.springframework.ldap.config.ContextSourceParser.java

@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(LdapContextSource.class);

    String username = element.getAttribute(ATT_USERNAME);
    String password = element.getAttribute(ATT_PASSWORD);
    String url = element.getAttribute(ATT_URL);
    Assert.hasText(url, "url attribute must be specified");

    builder.addPropertyValue("userDn", username);
    builder.addPropertyValue("password", password);

    BeanDefinitionBuilder urlsBuilder = BeanDefinitionBuilder.rootBeanDefinition(UrlsFactory.class)
            .setFactoryMethod("urls").addConstructorArgValue(url);

    builder.addPropertyValue("urls", urlsBuilder.getBeanDefinition());
    builder.addPropertyValue("base", getString(element, ATT_BASE, ""));
    builder.addPropertyValue("referral", getString(element, ATT_REFERRAL, null));

    boolean anonymousReadOnly = getBoolean(element, ATT_ANONYMOUS_READ_ONLY, false);
    builder.addPropertyValue("anonymousReadOnly", anonymousReadOnly);
    boolean nativePooling = getBoolean(element, ATT_NATIVE_POOLING, false);
    builder.addPropertyValue("pooled", nativePooling);

    String authStrategyRef = element.getAttribute(ATT_AUTHENTICATION_STRATEGY_REF);
    if (StringUtils.hasText(authStrategyRef)) {
        builder.addPropertyReference("authenticationStrategy", authStrategyRef);
    }/*w w  w . j  a  v  a 2s .c o  m*/

    String authSourceRef = element.getAttribute(ATT_AUTHENTICATION_SOURCE_REF);
    if (StringUtils.hasText(authSourceRef)) {
        builder.addPropertyReference("authenticationSource", authSourceRef);
    } else {
        Assert.hasText(username,
                "username attribute must be specified unless an authentication-source-ref explicitly configured");
        Assert.hasText(password,
                "password attribute must be specified unless an authentication-source-ref explicitly configured");
    }

    String baseEnvPropsRef = element.getAttribute(ATT_BASE_ENV_PROPS_REF);
    if (StringUtils.hasText(baseEnvPropsRef)) {
        builder.addPropertyReference("baseEnvironmentProperties", baseEnvPropsRef);
    }

    BeanDefinition targetContextSourceDefinition = builder.getBeanDefinition();
    targetContextSourceDefinition = applyPoolingIfApplicable(targetContextSourceDefinition, element,
            nativePooling);

    BeanDefinition actualContextSourceDefinition = targetContextSourceDefinition;
    if (!anonymousReadOnly) {
        BeanDefinitionBuilder proxyBuilder = BeanDefinitionBuilder
                .rootBeanDefinition(TransactionAwareContextSourceProxy.class);
        proxyBuilder.addConstructorArgValue(targetContextSourceDefinition);
        actualContextSourceDefinition = proxyBuilder.getBeanDefinition();
    }

    String id = getString(element, AbstractBeanDefinitionParser.ID_ATTRIBUTE, DEFAULT_ID);
    parserContext.registerBeanComponent(new BeanComponentDefinition(actualContextSourceDefinition, id));

    return actualContextSourceDefinition;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• »