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.webflux.config.WebFluxIntegrationConfigurationInitializer.java

/**
 * Registers a {@link WebFluxIntegrationRequestMappingHandlerMapping}
 * which could also be overridden by the user by simply registering
 * a {@link WebFluxIntegrationRequestMappingHandlerMapping} {@code <bean>} with 'id'
 * {@link WebFluxContextUtils#HANDLER_MAPPING_BEAN_NAME}.
 * <p>//w  w  w. j  a  va2s  . c  o m
 * In addition, checks if the {@code org.springframework.web.reactive.result.method.RequestMappingInfo}
 * class is present on the classpath.
 * When Spring Integration HTTP is used only as an HTTP client, there is no reason to use and register
 * the HTTP server components.
 */
private void registerReactiveRequestMappingHandlerMappingIfNecessary(BeanDefinitionRegistry registry) {
    if (HttpContextUtils.WEB_FLUX_PRESENT
            && !registry.containsBeanDefinition(WebFluxContextUtils.HANDLER_MAPPING_BEAN_NAME)) {
        BeanDefinitionBuilder requestMappingBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(WebFluxIntegrationRequestMappingHandlerMapping.class);
        requestMappingBuilder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        requestMappingBuilder.addPropertyValue(IntegrationNamespaceUtils.ORDER, 0);
        registry.registerBeanDefinition(WebFluxContextUtils.HANDLER_MAPPING_BEAN_NAME,
                requestMappingBuilder.getBeanDefinition());

        BeanDefinitionReaderUtils.registerWithGeneratedName(
                new RootBeanDefinition(IntegrationHandlerResultHandler.class), registry);
    }
}

From source file:org.springframework.integration.websocket.config.WebSocketIntegrationConfigurationInitializer.java

/**
 * Register a {@link WebSocketHandlerMappingFactoryBean} which could also be overridden
 * by the user by simply using {@link org.springframework.web.socket.config.annotation.EnableWebSocket}
 * <p>/*w  w w.j a v  a 2 s  .com*/
 * In addition, checks if the {@code javax.servlet.Servlet} class is present on the classpath.
 * When Spring Integration WebSocket support is used only as a WebSocket client,
 * there is no reason to use and register the Spring WebSocket server components.
 * <p>
 * Note, there is no XML equivalent for
 * the {@link org.springframework.web.socket.config.annotation .EnableWebSocket}
 * in the Spring WebSocket. therefore this registration can be used to process
 * {@link WebSocketConfigurer} implementations without annotation configuration.
 * From other side it can be used to replace
 * {@link org.springframework.web.socket.config.annotation.EnableWebSocket} in the Spring Integration
 * applications when {@link org.springframework.integration.config.EnableIntegration} is in use.
 */
private void registerEnableWebSocketIfNecessary(BeanDefinitionRegistry registry) {
    if (servletPresent) {
        if (!registry.containsBeanDefinition("defaultSockJsTaskScheduler")) {
            BeanDefinitionBuilder sockJsTaskSchedulerBuilder = BeanDefinitionBuilder
                    .genericBeanDefinition(ThreadPoolTaskScheduler.class)
                    .addPropertyValue("threadNamePrefix", "SockJS-")
                    .addPropertyValue("poolSize", Runtime.getRuntime().availableProcessors())
                    .addPropertyValue("removeOnCancelPolicy", true);

            registry.registerBeanDefinition("defaultSockJsTaskScheduler",
                    sockJsTaskSchedulerBuilder.getBeanDefinition());
        }

        if (!registry.containsBeanDefinition(DelegatingWebSocketConfiguration.class.getName())
                && !registry.containsBeanDefinition(WEB_SOCKET_HANDLER_MAPPING_BEAN_NAME)) {
            BeanDefinitionBuilder enableWebSocketBuilder = BeanDefinitionBuilder
                    .genericBeanDefinition(WebSocketHandlerMappingFactoryBean.class)
                    .setRole(BeanDefinition.ROLE_INFRASTRUCTURE)
                    .addPropertyReference("sockJsTaskScheduler", "defaultSockJsTaskScheduler");

            registry.registerBeanDefinition(WEB_SOCKET_HANDLER_MAPPING_BEAN_NAME,
                    enableWebSocketBuilder.getBeanDefinition());
        }
    }
}

From source file:org.springframework.integration.ws.config.WsIntegrationConfigurationInitializer.java

@Override
public void initialize(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    if (beanFactory instanceof BeanDefinitionRegistry) {
        if (beanFactory.getBeanNamesForType(EndpointAdapter.class, false, false).length > 0) {
            BeanDefinitionBuilder requestMappingBuilder = BeanDefinitionBuilder
                    .genericBeanDefinition(MessageEndpointAdapter.class);
            requestMappingBuilder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            ((BeanDefinitionRegistry) beanFactory).registerBeanDefinition(MESSAGE_ENDPOINT_ADAPTER_BEAN_NAME,
                    requestMappingBuilder.getBeanDefinition());
        }/*from w  w w.j  av  a 2s.c o  m*/
    } else {
        logger.warn("'IntegrationRequestMappingHandlerMapping' isn't registered because 'beanFactory'"
                + " isn't an instance of `BeanDefinitionRegistry`.");
    }
}

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);
    }//from  w ww  .  ja  v a 2  s .  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;
}

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

private BeanDefinition applyPoolingIfApplicable(BeanDefinition targetContextSourceDefinition, Element element,
        boolean nativePooling) {

    Element poolingElement = DomUtils.getChildElementByTagName(element, Elements.POOLING);
    Element pooling2Element = DomUtils.getChildElementByTagName(element, Elements.POOLING2);

    if (pooling2Element != null && poolingElement != null) {
        throw new IllegalArgumentException(
                String.format("%s cannot be enabled together with %s.", Elements.POOLING2, Elements.POOLING));
    } else if (poolingElement == null && pooling2Element == null) {
        return targetContextSourceDefinition;
    }//from   w w  w  . j  a v a 2s .  c om

    if (nativePooling) {
        throw new IllegalArgumentException(
                String.format("%s cannot be enabled together with %s", ATT_NATIVE_POOLING, Elements.POOLING));
    }

    if (pooling2Element != null) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(PooledContextSource.class);
        builder.addPropertyValue("contextSource", targetContextSourceDefinition);

        populatePoolConfigProperties(builder, pooling2Element);

        boolean testOnBorrow = getBoolean(pooling2Element, ATT_TEST_ON_BORROW, false);
        boolean testOnReturn = getBoolean(pooling2Element, ATT_TEST_ON_RETURN, false);
        boolean testWhileIdle = getBoolean(pooling2Element, ATT_TEST_WHILE_IDLE, false);
        boolean testOnCreate = getBoolean(pooling2Element, ATT_TEST_ON_CREATE, false);

        if (testOnBorrow || testOnCreate || testWhileIdle || testOnReturn) {
            populatePoolValidationProperties(builder, pooling2Element);
        }

        return builder.getBeanDefinition();
    } else {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(PoolingContextSource.class);
        builder.addPropertyValue("contextSource", targetContextSourceDefinition);

        builder.addPropertyValue("maxActive",
                getString(poolingElement, ATT_MAX_ACTIVE, String.valueOf(DEFAULT_MAX_ACTIVE)));
        builder.addPropertyValue("maxTotal",
                getString(poolingElement, ATT_MAX_TOTAL, String.valueOf(DEFAULT_MAX_TOTAL)));
        builder.addPropertyValue("maxIdle",
                getString(poolingElement, ATT_MAX_IDLE, String.valueOf(DEFAULT_MAX_IDLE)));
        builder.addPropertyValue("minIdle",
                getString(poolingElement, ATT_MIN_IDLE, String.valueOf(DEFAULT_MIN_IDLE)));
        builder.addPropertyValue("maxWait",
                getString(poolingElement, ATT_MAX_WAIT, String.valueOf(DEFAULT_MAX_WAIT)));
        String whenExhausted = getString(poolingElement, ATT_WHEN_EXHAUSTED, PoolExhaustedAction.BLOCK.name());
        builder.addPropertyValue("whenExhaustedAction", PoolExhaustedAction.valueOf(whenExhausted).getValue());
        builder.addPropertyValue("timeBetweenEvictionRunsMillis", getString(poolingElement,
                ATT_EVICTION_RUN_MILLIS, String.valueOf(DEFAULT_EVICTION_RUN_MILLIS)));
        builder.addPropertyValue("minEvictableIdleTimeMillis",
                getString(poolingElement, ATT_EVICTABLE_TIME_MILLIS, String.valueOf(DEFAULT_EVICTABLE_MILLIS)));
        builder.addPropertyValue("numTestsPerEvictionRun", getString(poolingElement, ATT_TESTS_PER_EVICTION_RUN,
                String.valueOf(DEFAULT_TESTS_PER_EVICTION_RUN)));

        boolean testOnBorrow = getBoolean(poolingElement, ATT_TEST_ON_BORROW, false);
        boolean testOnReturn = getBoolean(poolingElement, ATT_TEST_ON_RETURN, false);
        boolean testWhileIdle = getBoolean(poolingElement, ATT_TEST_WHILE_IDLE, false);

        if (testOnBorrow || testOnReturn || testWhileIdle) {
            populatePoolValidationProperties(builder, poolingElement, testOnBorrow, testOnReturn,
                    testWhileIdle);
        }

        return builder.getBeanDefinition();
    }
}

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

private void populatePoolValidationProperties(BeanDefinitionBuilder builder, Element element,
        boolean testOnBorrow, boolean testOnReturn, boolean testWhileIdle) {

    builder.addPropertyValue("testOnBorrow", testOnBorrow);
    builder.addPropertyValue("testOnReturn", testOnReturn);
    builder.addPropertyValue("testWhileIdle", testWhileIdle);

    BeanDefinitionBuilder validatorBuilder = BeanDefinitionBuilder
            .rootBeanDefinition(DefaultDirContextValidator.class);
    validatorBuilder.addPropertyValue("base", getString(element, ATT_VALIDATION_QUERY_BASE, ""));
    validatorBuilder.addPropertyValue("filter",
            getString(element, ATT_VALIDATION_QUERY_FILTER, DefaultDirContextValidator.DEFAULT_FILTER));
    String searchControlsRef = element.getAttribute(ATT_VALIDATION_QUERY_SEARCH_CONTROLS_REF);
    if (StringUtils.hasText(searchControlsRef)) {
        validatorBuilder.addPropertyReference("searchControls", searchControlsRef);
    }//w w  w.  ja  v  a2  s .  co m
    builder.addPropertyValue("dirContextValidator", validatorBuilder.getBeanDefinition());

    builder.addPropertyValue("timeBetweenEvictionRunsMillis",
            getString(element, ATT_EVICTION_RUN_MILLIS, String.valueOf(DEFAULT_EVICTION_RUN_MILLIS)));
    builder.addPropertyValue("numTestsPerEvictionRun",
            getInt(element, ATT_TESTS_PER_EVICTION_RUN, DEFAULT_TESTS_PER_EVICTION_RUN));
    builder.addPropertyValue("minEvictableIdleTimeMillis",
            getString(element, ATT_EVICTABLE_TIME_MILLIS, String.valueOf(DEFAULT_EVICTABLE_MILLIS)));

    String nonTransientExceptions = getString(element, ATT_NON_TRANSIENT_EXCEPTIONS,
            CommunicationException.class.getName());
    String[] strings = StringUtils.commaDelimitedListToStringArray(nonTransientExceptions);
    Set<Class<?>> nonTransientExceptionClasses = new HashSet<Class<?>>();
    for (String className : strings) {
        try {
            nonTransientExceptionClasses.add(ClassUtils.getDefaultClassLoader().loadClass(className));
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException(String.format("%s is not a valid class name", className), e);
        }
    }

    builder.addPropertyValue("nonTransientExceptions", nonTransientExceptionClasses);
}

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

private void populatePoolValidationProperties(BeanDefinitionBuilder builder, Element element) {

    BeanDefinitionBuilder validatorBuilder = BeanDefinitionBuilder
            .rootBeanDefinition(org.springframework.ldap.pool2.validation.DefaultDirContextValidator.class);
    validatorBuilder.addPropertyValue("base", getString(element, ATT_VALIDATION_QUERY_BASE, ""));
    validatorBuilder.addPropertyValue("filter", getString(element, ATT_VALIDATION_QUERY_FILTER,
            org.springframework.ldap.pool2.validation.DefaultDirContextValidator.DEFAULT_FILTER));
    String searchControlsRef = element.getAttribute(ATT_VALIDATION_QUERY_SEARCH_CONTROLS_REF);
    if (StringUtils.hasText(searchControlsRef)) {
        validatorBuilder.addPropertyReference("searchControls", searchControlsRef);
    }/*  w  w w .  j  a  v a  2  s .c  om*/
    builder.addPropertyValue("dirContextValidator", validatorBuilder.getBeanDefinition());

    String nonTransientExceptions = getString(element, ATT_NON_TRANSIENT_EXCEPTIONS,
            CommunicationException.class.getName());
    String[] strings = StringUtils.commaDelimitedListToStringArray(nonTransientExceptions);
    Set<Class<?>> nonTransientExceptionClasses = new HashSet<Class<?>>();
    for (String className : strings) {
        try {
            nonTransientExceptionClasses.add(ClassUtils.getDefaultClassLoader().loadClass(className));
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException(String.format("%s is not a valid class name", className), e);
        }
    }

    builder.addPropertyValue("nonTransientExceptions", nonTransientExceptionClasses);
}

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

private void populatePoolConfigProperties(BeanDefinitionBuilder builder, Element element) {
    BeanDefinitionBuilder configBuilder = BeanDefinitionBuilder.rootBeanDefinition(PoolConfig.class);

    configBuilder.addPropertyValue("maxTotal",
            getString(element, ATT_MAX_TOTAL, String.valueOf(DEFAULT_MAX_TOTAL)));
    configBuilder.addPropertyValue("maxTotalPerKey",
            getString(element, ATT_MAX_TOTAL_PER_KEY, String.valueOf(DEFAULT_MAX_TOTAL_PER_KEY)));
    configBuilder.addPropertyValue("maxIdlePerKey",
            getString(element, ATT_MAX_IDLE_PER_KEY, String.valueOf(DEFAULT_MAX_IDLE_PER_KEY)));
    configBuilder.addPropertyValue("minIdlePerKey",
            getString(element, ATT_MIN_IDLE_PER_KEY, String.valueOf(DEFAULT_MIN_IDLE_PER_KEY)));
    configBuilder.addPropertyValue("evictionPolicyClassName",
            getString(element, ATT_EVICTION_POLICY_CLASS, DEFAULT_EVICTION_POLICY_CLASS_NAME));
    configBuilder.addPropertyValue("fairness", getBoolean(element, ATT_FAIRNESS, DEFAULT_FAIRNESS));
    configBuilder.addPropertyValue("jmxEnabled", getBoolean(element, ATT_JMX_ENABLE, DEFAULT_JMX_ENABLE));
    configBuilder.addPropertyValue("jmxNameBase", getString(element, ATT_JMX_NAME_BASE, DEFAULT_JMX_NAME_BASE));
    configBuilder.addPropertyValue("jmxNamePrefix",
            getString(element, ATT_JMX_NAME_PREFIX, DEFAULT_JMX_NAME_PREFIX));
    configBuilder.addPropertyValue("lifo", getBoolean(element, ATT_LIFO, DEFAULT_LIFO));
    configBuilder.addPropertyValue("maxWaitMillis",
            getString(element, ATT_MAX_WAIT, String.valueOf(DEFAULT_MAX_WAIT_MILLIS)));
    configBuilder.addPropertyValue("blockWhenExhausted", Boolean.valueOf(
            getString(element, ATT_BLOCK_WHEN_EXHAUSTED, String.valueOf(DEFAULT_BLOCK_WHEN_EXHAUSTED))));
    configBuilder.addPropertyValue("testOnBorrow", getBoolean(element, ATT_TEST_ON_BORROW, false));
    configBuilder.addPropertyValue("testOnCreate", getBoolean(element, ATT_TEST_ON_CREATE, false));
    configBuilder.addPropertyValue("testOnReturn", getBoolean(element, ATT_TEST_ON_RETURN, false));
    configBuilder.addPropertyValue("testWhileIdle", getBoolean(element, ATT_TEST_WHILE_IDLE, false));
    configBuilder.addPropertyValue("timeBetweenEvictionRunsMillis",
            getString(element, ATT_EVICTION_RUN_MILLIS, String.valueOf(DEFAULT_EVICTION_RUN_MILLIS)));
    configBuilder.addPropertyValue("numTestsPerEvictionRun",
            getString(element, ATT_TESTS_PER_EVICTION_RUN, String.valueOf(DEFAULT_TESTS_PER_EVICTION_RUN)));
    configBuilder.addPropertyValue("minEvictableIdleTimeMillis",
            getString(element, ATT_EVICTABLE_TIME_MILLIS, String.valueOf(DEFAULT_EVICTABLE_MILLIS)));
    configBuilder.addPropertyValue("softMinEvictableIdleTimeMillis",
            getString(element, ATT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS,
                    String.valueOf(DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS)));

    builder.addConstructorArgValue(configBuilder.getBeanDefinition());
}

From source file:org.springframework.security.config.authentication.PasswordEncoderParser.java

public static BeanDefinition createPasswordEncoderBeanDefinition(String hash, boolean useBase64) {
    Class<?> beanClass = ENCODER_CLASSES.get(hash);
    BeanDefinitionBuilder beanBldr = BeanDefinitionBuilder.rootBeanDefinition(beanClass);
    return beanBldr.getBeanDefinition();
}

From source file:org.springframework.security.config.debug.SecurityDebugBeanFactoryPostProcessor.java

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    logger.warn("\n\n" + "********************************************************************\n"
            + "**********        Security debugging is enabled.       *************\n"
            + "**********    This may include sensitive information.  *************\n"
            + "**********      Do not use in a production system!     *************\n"
            + "********************************************************************\n\n");
    // SPRING_SECURITY_FILTER_CHAIN does not exist yet since it is an alias that has
    // not been processed, so use FILTER_CHAIN_PROXY
    if (registry.containsBeanDefinition(BeanIds.FILTER_CHAIN_PROXY)) {
        BeanDefinition fcpBeanDef = registry.getBeanDefinition(BeanIds.FILTER_CHAIN_PROXY);
        BeanDefinitionBuilder debugFilterBldr = BeanDefinitionBuilder.genericBeanDefinition(DebugFilter.class);
        debugFilterBldr.addConstructorArgValue(fcpBeanDef);
        // Remove the alias to SPRING_SECURITY_FILTER_CHAIN, so that it does not
        // override the new
        // SPRING_SECURITY_FILTER_CHAIN definition
        registry.removeAlias(BeanIds.SPRING_SECURITY_FILTER_CHAIN);
        registry.registerBeanDefinition(BeanIds.SPRING_SECURITY_FILTER_CHAIN,
                debugFilterBldr.getBeanDefinition());
    }//from   w w  w .j  ava2 s .c  o m
}