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: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);
    }//from w  w w.j  a  v  a2s  . c o m

    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.apache.dubbo.config.spring.context.annotation.DubboConfigBindingRegistrar.java

private void registerDubboConfigBindingBeanPostProcessor(String prefix, String beanName, boolean multiple,
        BeanDefinitionRegistry registry) {

    Class<?> processorClass = DubboConfigBindingBeanPostProcessor.class;

    BeanDefinitionBuilder builder = rootBeanDefinition(processorClass);

    String actualPrefix = multiple ? normalizePrefix(prefix) + beanName : prefix;

    builder.addConstructorArgValue(actualPrefix).addConstructorArgValue(beanName);

    AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();

    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

    registerWithGeneratedName(beanDefinition, registry);

    if (log.isInfoEnabled()) {
        log.info("The BeanPostProcessor bean definition [" + processorClass.getName()
                + "] for dubbo config bean [name : " + beanName + "] has been registered.");
    }/*from   w w w . jav  a 2  s .c om*/

}

From source file:org.blocks4j.feature.toggle.spring.scheme.FeatureToggleDefinitionParser.java

private void buildNewFactoryBean(String factoryBeanName, ParserContext context, String onRefName,
        String offRefName, Class<?> commonInterface, String feature) {
    BeanDefinitionRegistry factory = context.getReaderContext().getReader().getBeanFactory();
    if (!factory.isBeanNameInUse(factoryBeanName)) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(FeatureToggleBeanFactory.class);
        builder.addPropertyValue(TAG_ONREF_NAME, onRefName);
        builder.addPropertyValue(TAG_OFFREF_NAME, offRefName);
        builder.addPropertyValue(TAG_FEATURENAME, feature);
        builder.addPropertyValue(TAG_COMMONINTERFACE_NAME, commonInterface);
        factory.registerBeanDefinition(factoryBeanName, builder.getBeanDefinition());
    } else {//  w  w  w  .  j  a v a 2 s .  co m
        throw new RuntimeException(String
                .format("A bean with name '%s' already exists in the application context.", factoryBeanName));
    }
}

From source file:org.broadleafcommerce.openadmin.server.util.MetadataOverrideBeanDefinitionParser.java

@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder overallMapBuilder = BeanDefinitionBuilder.rootBeanDefinition(MapFactoryBean.class);
    Map<String, BeanDefinition> overallMap = new ManagedMap<String, BeanDefinition>();
    List<Element> overrideItemElements = DomUtils.getChildElementsByTagName(element, "overrideItem");
    for (Element overrideItem : overrideItemElements) {
        String configKey = overrideItem.getAttribute("configurationKey");
        String ceilingEntity = overrideItem.getAttribute("ceilingEntity");

        if (StringUtils.isEmpty(configKey) && StringUtils.isEmpty(ceilingEntity)) {
            throw new IllegalArgumentException(
                    "Must specify either a configurationKey or a ceilingEntity attribute for the overrideItem element");
        }/*from  w ww. j av a2  s .  com*/

        BeanDefinitionBuilder fieldMapBuilder = BeanDefinitionBuilder.rootBeanDefinition(MapFactoryBean.class);
        Map<String, BeanDefinition> fieldMap = new ManagedMap<String, BeanDefinition>();
        List<Element> fieldElements = DomUtils.getChildElementsByTagName(overrideItem, "field");
        for (Element fieldElement : fieldElements) {
            String fieldName = fieldElement.getAttribute("name");
            BeanDefinitionBuilder metadataBuilder = BeanDefinitionBuilder
                    .rootBeanDefinition(FieldMetadataOverride.class);
            fieldMap.put(fieldName, metadataBuilder.getBeanDefinition());
            {
                List<Element> propElements = DomUtils.getChildElementsByTagName(fieldElement, "property");
                for (Element propElement : propElements) {
                    String propName = propElement.getAttribute("name");
                    String propValue = propElement.getAttribute("value");
                    metadataBuilder.addPropertyValue(propName, propValue);
                }
            }

            {
                List<Element> validationElements = DomUtils.getChildElementsByTagName(fieldElement,
                        "validation");
                Map<String, Map<String, String>> validationConfigMap = new ManagedMap<String, Map<String, String>>();
                for (Element validationElement : validationElements) {
                    Map<String, String> validationMap = new ManagedMap<String, String>();
                    List<Element> valPropElements = DomUtils.getChildElementsByTagName(validationElement,
                            "property");
                    for (Element valPropElement : valPropElements) {
                        String valPropName = valPropElement.getAttribute("name");
                        String valPropValue = valPropElement.getAttribute("value");
                        validationMap.put(valPropName, valPropValue);
                    }
                    String className = validationElement.getAttribute("className");
                    validationConfigMap.put(className, validationMap);
                }
                if (!validationConfigMap.isEmpty()) {
                    metadataBuilder.addPropertyValue("validationConfigurations", validationConfigMap);
                }
            }

            {
                List<Element> optionElements = DomUtils.getChildElementsByTagName(fieldElement,
                        "optionFilterValue");
                String[][] optionFilterValues = new String[optionElements.size()][3];
                int j = 0;
                for (Element optionElement : optionElements) {
                    optionFilterValues[j][0] = optionElement.getAttribute("name");
                    optionFilterValues[j][1] = optionElement.getAttribute("value");
                    optionFilterValues[j][2] = optionElement.getAttribute("type");
                    j++;
                }
                if (!ArrayUtils.isEmpty(optionFilterValues)) {
                    metadataBuilder.addPropertyValue("optionFilterValues", optionFilterValues);
                }
            }

            {
                List<Element> keyElements = DomUtils.getChildElementsByTagName(fieldElement, "mapKey");
                String[][] keyValues = new String[keyElements.size()][2];
                int j = 0;
                for (Element keyElement : keyElements) {
                    keyValues[j][0] = keyElement.getAttribute("value");
                    keyValues[j][1] = keyElement.getAttribute("displayValue");
                    j++;
                }
                if (!ArrayUtils.isEmpty(keyValues)) {
                    metadataBuilder.addPropertyValue("keys", keyValues);
                }
            }

            {
                List<Element> children = DomUtils.getChildElementsByTagName(fieldElement, "customCriteria");
                String[] values = new String[children.size()];
                int j = 0;
                for (Element childElem : children) {
                    values[j] = childElem.getAttribute("value");
                    j++;
                }
                if (!ArrayUtils.isEmpty(values)) {
                    metadataBuilder.addPropertyValue("customCriteria", values);
                }
            }

            {
                List<Element> children = DomUtils.getChildElementsByTagName(fieldElement,
                        "maintainedAdornedTargetField");
                String[] values = new String[children.size()];
                int j = 0;
                for (Element childElem : children) {
                    values[j] = childElem.getAttribute("value");
                    j++;
                }
                if (!ArrayUtils.isEmpty(values)) {
                    metadataBuilder.addPropertyValue("maintainedAdornedTargetFields", values);
                }
            }

            {
                List<Element> children = DomUtils.getChildElementsByTagName(fieldElement, "gridVisibleField");
                String[] values = new String[children.size()];
                int j = 0;
                for (Element childElem : children) {
                    values[j] = childElem.getAttribute("value");
                    j++;
                }
                if (!ArrayUtils.isEmpty(values)) {
                    metadataBuilder.addPropertyValue("gridVisibleFields", values);
                }
            }
        }
        fieldMapBuilder.addPropertyValue("sourceMap", fieldMap);

        overallMap.put(StringUtils.isEmpty(configKey) ? ceilingEntity : configKey,
                fieldMapBuilder.getBeanDefinition());
    }

    overallMapBuilder.addPropertyValue("sourceMap", overallMap);

    return overallMapBuilder.getBeanDefinition();
}

From source file:org.directwebremoting.spring.DwrNamespaceHandler.java

protected static BeanDefinition registerSpringConfiguratorIfNecessary(BeanDefinitionRegistry registry) {
    if (!registry.containsBeanDefinition(DEFAULT_SPRING_CONFIGURATOR_ID)) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(SpringConfigurator.class);
        builder.addPropertyValue("creators", new ManagedMap());
        builder.addPropertyValue("converters", new ManagedMap());
        registry.registerBeanDefinition(DEFAULT_SPRING_CONFIGURATOR_ID, builder.getBeanDefinition());
    }/*from w  w w  .  j av  a  2s . c  o m*/
    return registry.getBeanDefinition(DEFAULT_SPRING_CONFIGURATOR_ID);
}

From source file:org.directwebremoting.spring.DwrNamespaceHandler.java

/**
 * Registers a new {@link org.directwebremoting.extend.Creator} in the registry using name <code>javascript</code>.
 * @param registry The definition of all the Beans
 * @param javascript The name of the bean in the registry.
 * @param creatorConfig// w  ww  . j a  v  a  2 s  .  co  m
 * @param params
 * @param children The node list to check for nested elements
 */
@SuppressWarnings("unchecked")
protected void registerCreator(BeanDefinitionRegistry registry, String javascript,
        BeanDefinitionBuilder creatorConfig, Map<String, String> params, NodeList children) {
    registerSpringConfiguratorIfNecessary(registry);

    List<String> includes = new ArrayList<String>();
    creatorConfig.addPropertyValue("includes", includes);

    List<String> excludes = new ArrayList<String>();
    creatorConfig.addPropertyValue("excludes", excludes);

    Properties auth = new Properties();
    creatorConfig.addPropertyValue("auth", auth);

    // check to see if there are any nested elements here
    for (int i = 0; i < children.getLength(); i++) {
        Node node = children.item(i);

        if (node.getNodeType() == Node.TEXT_NODE || node.getNodeType() == Node.COMMENT_NODE) {
            continue;
        }

        Element child = (Element) node;

        if ("dwr:latencyfilter".equals(node.getNodeName())) {
            BeanDefinitionBuilder beanFilter = BeanDefinitionBuilder
                    .rootBeanDefinition(ExtraLatencyAjaxFilter.class);
            beanFilter.addPropertyValue("delay", child.getAttribute("delay"));
            BeanDefinitionHolder holder2 = new BeanDefinitionHolder(beanFilter.getBeanDefinition(),
                    "__latencyFilter_" + javascript);
            BeanDefinitionReaderUtils.registerBeanDefinition(holder2, registry);

            ManagedList filterList = new ManagedList();
            filterList.add(new RuntimeBeanReference("__latencyFilter_" + javascript));
            creatorConfig.addPropertyValue("filters", filterList);
        } else if ("dwr:include".equals(node.getNodeName())) {
            includes.add(child.getAttribute("method"));
        } else if ("dwr:exclude".equals(node.getNodeName())) {
            excludes.add(child.getAttribute("method"));
        } else if ("dwr:auth".equals(node.getNodeName())) {
            auth.setProperty(child.getAttribute("method"), child.getAttribute("role"));
        } else if ("dwr:convert".equals(node.getNodeName())) {
            Element element = (Element) node;
            String type = element.getAttribute("type");
            String className = element.getAttribute("class");

            ConverterConfig converterConfig = new ConverterConfig();
            converterConfig.setType(type);
            parseConverterSettings(converterConfig, element);
            lookupConverters(registry).put(className, converterConfig);
        } else if ("dwr:filter".equals(node.getNodeName())) {
            Element element = (Element) node;
            String filterClass = element.getAttribute("class");
            List<Element> filterParamElements = DomUtils.getChildElementsByTagName(element, "param");
            BeanDefinitionBuilder beanFilter;
            try {
                beanFilter = BeanDefinitionBuilder.rootBeanDefinition(ClassUtils.forName(filterClass));
            } catch (ClassNotFoundException e) {
                throw new IllegalArgumentException("DWR filter class '" + filterClass + "' was not found. "
                        + "Check the class name specified in <dwr:filter class=\"" + filterClass
                        + "\" /> exists");
            }
            for (Element filterParamElement : filterParamElements) {
                beanFilter.addPropertyValue(filterParamElement.getAttribute("name"),
                        filterParamElement.getAttribute("value"));
            }
            BeanDefinitionHolder holder2 = new BeanDefinitionHolder(beanFilter.getBeanDefinition(),
                    "__filter_" + filterClass + "_" + javascript);
            BeanDefinitionReaderUtils.registerBeanDefinition(holder2, registry);

            ManagedList filterList = new ManagedList();
            filterList.add(new RuntimeBeanReference("__filter_" + filterClass + "_" + javascript));
            creatorConfig.addPropertyValue("filters", filterList);
        } else if ("dwr:param".equals(node.getNodeName())) {
            Element element = (Element) node;
            String name = element.getAttribute("name");
            String value = element.getAttribute("value");
            params.put(name, value);
        } else {
            throw new RuntimeException("an unknown dwr:remote sub node was fouund: " + node.getNodeName());
        }
    }
    creatorConfig.addPropertyValue("params", params);

    String creatorConfigName = "__" + javascript;
    BeanDefinitionHolder holder3 = new BeanDefinitionHolder(creatorConfig.getBeanDefinition(),
            creatorConfigName);
    BeanDefinitionReaderUtils.registerBeanDefinition(holder3, registry);

    lookupCreators(registry).put(javascript, new RuntimeBeanReference(creatorConfigName));
}

From source file:org.jboss.windup.config.spring.namespace.xml.XPathClassifyingBeanParser.java

@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder beanBuilder = BeanDefinitionBuilder
            .rootBeanDefinition(XPathClassifyingDecorator.class);

    beanBuilder.addPropertyValue("xpathExpression", element.getAttribute("xpath"));
    beanBuilder.addPropertyValue("matchDescription", element.getAttribute("description"));

    if (element.hasAttribute("effort")) {
        LOG.debug("Effort: " + element.getAttribute("effort"));
        BeanDefinitionBuilder effortBean = BeanDefinitionBuilder
                .genericBeanDefinition("org.jboss.windup.metadata.decoration.effort.StoryPointEffort");
        effortBean.addPropertyValue("hours", element.getAttribute("effort"));
        beanBuilder.addPropertyValue("effort", effortBean.getBeanDefinition());
    } else {/*ww  w. j av  a 2s.co m*/
        BeanDefinitionBuilder effortBean = BeanDefinitionBuilder
                .genericBeanDefinition("org.jboss.windup.metadata.decoration.effort.UnknownEffort");
        beanBuilder.addPropertyValue("effort", effortBean.getBeanDefinition());
    }

    SpringNamespaceHandlerUtil.parseNamespaceMap(beanBuilder, element);

    SpringNamespaceHandlerUtil.setNestedList(beanBuilder, element, "hints", parserContext);
    SpringNamespaceHandlerUtil.setNestedList(beanBuilder, element, "decorators", parserContext);

    return beanBuilder.getBeanDefinition();
}

From source file:org.jboss.windup.config.spring.namespace.xml.XPathSummaryBeanParser.java

@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder beanBuilder = BeanDefinitionBuilder.rootBeanDefinition(XPathSummaryDecorator.class);

    beanBuilder.addPropertyValue("xpathExpression", element.getAttribute("xpath"));
    beanBuilder.addPropertyValue("matchDescription", element.getAttribute("description"));

    if (element.hasAttribute("inline")) {
        beanBuilder.addPropertyValue("inline", element.getAttribute("inline"));
    }/* w  ww  .  ja  v a  2s.c o  m*/

    if (element.hasAttribute("effort")) {
        LOG.debug("Effort: " + element.getAttribute("effort"));
        BeanDefinitionBuilder effortBean = BeanDefinitionBuilder
                .genericBeanDefinition("org.jboss.windup.metadata.decoration.effort.StoryPointEffort");
        effortBean.addPropertyValue("hours", element.getAttribute("effort"));
        beanBuilder.addPropertyValue("effort", effortBean.getBeanDefinition());
    } else {
        BeanDefinitionBuilder effortBean = BeanDefinitionBuilder
                .genericBeanDefinition("org.jboss.windup.metadata.decoration.effort.UnknownEffort");
        beanBuilder.addPropertyValue("effort", effortBean.getBeanDefinition());
    }

    SpringNamespaceHandlerUtil.parseNamespaceMap(beanBuilder, element);

    SpringNamespaceHandlerUtil.setNestedList(beanBuilder, element, "hints", parserContext);
    SpringNamespaceHandlerUtil.setNestedList(beanBuilder, element, "decorators", parserContext);

    return beanBuilder.getBeanDefinition();
}

From source file:org.jboss.windup.config.spring.namespace.xml.XPathValueBeanParser.java

@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder beanBuilder = BeanDefinitionBuilder.rootBeanDefinition(XPathValueDecorator.class);

    beanBuilder.addPropertyValue("xpathExpression", element.getAttribute("xpath"));
    beanBuilder.addPropertyValue("matchDescription", element.getAttribute("description"));

    if (element.hasAttribute("inline")) {
        beanBuilder.addPropertyValue("inline", element.getAttribute("inline"));
    }//w  ww .ja  v a2  s.co m

    if (element.hasAttribute("effort")) {
        LOG.debug("Effort: " + element.getAttribute("effort"));
        BeanDefinitionBuilder effortBean = BeanDefinitionBuilder
                .genericBeanDefinition("org.jboss.windup.metadata.decoration.effort.StoryPointEffort");
        effortBean.addPropertyValue("hours", element.getAttribute("effort"));
        beanBuilder.addPropertyValue("effort", effortBean.getBeanDefinition());
    } else {
        BeanDefinitionBuilder effortBean = BeanDefinitionBuilder
                .genericBeanDefinition("org.jboss.windup.metadata.decoration.effort.UnknownEffort");
        beanBuilder.addPropertyValue("effort", effortBean.getBeanDefinition());
    }

    SpringNamespaceHandlerUtil.parseNamespaceMap(beanBuilder, element);

    SpringNamespaceHandlerUtil.setNestedList(beanBuilder, element, "hints", parserContext);
    SpringNamespaceHandlerUtil.setNestedList(beanBuilder, element, "decorators", parserContext);

    return beanBuilder.getBeanDefinition();
}

From source file:org.kuali.rice.krad.datadictionary.parse.CustomSchemaParser.java

/**
 * Parses the xml bean into a standard bean definition format and fills the information in the passed in definition
 * builder/*  w  ww .j  a  v a  2 s. c  o m*/
 *
 * @param element - The xml bean being parsed.
 * @param parserContext - Provided information and functionality regarding current bean set.
 * @param bean - A definition builder used to build a new spring bean from the information it is filled with.
 */
@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder bean) {
    // Retrieve custom schema information build from the annotations
    Map<String, Map<String, BeanTagAttributeInfo>> attributeProperties = CustomTagAnnotations
            .getAttributeProperties();
    Map<String, BeanTagAttributeInfo> entries = attributeProperties.get(element.getLocalName());

    // Log error if there are no attributes found for the bean tag
    if (entries == null) {
        LOG.error("Bean Tag not found " + element.getLocalName());
    }

    if (element.getTagName().equals(INC_TAG)) {
        String parentId = element.getAttribute("compId");
        bean.setParentName(parentId);

        return;
    }

    if (element.getTagName().equals("content")) {
        bean.setParentName("Uif-Content");

        String markup = nodesToString(element.getChildNodes());
        bean.addPropertyValue("markup", markup);

        return;
    }

    // Retrieve the information for the new bean tag and fill in the default parent if needed
    BeanTagInfo tagInfo = CustomTagAnnotations.getBeanTags().get(element.getLocalName());

    String elementParent = element.getAttribute("parent");
    if (StringUtils.isNotBlank(elementParent) && !StringUtils.equals(elementParent, tagInfo.getParent())) {
        bean.setParentName(elementParent);
    } else if (StringUtils.isNotBlank(tagInfo.getParent())) {
        bean.setParentName(tagInfo.getParent());
    }

    // Create the map for the attributes found in the tag and process them in to the definition builder.
    NamedNodeMap attributes = element.getAttributes();
    for (int i = 0; i < attributes.getLength(); i++) {
        processSingleValue(attributes.item(i).getNodeName(), attributes.item(i).getNodeValue(), entries, bean);
    }

    ArrayList<Element> children = (ArrayList<Element>) DomUtils.getChildElements(element);

    // Process the children found in the xml tag
    for (int i = 0; i < children.size(); i++) {
        String tag = children.get(i).getLocalName();
        BeanTagAttributeInfo info = entries.get(tag);

        if (children.get(i).getTagName().equals("spring:property")
                || children.get(i).getTagName().equals("property")) {
            BeanDefinitionParserDelegate delegate = parserContext.getDelegate();
            delegate.parsePropertyElement(children.get(i), bean.getBeanDefinition());

            continue;
        }

        // Sets the property name to be used when adding the property value
        String propertyName;
        BeanTagAttribute.AttributeType type = null;
        if (info == null) {
            propertyName = CustomTagAnnotations.findPropertyByType(element.getLocalName(), tag);

            if (StringUtils.isNotBlank(propertyName)) {
                bean.addPropertyValue(propertyName, parseBean(children.get(i), bean, parserContext));

                continue;
            } else {
                // If the tag is not in the schema map let spring handle the value by forwarding the tag as the
                // propertyName
                propertyName = tag;
                type = findBeanType(children.get(i));
            }
        } else {
            // If the tag is found in the schema map use the connected name stored in the attribute information
            propertyName = info.getPropertyName();
            type = info.getType();
        }

        // Process the information stored in the child bean
        ArrayList<Element> grandChildren = (ArrayList<Element>) DomUtils.getChildElements(children.get(i));

        if (type == BeanTagAttribute.AttributeType.SINGLEVALUE) {
            String propertyValue = DomUtils.getTextValue(children.get(i));
            bean.addPropertyValue(propertyName, propertyValue);
        } else if (type == BeanTagAttribute.AttributeType.ANY) {
            String propertyValue = nodesToString(children.get(i).getChildNodes());
            bean.addPropertyValue(propertyName, propertyValue);
        } else if ((type == BeanTagAttribute.AttributeType.DIRECT)
                || (type == BeanTagAttribute.AttributeType.DIRECTORBYTYPE)) {
            boolean isPropertyTag = false;
            if ((children.get(i).getAttributes().getLength() == 0) && (grandChildren.size() == 1)) {
                String grandChildTag = grandChildren.get(0).getLocalName();

                Class<?> valueClass = info.getValueType();
                if (valueClass.isInterface()) {
                    try {
                        valueClass = Class.forName(valueClass.getName() + "Base");
                    } catch (ClassNotFoundException e) {
                        throw new RuntimeException("Unable to find impl class for interface", e);
                    }
                }

                Set<String> validTagNames = CustomTagAnnotations.getBeanTagsByClass(valueClass);
                if (validTagNames.contains(grandChildTag)) {
                    isPropertyTag = true;
                }
            }

            if (isPropertyTag) {
                bean.addPropertyValue(propertyName, parseBean(grandChildren.get(0), bean, parserContext));
            } else {
                bean.addPropertyValue(propertyName, parseBean(children.get(i), bean, parserContext));
            }
        } else if ((type == BeanTagAttribute.AttributeType.SINGLEBEAN)
                || (type == BeanTagAttribute.AttributeType.BYTYPE)) {
            bean.addPropertyValue(propertyName, parseBean(grandChildren.get(0), bean, parserContext));
        } else if (type == BeanTagAttribute.AttributeType.LISTBEAN) {
            bean.addPropertyValue(propertyName, parseList(grandChildren, children.get(i), bean, parserContext));
        } else if (type == BeanTagAttribute.AttributeType.LISTVALUE) {
            bean.addPropertyValue(propertyName, parseList(grandChildren, children.get(i), bean, parserContext));
        } else if (type == BeanTagAttribute.AttributeType.MAPVALUE) {
            bean.addPropertyValue(propertyName, parseMap(grandChildren, children.get(i), bean, parserContext));
        } else if (type == BeanTagAttribute.AttributeType.MAPBEAN) {
            bean.addPropertyValue(propertyName, parseMap(grandChildren, children.get(i), bean, parserContext));
        } else if (type == BeanTagAttribute.AttributeType.SETVALUE) {
            bean.addPropertyValue(propertyName, parseSet(grandChildren, children.get(i), bean, parserContext));
        } else if (type == BeanTagAttribute.AttributeType.SETBEAN) {
            bean.addPropertyValue(propertyName, parseSet(grandChildren, children.get(i), bean, parserContext));
        }
    }
}