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

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

Introduction

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

Prototype

public static BeanDefinitionBuilder rootBeanDefinition(Class<?> beanClass) 

Source Link

Document

Create a new BeanDefinitionBuilder used to construct a RootBeanDefinition .

Usage

From source file:org.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());
    }/* w  w w . j a  va 2  s  .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/*from  w  w  w  . ja  v a2  s .c o  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 {/*from  w w  w  .jav a2  s . c o 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"));
    }// www  . j  av  a  2s.  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.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"));
    }//from  w  w  w  .j  a va 2  s. 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.metaeffekt.dcc.commons.spring.xml.DCCConfigurationBeanDefinitionParser.java

private void registerProfileFactoryBeanIfRequired(String profileId, String deploymentId, String profileType,
        String profileDescription, File origin, BeanDefinitionRegistry registry, String solutionPropertiesPath,
        String deploymentPropertiesPath, ParserContext parserContext) {
    if (!registry.containsBeanDefinition(THE_ONE_TRUE_PROFILE_BEAN_NAME)) {
        BeanDefinitionBuilder profileFactoryBuilder = BeanDefinitionBuilder
                .rootBeanDefinition(ProfileFactoryBean.class);
        profileFactoryBuilder.addConstructorArgValue(Id.createProfileId(profileId));
        profileFactoryBuilder.addConstructorArgValue(Id.createDeploymentId(deploymentId));
        profileFactoryBuilder.addConstructorArgValue(profileType);
        profileFactoryBuilder.addConstructorArgValue(profileDescription);
        profileFactoryBuilder.addConstructorArgValue(origin);
        profileFactoryBuilder.addPropertyValue(PROPERTY_SOLUTION_PROPERTIES_PATH, solutionPropertiesPath);
        profileFactoryBuilder.addPropertyValue(PROPERTY_DEPLOYMENT_PROPERTIES_PATH, deploymentPropertiesPath);

        final ResourceLoader resourceLoader = parserContext.getReaderContext().getResourceLoader();
        if (resourceLoader instanceof ProfileApplicationContext) {
            File solutionDir = ((ProfileApplicationContext) resourceLoader).getSolutionDir();
            profileFactoryBuilder.addPropertyValue(PROPERTY_SOLUTION_DIR, solutionDir);
        }/*from w  ww .  j av a2 s . co m*/

        registry.registerBeanDefinition(THE_ONE_TRUE_PROFILE_BEAN_NAME,
                profileFactoryBuilder.getBeanDefinition());

        RootBeanDefinition factoryBean = (RootBeanDefinition) registry
                .getBeanDefinition(THE_ONE_TRUE_PROFILE_BEAN_NAME);
        factoryBean.setAttribute("builder", profileFactoryBuilder);
    } else {
        RootBeanDefinition factoryBean = (RootBeanDefinition) registry
                .getBeanDefinition(THE_ONE_TRUE_PROFILE_BEAN_NAME);
        BeanDefinitionBuilder builder = (BeanDefinitionBuilder) factoryBean.getAttribute("builder");
        if (solutionPropertiesPath != null) {
            builder.addPropertyValue(PROPERTY_SOLUTION_PROPERTIES_PATH, solutionPropertiesPath);
        }
        if (deploymentPropertiesPath != null) {
            builder.addPropertyValue(PROPERTY_DEPLOYMENT_PROPERTIES_PATH, deploymentPropertiesPath);
        }
    }
}

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

private void parseAndRegisterSingleCapabilityDefinition(Element capabilityDefElement, File origin,
        ParserContext parserContext, BeanDefinitionRegistry registry) {

    String capabilityDefId = extractMandatoryIdAttributeFromElement(capabilityDefElement,
            "CapabilityDefinition", registry);

    String description = extractDescription(capabilityDefElement, registry);

    String abstractString = capabilityDefElement.getAttribute(PROPERTY_UNIT_ABSTRACT);
    boolean _abstract = StringUtils.equals("true", abstractString) ? true : false;

    List<CapabilityDefinitionReference> ancestors = parseInheritDefinitionElements(capabilityDefElement,
            registry);/*from   ww w  .  ja v a2 s . co m*/
    ManagedList<AttributeKey> attributeKeysList = parseAttributeKeyElements(capabilityDefElement,
            parserContext);

    BeanDefinitionBuilder capabilityBeanDefBuilder = BeanDefinitionBuilder
            .rootBeanDefinition(CapabilityDefinition.class);
    capabilityBeanDefBuilder.addConstructorArgValue(capabilityDefId);
    capabilityBeanDefBuilder.addPropertyValue(PROPERTY_ORIGIN, origin);
    capabilityBeanDefBuilder.addPropertyValue(PROPERTY_DESCRIPTION, description);
    capabilityBeanDefBuilder.addPropertyValue(PROPERTY_CAPABILITY_DEF_ANCESTORS, ancestors);
    capabilityBeanDefBuilder.addPropertyValue(PROPERTY_CAPABILITY_DEF_ATTRIBUTE_KEYS, attributeKeysList);
    capabilityBeanDefBuilder.addPropertyValue(PROPERTY_UNIT_ABSTRACT, _abstract);

    registry.registerBeanDefinition(createCapabilityDefBeanName(capabilityDefId),
            capabilityBeanDefBuilder.getBeanDefinition());
}

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

private void parseAndRegisterUnits(Element profileElement, File origin, BeanDefinitionRegistry registry,
        ParserContext parserContext) {//from  w w  w.j a v a2  s . c om

    List<Element> unitElements = DomUtils.getChildElementsByTagName(profileElement, ELEMENT_UNIT);
    for (Element unitElement : unitElements) {
        // first retrieve all XML attributes of the Unit element
        String unitId = extractMandatoryIdAttributeFromElement(unitElement, "Unit", registry);
        // TODO: currently not used as there is nowhere to set this on a ConfigurationUnit
        @SuppressWarnings("unused")
        String unitType = unitElement.getAttribute(ATTRIBUTE_UNIT_TYPE);
        boolean unitIsAbstract = Boolean.valueOf(unitElement.getAttribute(ATTRIBUTE_UNIT_ABSTRACT));
        String unitExtends = parseString(unitElement, ATTRIBUTE_UNIT_EXTENDS, null, registry);

        ManagedList<AbstractBeanDefinition> requiredCapabilityReferences = parseRequiredCapabilities(
                unitElement, unitId, registry);
        ManagedList<AbstractBeanDefinition> providedCapabilityReferences = parseProvidedCapabilities(
                unitElement, unitId, registry);
        ManagedList<Attribute> attributes = parseAttributesElement(unitElement, parserContext);
        ManagedList<AbstractBeanDefinition> mappings = parseMappingsElement(unitElement, unitId, registry);
        ManagedList<AbstractBeanDefinition> commands = parseCommands(unitElement, unitId, registry);
        ManagedList<AbstractBeanDefinition> asserts = parseAsserts(unitElement, registry);

        BeanDefinitionBuilder unitBeanDefBuilder = null;
        if (StringUtils.isNotBlank(unitExtends)) {
            unitBeanDefBuilder = BeanDefinitionBuilder.childBeanDefinition(unitExtends);
            unitBeanDefBuilder.getRawBeanDefinition().setBeanClass(ConfigurationUnit.class);
            requiredCapabilityReferences.setMergeEnabled(true);
            providedCapabilityReferences.setMergeEnabled(true);
            attributes.setMergeEnabled(true);
            mappings.setMergeEnabled(true);
            commands.setMergeEnabled(true);
            asserts.setMergeEnabled(true);

            unitBeanDefBuilder.addPropertyValue(PROPERTY_UNIT_PARENT_ID, unitExtends);
        } else {
            unitBeanDefBuilder = BeanDefinitionBuilder.rootBeanDefinition(ConfigurationUnit.class);
        }

        String description = extractDescription(unitElement, registry);

        unitBeanDefBuilder.setAbstract(false);
        unitBeanDefBuilder.addPropertyValue(PROPERTY_ORIGIN, origin);
        unitBeanDefBuilder.addPropertyValue(PROPERTY_DESCRIPTION, description);
        unitBeanDefBuilder.addPropertyValue(PROPERTY_UNIT_ABSTRACT, unitIsAbstract);
        unitBeanDefBuilder.addPropertyValue(PROPERTY_UNIT_PROVIDED_CAPABILITIES, providedCapabilityReferences);
        unitBeanDefBuilder.addPropertyValue(PROPERTY_UNIT_REQUIRED_CAPABILITIES, requiredCapabilityReferences);
        unitBeanDefBuilder.addPropertyValue(PROPERTY_UNIT_ATTRIBUTES, attributes);
        unitBeanDefBuilder.addPropertyValue(PROPERTY_UNIT_MAPPINGS, mappings);
        unitBeanDefBuilder.addPropertyValue(PROPERTY_UNIT_COMMANDS, commands);
        unitBeanDefBuilder.addPropertyValue(PROPERTY_UNIT_ASSERTS, asserts);

        unitBeanDefBuilder.addConstructorArgValue(unitId);
        RuntimeBeanReference unitBeanRef = new RuntimeBeanReference(unitId);
        unitBeanRef.setSource(parserContext.getReaderContext().extractSource(unitElement));

        registry.registerBeanDefinition(unitId, unitBeanDefBuilder.getBeanDefinition());
    }

}

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  w  w .j  a v a 2 s .  c o  m
    return builder;
}

From source file:org.mule.config.spring.parsers.assembly.DefaultBeanAssembler.java

/**
 * Insert the bean we have built into the target (typically the parent bean).
 *
 * <p>This is the most complex case because the bean can have an aribtrary type.
 * /*from  w  w w. ja v a2 s. c  o m*/
 * @param oldName The identifying the bean (typically element name).
 */
public void insertBeanInTarget(String oldName) {
    logger.debug("insert " + bean.getBeanDefinition().getBeanClassName() + " -> " + target.getBeanClassName());
    assertTargetPresent();
    String beanClass = bean.getBeanDefinition().getBeanClassName();
    PropertyValues sourceProperties = bean.getRawBeanDefinition().getPropertyValues();
    String newName = bestGuessName(targetConfig, oldName, target.getBeanClassName());
    MutablePropertyValues targetProperties = target.getPropertyValues();
    PropertyValue pv = targetProperties.getPropertyValue(newName);
    Object oldValue = null == pv ? null : pv.getValue();

    if (!targetConfig.isIgnored(oldName)) {
        if (targetConfig.isCollection(oldName)
                || beanClass.equals(ChildListEntryDefinitionParser.ListEntry.class.getName())) {
            if (null == oldValue) {
                if (beanClass.equals(ChildMapEntryDefinitionParser.KeyValuePair.class.getName())
                        || beanClass.equals(MapEntryCombiner.class.getName())
                        || beanClass.equals(MapFactoryBean.class.getName())) {
                    // a collection of maps requires an extra intermediate object that does the
                    // lazy combination/caching of maps when first used
                    BeanDefinitionBuilder combiner = BeanDefinitionBuilder
                            .rootBeanDefinition(MapCombiner.class);
                    targetProperties.addPropertyValue(newName, combiner.getBeanDefinition());
                    MutablePropertyValues combinerProperties = combiner.getBeanDefinition().getPropertyValues();
                    oldValue = new ManagedList();
                    pv = new PropertyValue(MapCombiner.LIST, oldValue);
                    combinerProperties.addPropertyValue(pv);
                } else {
                    oldValue = new ManagedList();
                    pv = new PropertyValue(newName, oldValue);
                    targetProperties.addPropertyValue(pv);
                }
            }

            List list = retrieveList(oldValue);
            if (ChildMapEntryDefinitionParser.KeyValuePair.class.getName().equals(beanClass)) {
                list.add(new ManagedMap());
                retrieveMap(list.get(list.size() - 1)).put(
                        sourceProperties.getPropertyValue(ChildMapEntryDefinitionParser.KEY).getValue(),
                        sourceProperties.getPropertyValue(ChildMapEntryDefinitionParser.VALUE).getValue());
            } else if (beanClass.equals(ChildListEntryDefinitionParser.ListEntry.class.getName())) {
                list.add(sourceProperties.getPropertyValue(ChildListEntryDefinitionParser.VALUE).getValue());
            } else {
                list.add(bean.getBeanDefinition());
            }
        } else {
            // not a collection

            if (ChildMapEntryDefinitionParser.KeyValuePair.class.getName().equals(beanClass)) {
                if (null == pv || null == oldValue) {
                    pv = new PropertyValue(newName, new ManagedMap());
                    targetProperties.addPropertyValue(pv);
                }
                retrieveMap(pv.getValue()).put(
                        sourceProperties.getPropertyValue(ChildMapEntryDefinitionParser.KEY).getValue(),
                        sourceProperties.getPropertyValue(ChildMapEntryDefinitionParser.VALUE).getValue());
            } else {
                targetProperties.addPropertyValue(newName, bean.getBeanDefinition());
            }
        }
    }
}