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

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

Introduction

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

Prototype

public BeanDefinitionBuilder addConstructorArgReference(String beanName) 

Source Link

Document

Add a reference to a named bean as a constructor arg.

Usage

From source file:org.brekka.stillingar.spring.config.NamespaceBeanDefinitionParser.java

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    String prefix = element.getAttribute("prefix");
    String uri = element.getAttribute("uri");
    if (uri == null) {
        // Older versions had the attribute incorrectly named 'url'.
        uri = element.getAttribute("url");
    }// www  .j a  v a 2 s. c om
    String serviceRef = element.getAttribute("service-ref");
    String namespaceContextId = serviceRef + "-Namespaces";
    try {
        BeanDefinition namespaceBeanDefinition = parserContext.getRegistry()
                .getBeanDefinition(namespaceContextId);
        // In the same context, make sure to register the namespace as early as possible.
        ConstructorArgumentValues constructorArgumentValues = namespaceBeanDefinition
                .getConstructorArgumentValues();
        ValueHolder valueHolder = constructorArgumentValues.getIndexedArgumentValue(0, null);
        Object value = valueHolder.getValue();
        ManagedArray array = (ManagedArray) value;
        array.add(prefix);
        array.add(uri);
    } catch (NoSuchBeanDefinitionException e) {
        if (log.isInfoEnabled()) {
            log.info(String.format("No namespaces context found with id '%s' in the current container",
                    namespaceContextId), e);
        }
    }
    builder.addConstructorArgReference(serviceRef + "-Namespaces");
    builder.addConstructorArgValue(uri);
    builder.addConstructorArgValue(prefix);
}

From source file:com.consol.citrus.selenium.xml.WebClientConfigurationParser.java

@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(WebClient.class);

    BeanDefinitionBuilder configurationBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(WebClientConfiguration.class);

    BeanDefinitionParserUtils.setPropertyValue(configurationBuilder, element.getAttribute("browser-type"),
            "browserType");
    BeanDefinitionParserUtils.setPropertyValue(configurationBuilder, element.getAttribute("start-url"),
            "startUrl");
    BeanDefinitionParserUtils.setPropertyValue(configurationBuilder, element.getAttribute("model-namespace"),
            "modelNamespace");
    BeanDefinitionParserUtils.setPropertyValue(configurationBuilder, element.getAttribute("selenium-server"),
            "seleniumServer");
    BeanDefinitionParserUtils.setPropertyValue(configurationBuilder, element.getAttribute("enable-javascript"),
            "enableJavascript");

    if (element.hasAttribute("error-strategy")) {
        configurationBuilder.addPropertyValue("errorHandlingStrategy",
                ErrorHandlingStrategy.fromName(element.getAttribute("error-strategy")));
    }/*from  w  ww  . jav a2  s  .  c o  m*/

    String clientConfigurationId = element.getAttribute(ID_ATTRIBUTE) + "Configuration";
    BeanDefinitionParserUtils.registerBean(clientConfigurationId, configurationBuilder.getBeanDefinition(),
            parserContext, shouldFireEvents());

    builder.addConstructorArgReference(clientConfigurationId);

    return builder.getBeanDefinition();
}

From source file:sipackage.config.xml.SIAdapterUpperPrefixOutboundGatewayParser.java

@Override
protected BeanDefinitionBuilder parseHandler(Element gatewayElement, ParserContext parserContext) {

    final BeanDefinitionBuilder siAdapterLowerPrefixOutboundGatewayBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(SIAdapterUpperPrefixOutboundGateway.class);

    IntegrationNamespaceUtils.setValueIfAttributeDefined(siAdapterLowerPrefixOutboundGatewayBuilder,
            gatewayElement, "reply-timeout", "sendTimeout");

    final String replyChannel = gatewayElement.getAttribute("reply-channel");

    if (StringUtils.hasText(replyChannel)) {
        siAdapterLowerPrefixOutboundGatewayBuilder.addPropertyReference("outputChannel", replyChannel);
    }/*from   w ww.  ja  v  a  2 s  .c  o  m*/

    final BeanDefinitionBuilder siAdapterLowerPrefixExecutorBuilder = SIAdapterUpperPrefixParserUtils
            .getSIAdapterUpperPrefixExecutorBuilder(gatewayElement, parserContext);

    IntegrationNamespaceUtils.setValueIfAttributeDefined(siAdapterLowerPrefixExecutorBuilder, gatewayElement,
            "example-property");

    final BeanDefinition siAdapterLowerPrefixExecutorBuilderBeanDefinition = siAdapterLowerPrefixExecutorBuilder
            .getBeanDefinition();
    final String gatewayId = this.resolveId(gatewayElement,
            siAdapterLowerPrefixOutboundGatewayBuilder.getRawBeanDefinition(), parserContext);
    final String siAdapterLowerPrefixExecutorBeanName = gatewayId + ".siAdapterLowerPrefixExecutor";

    parserContext.registerBeanComponent(new BeanComponentDefinition(
            siAdapterLowerPrefixExecutorBuilderBeanDefinition, siAdapterLowerPrefixExecutorBeanName));

    siAdapterLowerPrefixOutboundGatewayBuilder.addConstructorArgReference(siAdapterLowerPrefixExecutorBeanName);

    return siAdapterLowerPrefixOutboundGatewayBuilder;

}

From source file:org.opencredo.couchdb.config.CouchDbInboundChannelAdapterParser.java

@Override
protected BeanMetadataElement parseSource(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder = null;
    String databaseUrl = element.getAttribute(COUCHDB_DATABASE_URL_ATTRIBUTE);
    String changesOperations = element.getAttribute(COUCHDB_CHANGES_OPERATIONS_ATTRIBUTE);
    String allDocuments = element.getAttribute(COUCHDB_ALL_DOCUMENTS_ATTRIBUTE);
    String allDocumentsLimit = element.getAttribute(COUCHDB_ALL_DOCUMENTS_LIMIT_ATTRIBUTE);

    if (StringUtils.hasText(databaseUrl)) {
        if (StringUtils.hasText(changesOperations)) {
            parserContext.getReaderContext().error("At most one of '" + COUCHDB_DATABASE_URL_ATTRIBUTE
                    + "' and '" + COUCHDB_CHANGES_OPERATIONS_ATTRIBUTE + "' may be provided.", element);
        } else {/*from w w  w .jav  a2s. c o  m*/
            if ("true".equals(allDocuments)) {
                builder = BeanDefinitionBuilder.genericBeanDefinition(CouchDbAllDocumentsMessageSource.class);
            } else {
                builder = BeanDefinitionBuilder.genericBeanDefinition(CouchDbChangesPollingMessageSource.class);
            }
            builder.addConstructorArgValue(databaseUrl);
        }
    } else if (StringUtils.hasText(changesOperations)) {
        // changesOperations and allDocuments are XOR
        if ("true".equals(allDocuments)) {
            parserContext.getReaderContext().error("At most one of '" + COUCHDB_ALL_DOCUMENTS_ATTRIBUTE
                    + "' and '" + COUCHDB_CHANGES_OPERATIONS_ATTRIBUTE + "' may be provided.", element);
        } else {
            builder = BeanDefinitionBuilder.genericBeanDefinition(CouchDbChangesPollingMessageSource.class);
            builder.addConstructorArgReference(changesOperations);
        }
    } else {
        parserContext.getReaderContext().error("Either '" + COUCHDB_DATABASE_URL_ATTRIBUTE + "' or '"
                + COUCHDB_CHANGES_OPERATIONS_ATTRIBUTE + "' must be provided.", element);
    }

    if ("true".equals(allDocuments)) {
        builder.addConstructorArgValue(Integer.valueOf(allDocumentsLimit));
    }

    String beanName = BeanDefinitionReaderUtils.registerWithGeneratedName(builder.getBeanDefinition(),
            parserContext.getRegistry());
    return new RuntimeBeanReference(beanName);
}

From source file:net.shibboleth.idp.profile.spring.relyingparty.metadata.impl.HTTPMetadataProviderParser.java

/** {@inheritDoc} */
// Checkstyle: CyclomaticComplexity OFF
@Override/*www  .  j av  a  2  s  . c  om*/
protected void doNativeParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    super.doNativeParse(element, parserContext, builder);

    if (element.hasAttributeNS(null, "cacheDuration")) {
        log.error("{}: cacheDuration is not supported",
                parserContext.getReaderContext().getResource().getDescription());
        throw new BeanDefinitionParsingException(new Problem("cacheDuration is not supported",
                new Location(parserContext.getReaderContext().getResource())));
    }

    if (element.hasAttributeNS(null, "maintainExpiredMetadata")) {
        log.error("{}: maintainExpiredMetadata is not supported",
                parserContext.getReaderContext().getResource().getDescription());
        throw new BeanDefinitionParsingException(new Problem("maintainExpiredMetadata is not supported",
                new Location(parserContext.getReaderContext().getResource())));
    }

    boolean haveTLSTrustEngine = false;
    if (element.hasAttributeNS(null, "tlsTrustEngineRef")) {
        builder.addPropertyReference("tLSTrustEngine",
                StringSupport.trimOrNull(element.getAttributeNS(null, "tlsTrustEngineRef")));
        haveTLSTrustEngine = true;
    } else {
        BeanDefinition tlsTrustEngine = parseTLSTrustEngine(element, parserContext);
        if (tlsTrustEngine != null) {
            builder.addPropertyValue("tLSTrustEngine", tlsTrustEngine);
            haveTLSTrustEngine = true;
        }
    }

    if (element.hasAttributeNS(null, "httpClientRef")) {
        builder.addConstructorArgReference(
                StringSupport.trimOrNull(element.getAttributeNS(null, "httpClientRef")));
        if (element.hasAttributeNS(null, "requestTimeout")
                || element.hasAttributeNS(null, "disregardSslCertificate")
                || element.hasAttributeNS(null, "disregardTLSCertificate")
                || element.hasAttributeNS(null, "proxyHost") || element.hasAttributeNS(null, "proxyPort")
                || element.hasAttributeNS(null, "proxyUser") || element.hasAttributeNS(null, "proxyPassword")) {
            log.warn("httpClientRef overrides settings for requestTimeout, disregardSslCertificate, "
                    + "disregardTLSCertificate, proxyHost, proxyPort, proxyUser and proxyPassword");
        }
    } else {
        builder.addConstructorArgValue(buildHttpClient(element, parserContext, haveTLSTrustEngine));
    }
    builder.addConstructorArgValue(StringSupport.trimOrNull(element.getAttributeNS(null, METADATA_URL)));

    if (element.hasAttributeNS(null, BASIC_AUTH_USER) || element.hasAttributeNS(null, BASIC_AUTH_PASSWORD)) {
        builder.addPropertyValue("basicCredentials", buildBasicCredentials(element));
    }

}

From source file:org.brekka.stillingar.spring.config.ConfigurationServiceBeanDefinitionParser.java

/**
 * @param element//from  w w w . j ava  2s.c  om
 * @param builder
 */
protected void prepareJAXB(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    Element jaxbElement = selectSingleChildElement(element, "jaxb", false);

    // Path
    String contextPath = jaxbElement.getAttribute("context-path");
    builder.addConstructorArgValue(contextPath);

    // Schemas
    List<Element> schemaElementList = selectChildElements(jaxbElement, "schema");
    ManagedList<URL> schemaUrlList = new ManagedList<URL>(schemaElementList.size());
    for (Element schemaElement : schemaElementList) {
        String schemaPath = schemaElement.getTextContent();
        try {
            Resource resource = parserContext.getReaderContext().getResourceLoader().getResource(schemaPath);
            schemaUrlList.add(resource.getURL());
        } catch (IOException e) {
            throw new ConfigurationException(String.format("Failed to parse schema location '%s'", schemaPath),
                    e);
        }
    }
    builder.addConstructorArgValue(schemaUrlList);

    // Namespaces
    builder.addConstructorArgReference(this.namespacesId);

    // ConversionManager
    builder.addConstructorArgValue(prepareJAXBConversionManager());
}

From source file:org.drools.container.spring.namespace.KnowledgeSessionDefinitionParser.java

@SuppressWarnings("unchecked")
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {

    String id = element.getAttribute("id");
    emptyAttributeCheck(element.getLocalName(), "id", id);

    String kbase = element.getAttribute(KBASE_ATTRIBUTE);
    emptyAttributeCheck(element.getLocalName(), KBASE_ATTRIBUTE, kbase);

    String sessionType = element.getAttribute(TYPE_ATTRIBUTE);
    BeanDefinitionBuilder factory;//from  w ww .  ja va  2  s .c om

    if ("stateful".equals(sessionType)) {
        factory = BeanDefinitionBuilder.rootBeanDefinition(StatefulKnowledgeSessionBeanFactory.class);
    } else if ("stateless".equals(sessionType)) {
        factory = BeanDefinitionBuilder.rootBeanDefinition(StatelessKnowledgeSessionBeanFactory.class);
    } else {
        throw new IllegalArgumentException(
                "Invalid value for " + TYPE_ATTRIBUTE + " attribute: " + sessionType);
    }

    factory.addPropertyReference("kbase", kbase);

    String node = element.getAttribute(GRID_NODE_ATTRIBUTE);
    if (node != null && node.length() > 0) {
        factory.addPropertyReference("node", node);
    }

    String name = element.getAttribute(NAME_ATTRIBUTE);
    if (StringUtils.hasText(name)) {
        factory.addPropertyValue("name", name);
    } else {
        factory.addPropertyValue("name", id);
    }

    // Additions for JIRA JBRULES-3076
    String listeners = element.getAttribute(LISTENERS_ATTRIBUTE);
    if (StringUtils.hasText(listeners)) {
        factory.addPropertyValue("eventListenersFromGroup", new RuntimeBeanReference(listeners));
    }
    EventListenersUtil.parseEventListeners(parserContext, factory, element);
    // End of Additions for JIRA JBRULES-3076

    Element ksessionConf = DomUtils.getChildElementByTagName(element, "configuration");
    if (ksessionConf != null) {
        Element persistenceElm = DomUtils.getChildElementByTagName(ksessionConf, "jpa-persistence");
        if (persistenceElm != null) {
            BeanDefinitionBuilder beanBuilder = BeanDefinitionBuilder
                    .genericBeanDefinition(JpaConfiguration.class);

            String loadId = persistenceElm.getAttribute("load");
            if (StringUtils.hasText(loadId)) {
                beanBuilder.addPropertyValue("id", Long.parseLong(loadId));
            }

            Element tnxMng = DomUtils.getChildElementByTagName(persistenceElm, TX_MANAGER_ATTRIBUTE);
            String ref = tnxMng.getAttribute("ref");

            beanBuilder.addPropertyReference("platformTransactionManager", ref);

            Element emf = DomUtils.getChildElementByTagName(persistenceElm, EMF_ATTRIBUTE);
            ref = emf.getAttribute("ref");
            beanBuilder.addPropertyReference("entityManagerFactory", ref);

            Element variablePersisters = DomUtils.getChildElementByTagName(persistenceElm,
                    "variable-persisters");
            if (variablePersisters != null && variablePersisters.hasChildNodes()) {
                List<Element> childPersisterElems = DomUtils.getChildElementsByTagName(variablePersisters,
                        "persister");
                ManagedMap persistors = new ManagedMap(childPersisterElems.size());
                for (Element persisterElem : childPersisterElems) {
                    String forClass = persisterElem.getAttribute(FORCLASS_ATTRIBUTE);
                    String implementation = persisterElem.getAttribute(IMPLEMENTATION_ATTRIBUTE);
                    if (!StringUtils.hasText(forClass)) {
                        throw new RuntimeException("persister element must have valid for-class attribute");
                    }
                    if (!StringUtils.hasText(implementation)) {
                        throw new RuntimeException(
                                "persister element must have valid implementation attribute");
                    }
                    persistors.put(forClass, implementation);
                }
                beanBuilder.addPropertyValue("variablePersisters", persistors);
            }

            factory.addPropertyValue("jpaConfiguration", beanBuilder.getBeanDefinition());
        }
        BeanDefinitionBuilder rbaseConfBuilder = BeanDefinitionBuilder
                .rootBeanDefinition(SessionConfiguration.class);
        Element e = DomUtils.getChildElementByTagName(ksessionConf, KEEP_REFERENCE);
        if (e != null && StringUtils.hasText(e.getAttribute("enabled"))) {
            rbaseConfBuilder.addPropertyValue("keepReference", Boolean.parseBoolean(e.getAttribute("enabled")));
        }

        e = DomUtils.getChildElementByTagName(ksessionConf, CLOCK_TYPE);
        if (e != null && StringUtils.hasText(e.getAttribute("type"))) {
            rbaseConfBuilder.addPropertyValue("clockType", ClockType.resolveClockType(e.getAttribute("type")));
        }
        factory.addPropertyValue("conf", rbaseConfBuilder.getBeanDefinition());

        e = DomUtils.getChildElementByTagName(ksessionConf, WORK_ITEMS);
        if (e != null) {
            List<Element> children = DomUtils.getChildElementsByTagName(e, WORK_ITEM);
            if (children != null && !children.isEmpty()) {
                ManagedMap workDefs = new ManagedMap();
                for (Element child : children) {
                    workDefs.put(child.getAttribute("name"),
                            new RuntimeBeanReference(child.getAttribute("ref")));
                }
                factory.addPropertyValue("workItems", workDefs);
            }
        }
    }

    Element batch = DomUtils.getChildElementByTagName(element, "batch");
    if (batch == null) {
        // just temporary legacy suppport
        batch = DomUtils.getChildElementByTagName(element, "script");
    }
    if (batch != null) {
        // we know there can only ever be one
        ManagedList children = new ManagedList();

        for (int i = 0, length = batch.getChildNodes().getLength(); i < length; i++) {
            Node n = batch.getChildNodes().item(i);
            if (n instanceof Element) {
                Element e = (Element) n;

                BeanDefinitionBuilder beanBuilder = null;
                if ("insert-object".equals(e.getLocalName())) {
                    String ref = e.getAttribute("ref");
                    Element nestedElm = getFirstElement(e.getChildNodes());
                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(InsertObjectCommand.class);
                    if (StringUtils.hasText(ref)) {
                        beanBuilder.addConstructorArgReference(ref);
                    } else if (nestedElm != null) {
                        beanBuilder.addConstructorArgValue(
                                parserContext.getDelegate().parsePropertySubElement(nestedElm, null, null));
                    } else {
                        throw new IllegalArgumentException(
                                "insert-object must either specify a 'ref' attribute or have a nested bean");
                    }
                } else if ("set-global".equals(e.getLocalName())) {
                    String ref = e.getAttribute("ref");
                    Element nestedElm = getFirstElement(e.getChildNodes());
                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(SetGlobalCommand.class);
                    beanBuilder.addConstructorArgValue(e.getAttribute("identifier"));
                    if (StringUtils.hasText(ref)) {
                        beanBuilder.addConstructorArgReference(ref);
                    } else if (nestedElm != null) {
                        beanBuilder.addConstructorArgValue(
                                parserContext.getDelegate().parsePropertySubElement(nestedElm, null, null));
                    } else {
                        throw new IllegalArgumentException(
                                "set-global must either specify a 'ref' attribute or have a nested bean");
                    }
                } else if ("fire-until-halt".equals(e.getLocalName())) {
                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(FireUntilHaltCommand.class);
                } else if ("fire-all-rules".equals(e.getLocalName())) {
                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(FireAllRulesCommand.class);
                    String max = e.getAttribute("max");
                    if (StringUtils.hasText(max)) {
                        beanBuilder.addPropertyValue("max", max);
                    }
                } else if ("start-process".equals(e.getLocalName())) {

                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(StartProcessCommand.class);
                    String processId = e.getAttribute("process-id");
                    if (!StringUtils.hasText(processId)) {
                        throw new IllegalArgumentException("start-process must specify a process-id");
                    }
                    beanBuilder.addConstructorArgValue(processId);

                    List<Element> params = DomUtils.getChildElementsByTagName(e, "parameter");
                    if (!params.isEmpty()) {
                        ManagedMap map = new ManagedMap();
                        for (Element param : params) {
                            String identifier = param.getAttribute("identifier");
                            if (!StringUtils.hasText(identifier)) {
                                throw new IllegalArgumentException(
                                        "start-process paramaters must specify an identifier");
                            }

                            String ref = param.getAttribute("ref");
                            Element nestedElm = getFirstElement(param.getChildNodes());
                            if (StringUtils.hasText(ref)) {
                                map.put(identifier, new RuntimeBeanReference(ref));
                            } else if (nestedElm != null) {
                                map.put(identifier, parserContext.getDelegate()
                                        .parsePropertySubElement(nestedElm, null, null));
                            } else {
                                throw new IllegalArgumentException(
                                        "start-process parameters must either specify a 'ref' attribute or have a nested bean");
                            }
                        }
                        beanBuilder.addPropertyValue("parameters", map);
                    }
                } else if ("signal-event".equals(e.getLocalName())) {
                    beanBuilder = BeanDefinitionBuilder.genericBeanDefinition(SignalEventCommand.class);
                    String processInstanceId = e.getAttribute("process-instance-id");
                    if (StringUtils.hasText(processInstanceId)) {
                        beanBuilder.addConstructorArgValue(processInstanceId);
                    }

                    beanBuilder.addConstructorArgValue(e.getAttribute("event-type"));

                    String ref = e.getAttribute("ref");
                    Element nestedElm = getFirstElement(e.getChildNodes());
                    if (StringUtils.hasText(ref)) {
                        beanBuilder.addConstructorArgReference(ref);
                    } else if (nestedElm != null) {
                        beanBuilder.addConstructorArgValue(
                                parserContext.getDelegate().parsePropertySubElement(nestedElm, null, null));
                    } else {
                        throw new IllegalArgumentException(
                                "signal-event must either specify a 'ref' attribute or have a nested bean");
                    }
                }
                if (beanBuilder == null) {
                    throw new IllegalStateException("Unknow element: " + e.getLocalName());
                }
                children.add(beanBuilder.getBeanDefinition());
            }
        }
        factory.addPropertyValue("batch", children);
    }

    // find any kagent's for the current kbase and assign (only if this 
    // is a stateless session)
    if (sessionType.equals("stateless")) {
        for (String beanName : parserContext.getRegistry().getBeanDefinitionNames()) {
            BeanDefinition def = parserContext.getRegistry().getBeanDefinition(beanName);
            if (KnowledgeAgentBeanFactory.class.getName().equals(def.getBeanClassName())) {
                PropertyValue pvalue = def.getPropertyValues().getPropertyValue("kbase");
                RuntimeBeanReference tbf = (RuntimeBeanReference) pvalue.getValue();
                if (kbase.equals(tbf.getBeanName())) {
                    factory.addPropertyValue("knowledgeAgent", new RuntimeBeanReference(beanName));
                }
            }
        }
    }

    return factory.getBeanDefinition();
}

From source file:nl.surfnet.spring.security.opensaml.config.ServiceProviderBeanDefinitionParser.java

@Override
protected AbstractBeanDefinition parseInternal(final Element element, final ParserContext parserContext) {

    final String preAuthFilterRef = element.getAttribute("preauth-filter-ref");
    if (StringUtils.isBlank(preAuthFilterRef)) {
        parserContext.getReaderContext().error("The preauth-filter-ref is mandatory", element);
    }/*w  ww  . j av a  2 s  .  com*/

    final String messageHandlerRef = element.getAttribute("message-handler-ref");
    if (StringUtils.isBlank(messageHandlerRef)) {
        parserContext.getReaderContext().error("The message-handler-ref is mandatory", element);
    }

    final String certificatestoreRef = element.getAttribute("certificatestore-ref");
    if (StringUtils.isBlank(certificatestoreRef)) {
        parserContext.getReaderContext().error("The certificatestore-ref is mandatory", element);
    }

    final String provisionerRef = element.getAttribute("provisioner-ref");
    if (StringUtils.isBlank(provisionerRef)) {
        parserContext.getReaderContext().error("The provisioner-ref is mandatory", element);
    }

    final String authenticationManangerRef = element.getAttribute("authentication-manager-ref");
    if (StringUtils.isBlank(authenticationManangerRef)) {
        parserContext.getReaderContext().error("The authentication-manager-ref is mandatory", element);
    }

    final String entityID = element.getAttribute("entity-id");
    if (StringUtils.isBlank(entityID)) {
        parserContext.getReaderContext().error("The entity-id is mandatory", element);
    }

    final String assertionConsumerURI = element.getAttribute("assertion-consumer-uri");
    if (StringUtils.isBlank(assertionConsumerURI)) {
        parserContext.getReaderContext().error("Missing or empty assertion-consumer-uri.", element);
    }

    final String poolSize = element.getAttribute("max-parser-pool-size");
    try {
        poolSizeInt = Integer.parseInt(poolSize);
    } catch (NumberFormatException nfe) {
        parserContext.getReaderContext().error("An invalid value for max-parser-pool-size was supplied",
                element);
    }

    final String replayCacheLife = element.getAttribute("replay-cache-life-in-millis");
    try {
        replayCacheDuration = Integer.parseInt(replayCacheLife);
    } catch (NumberFormatException nfe) {
        parserContext.getReaderContext().error("An invalid value for replay-cache-life-in-millis was supplied",
                element);
    }

    final String clockSkew = element.getAttribute("issue-instant-check-clock-skew-in-secs");
    try {
        newClockSkew = Integer.parseInt(clockSkew);
    } catch (NumberFormatException nfe) {
        parserContext.getReaderContext()
                .error("An invalid value for issue-instant-check-clock-skew-in-secs was supplied", element);
    }

    final String validTime = element.getAttribute("issue-instant-check-valid-time-in-secs");
    try {
        newExpires = Integer.parseInt(validTime);
    } catch (NumberFormatException nfe) {
        parserContext.getReaderContext()
                .error("An invalid value for issue-instant-check-valid-time-in-secs was supplied", element);
    }

    BeanDefinitionBuilder bootstrapBean = BeanDefinitionBuilder.genericBeanDefinition(DefaultBootstrap.class);
    bootstrapBean.setInitMethodName("bootstrap");
    parserContext.getRegistry().registerBeanDefinition(BEAN_SAMLINITIALIZER, bootstrapBean.getBeanDefinition());

    final BasicParserPool basicParserPool = new BasicParserPool();
    basicParserPool.setMaxPoolSize(poolSizeInt);

    final HTTPPostSimpleSignDecoder httpPostSimpleSignDecoder = new HTTPPostSimpleSignDecoder(basicParserPool);

    final VelocityEngineFactoryBean velocityEngineFactoryBean = new VelocityEngineFactoryBean();
    velocityEngineFactoryBean.setPreferFileSystemAccess(false);
    Properties velocityEngineProperties = new Properties();
    velocityEngineProperties.setProperty("resource.loader", "classpath");
    velocityEngineProperties.setProperty("classpath.resource.loader.class",
            "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
    velocityEngineFactoryBean.setVelocityProperties(velocityEngineProperties);
    VelocityEngine velocityEngine = null;
    try {
        velocityEngine = velocityEngineFactoryBean.createVelocityEngine();
    } catch (IOException e) {
        throw new RuntimeException("Unable to create velocity engine instance");
    }

    // Replay cache
    BeanDefinitionBuilder replayCacheBuilder = BeanDefinitionBuilder.genericBeanDefinition(ReplayCache.class);
    replayCacheBuilder.addConstructorArgValue(new MapBasedStorageService());
    replayCacheBuilder.addConstructorArgValue(replayCacheDuration);
    parserContext.getRegistry().registerBeanDefinition(BEAN_REPLAYCACHE,
            replayCacheBuilder.getBeanDefinition());

    // Message replay rule
    BeanDefinitionBuilder messageReplayRuleBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(MessageReplayRule.class);
    messageReplayRuleBuilder.addConstructorArgReference(BEAN_REPLAYCACHE);
    parserContext.getRegistry().registerBeanDefinition("messageReplayRule",
            messageReplayRuleBuilder.getBeanDefinition());

    // Issue instant rule
    BeanDefinitionBuilder issueInstantBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(IssueInstantRule.class);
    issueInstantBuilder.addConstructorArgValue(newClockSkew);
    issueInstantBuilder.addConstructorArgValue(newExpires);
    parserContext.getRegistry().registerBeanDefinition("issueInstantRule",
            issueInstantBuilder.getBeanDefinition());

    // KeyStore Credential Resolver
    BeanDefinitionBuilder keyStoreBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(KeyStoreCredentialResolverDelegate.class);
    keyStoreBuilder.addPropertyReference("keyStore", certificatestoreRef);
    parserContext.getRegistry().registerBeanDefinition(BEAN_KEYSTORECREDENTIALRESOLVER,
            keyStoreBuilder.getBeanDefinition());

    // Signature Rule Builder
    BeanDefinitionBuilder signatureRuleBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(SignatureSecurityPolicyRule.class);
    signatureRuleBuilder.addConstructorArgValue(new SAMLSignatureProfileValidator());
    signatureRuleBuilder.addPropertyReference("credentialResolver", BEAN_KEYSTORECREDENTIALRESOLVER);

    // List of rule beans
    final ManagedList<BeanMetadataElement> beanMetadataElements = new ManagedList<BeanMetadataElement>();
    beanMetadataElements.add(signatureRuleBuilder.getBeanDefinition());
    beanMetadataElements.add(issueInstantBuilder.getBeanDefinition());
    beanMetadataElements.add(messageReplayRuleBuilder.getBeanDefinition());

    // Security Policy
    BeanDefinitionBuilder securityPolicyDelegateBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(SecurityPolicyDelegate.class);
    securityPolicyDelegateBuilder.addConstructorArgValue(beanMetadataElements);
    parserContext.getRegistry().registerBeanDefinition(BEAN_SECURITYPOLICY,
            securityPolicyDelegateBuilder.getBeanDefinition());

    // Security Policy Resolver
    BeanDefinitionBuilder securityPolicyResolverBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(StaticSecurityPolicyResolver.class);
    securityPolicyResolverBuilder.addConstructorArgReference(BEAN_SECURITYPOLICY);
    parserContext.getRegistry().registerBeanDefinition(BEAN_SECURITYPOLICYRESOLVER,
            securityPolicyResolverBuilder.getBeanDefinition());

    // Message Handler
    BeanDefinitionBuilder postBindingAdapter = BeanDefinitionBuilder
            .rootBeanDefinition(SAMLMessageHandlerImpl.class);
    postBindingAdapter.addConstructorArgValue(httpPostSimpleSignDecoder);
    postBindingAdapter.addConstructorArgReference(BEAN_SECURITYPOLICYRESOLVER);
    postBindingAdapter.addPropertyValue("velocityEngine", velocityEngine);
    postBindingAdapter.addPropertyValue("entityId", entityID);
    parserContext.getRegistry().registerBeanDefinition(messageHandlerRef,
            postBindingAdapter.getBeanDefinition());

    // Assertion Consumer Bean
    BeanDefinitionBuilder assertionComsumerBean = BeanDefinitionBuilder
            .genericBeanDefinition(AssertionConsumerImpl.class);
    assertionComsumerBean.addPropertyReference("provisioner", provisionerRef);
    parserContext.getRegistry().registerBeanDefinition(BEAN_ASSERTIONCONSUMER,
            assertionComsumerBean.getBeanDefinition());

    BeanDefinitionBuilder authenticationProvider = BeanDefinitionBuilder
            .rootBeanDefinition(SAMLResponseAuthenticationProvider.class);
    authenticationProvider.addConstructorArgReference(BEAN_ASSERTIONCONSUMER);
    parserContext.getRegistry().registerBeanDefinition(BEAN_AUTHENTICATIONPROVIDER,
            authenticationProvider.getBeanDefinition());

    // Pre Auth Filter
    final HttpSessionRequestCache requestCache = new HttpSessionRequestCache();
    final AuthenticationFailureHandlerImpl authenticationFailureHandler = new AuthenticationFailureHandlerImpl(
            requestCache);

    // Authentication Filter
    BeanDefinitionBuilder authenticationFilter = BeanDefinitionBuilder
            .rootBeanDefinition(SAMLResponseAuthenticationProcessingFilter.class);
    authenticationFilter.addConstructorArgValue(assertionConsumerURI);
    authenticationFilter.addPropertyReference("SAMLMessageHandler", messageHandlerRef);
    authenticationFilter.addPropertyReference("authenticationManager", authenticationManangerRef);
    authenticationFilter.addPropertyValue("authenticationFailureHandler", authenticationFailureHandler);
    parserContext.getRegistry().registerBeanDefinition(preAuthFilterRef,
            authenticationFilter.getBeanDefinition());

    return authenticationProvider.getBeanDefinition();
}

From source file:org.metaeffekt.dcc.commons.spring.xml.DCCConfigurationBeanDefinitionParser.java

private BeanDefinitionBuilder createGenericCapabilityBuilder(String capabilityId, Element capElement,
        Class<? extends Capability> type) {

    String capabilityDefinitionRef = capElement.getAttribute(ATTRIBUTE_CAPABILITY_DEFINITION_REF);

    // convention: if the capabilityDefinitionRef matches the capabilityId it can be omitted
    if (StringUtils.isEmpty(capabilityDefinitionRef)) {
        capabilityDefinitionRef = capabilityId;
    }/*from   ww  w.  ja  v a 2  s  .  c om*/
    String capabilityDefRef = createCapabilityDefBeanName(capabilityDefinitionRef);

    BeanDefinitionBuilder capabilityBeanDefBuilder = BeanDefinitionBuilder.genericBeanDefinition(type);
    capabilityBeanDefBuilder.addConstructorArgValue(Id.createCapabilityId(capabilityId));
    capabilityBeanDefBuilder.addConstructorArgReference(capabilityDefRef);
    capabilityBeanDefBuilder.addConstructorArgValue(null);

    // force spring to create several instances to not use shared capabilities across different units
    capabilityBeanDefBuilder.setScope(BeanDefinition.SCOPE_PROTOTYPE);

    return capabilityBeanDefBuilder;
}

From source file:org.mule.config.spring.parsers.AbstractMuleBeanDefinitionParser.java

protected BeanDefinitionBuilder createBeanDefinitionBuilder(Element element, Class<?> beanClass) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(beanClass);
    // If a constructor with a single MuleContext argument is available then use it.
    if (ClassUtils.getConstructor(beanClass, new Class[] { MuleContext.class }, true) != null) {
        builder.addConstructorArgReference(MuleProperties.OBJECT_MULE_CONTEXT);
    }/* w ww . ja  va2s. co  m*/
    return builder;
}