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

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

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

Introduction

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

Prototype

public BeanDefinitionBuilder addPropertyReference(String name, String beanName)

Source Link

Document

Add a reference to the specified bean name under the property specified.

Usage

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 ww w.  j  a  va2 s  .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.RepositoryBeanDefinitionBuilder.java

/**
 * Builds a new {@link BeanDefinitionBuilder} from the given {@link BeanDefinitionRegistry} and {@link ResourceLoader}
 * .//  ww  w.  java2  s.  com
 * 
 * @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.RemotingAnnotationPostProcessor.java

/**
 * //w w w . j a  v  a2  s .co 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   w ww .j a v a 2s . 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.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  a2s  .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.xml.DefaultConfiguringBeanFactoryPostProcessor.java

/**
 * Register a TaskScheduler in the given BeanDefinitionRegistry.
 *///from w  ww.ja  v  a 2s  .  co 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);
}

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  a2s.  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 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  ww . jav  a  2s . 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);
    }// ww w .  ja  v a2s.  c  o m
    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.security.config.http.AuthenticationConfigBuilder.java

private void injectAuthenticationDetailsSource(Element elt, BeanDefinitionBuilder filterBuilder) {
    String authDetailsSourceRef = elt.getAttribute(AuthenticationConfigBuilder.ATT_AUTH_DETAILS_SOURCE_REF);

    if (StringUtils.hasText(authDetailsSourceRef)) {
        filterBuilder.addPropertyReference("authenticationDetailsSource", authDetailsSourceRef);
    }//  w ww .  j  av  a  2 s .  c  o m
}