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

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

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

Introduction

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

Prototype

public AbstractBeanDefinition getBeanDefinition()

Source Link

Document

Validate and return the created BeanDefinition object.

Usage

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

private void parseIsTrueAsserts(final ManagedList<AbstractBeanDefinition> asserts, Element assertsElement,
        BeanDefinitionRegistry registry) {
    final List<Element> uniqueAsserts = DomUtils.getChildElementsByTagName(assertsElement, "is-true");

    for (Element uniqueAssert : uniqueAsserts) {
        final BeanDefinitionBuilder assertBeanDefBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(IsTrueAssert.class);
        assertBeanDefBuilder.addConstructorArgValue(parseString(uniqueAssert, "value", null, registry));
        assertBeanDefBuilder.addConstructorArgValue(parseString(uniqueAssert, "message", null, registry));
        asserts.add(assertBeanDefBuilder.getBeanDefinition());
    }//from   ww  w .  ja  v  a  2s. co  m
}

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

private ManagedList<AbstractBeanDefinition> parseCommands(Element unitElement, String unitId,
        BeanDefinitionRegistry registry) {
    ManagedList<AbstractBeanDefinition> commands = new ManagedList<>();
    List<Element> commandElements = DomUtils.getChildElementsByTagName(unitElement, ELEMENT_UNIT_COMMAND);

    if (!commandElements.isEmpty()) {

        String defaultPackageRef = unitElement.getAttribute(DccConstants.PACKAGE);
        Id<PackageId> defaultPackageId = null;
        if (StringUtils.isNotEmpty(defaultPackageRef)) {
            defaultPackageId = Id.createPackageId(defaultPackageRef);
        }//from ww  w.  j  a v a  2  s  . c  o  m

        for (Element commandElement : commandElements) {
            final String commandTypeRef = commandElement.getAttribute(ATTRIBUTE_UNIT_TYPE);
            final Commands commandType = Commands.parseConfigurableCommand(commandTypeRef);
            if (commandType == null) {
                throw new BeanCreationException(
                        String.format("Unsupported command type [%s].", commandTypeRef));
            }

            final Id<PackageId> packageId = parsePackageReferenceForCommand(defaultPackageId, commandElement,
                    unitId);

            final BeanDefinitionBuilder commandBeanDefBuilder = BeanDefinitionBuilder
                    .genericBeanDefinition(CommandDefinition.class);
            commandBeanDefBuilder.addConstructorArgValue(commandType);
            commandBeanDefBuilder.addConstructorArgValue(packageId);

            final List<CapabilityDefinitionReference> capabilities = parseCommandCapabilities(commandElement,
                    registry);
            final List<CapabilityDefinitionExtensionReference> contributions = parseCommandContributions(
                    commandElement, registry);
            final List<CapabilityDefinitionExtensionReference> requisitions = parseCommandRequisitions(
                    commandElement, registry);
            final List<Provision> provisions = parseCommandProvisions(commandElement, registry);

            commandBeanDefBuilder.addPropertyValue(PROPERTY_CAPABILITIES, capabilities);
            commandBeanDefBuilder.addPropertyValue(PROPERTY_CONTRIBUTIONS, contributions);
            commandBeanDefBuilder.addPropertyValue(PROPERTY_REQUISITIONS, requisitions);
            commandBeanDefBuilder.addPropertyValue(PROPERTY_PROVISIONS, provisions);

            commands.add(commandBeanDefBuilder.getBeanDefinition());
        }
    }

    return commands;
}

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

private ManagedList<AbstractBeanDefinition> parseMappingsElement(Element unitElement, String unitId,
        BeanDefinitionRegistry registry) {
    ManagedList<AbstractBeanDefinition> mappings = new ManagedList<>();
    Element mappingsElement = DomUtils.getChildElementByTagName(unitElement, ELEMENT_UNIT_MAPPINGS);
    if (mappingsElement != null) {
        List<Element> mappingElements = DomUtils.getChildElementsByTagName(mappingsElement, "mapping");
        for (Element mappingElement : mappingElements) {
            String targetCapabilityId = parseString(mappingElement, "targetCapabilityId", null, registry);

            BeanDefinitionBuilder mappingBeanDefBuilder = BeanDefinitionBuilder
                    .genericBeanDefinition(Mapping.class);
            mappingBeanDefBuilder.addConstructorArgValue(Id.createCapabilityId(targetCapabilityId));

            ManagedList<AttributeMapper> mappers = new ManagedList<>();

            Element mapUnitAttributesElement = DomUtils.getChildElementByTagName(mappingElement,
                    "map-unit-attributes");
            if (mapUnitAttributesElement != null) {
                String sourcePrefix = parseString(mapUnitAttributesElement, "sourcePrefix", null, registry);
                String targetPrefix = parseString(mapUnitAttributesElement, "targetPrefix", null, registry);
                UnitToCapabilityAttributeMapper mapper = new UnitToCapabilityAttributeMapper(sourcePrefix,
                        targetPrefix);/* ww w .j  a  va 2 s  . c  o m*/
                mappers.add(mapper);
            }

            // extract map alls
            List<Element> mapAllElements = DomUtils.getChildElementsByTagName(mappingElement, "map-all");
            for (Element mapAllElement : mapAllElements) {
                Id<CapabilityId> sourceCapabilityId = Id
                        .createCapabilityId(parseString(mapAllElement, "sourceCapabilityId", null, registry));
                String sourcePrefix = parseString(mapAllElement, "sourcePrefix", null, registry);
                String targetPrefix = parseString(mapAllElement, "targetPrefix", null, registry);
                SourceToTargetCapabilityAttributeMapper mapper = new SourceToTargetCapabilityAttributeMapper(
                        sourceCapabilityId, sourcePrefix, targetPrefix);
                mappers.add(mapper);
            }

            // extract expressions
            List<Element> expressionElements = DomUtils.getChildElementsByTagName(mappingElement, "expression");
            for (Element expressionElement : expressionElements) {
                String attributeKey = expressionElement.getAttribute("attributeKey");
                String value = parseString(expressionElement, "value", null, registry);
                ExpressionAttributeMapper mapper = new ExpressionAttributeMapper(attributeKey, value);
                mappers.add(mapper);
            }

            mappingBeanDefBuilder.addPropertyValue("attributeMappers", mappers);

            mappingBeanDefBuilder.setScope(BeanDefinition.SCOPE_PROTOTYPE);

            mappings.add(mappingBeanDefBuilder.getBeanDefinition().cloneBeanDefinition());
        }
    }
    return mappings;
}

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

private ManagedList<AbstractBeanDefinition> parseRequiredCapabilities(Element unitElement, String unitId,
        BeanDefinitionRegistry registry) {
    ManagedList<AbstractBeanDefinition> reqCapReferences = new ManagedList<>();
    List<Element> reqCapElements = DomUtils.getChildElementsByTagName(unitElement,
            ELEMENT_UNIT_REQUIRED_CAPABILITY);

    for (Element reqCapElement : reqCapElements) {
        String capabilityId = extractMandatoryIdAttributeFromElement(reqCapElement, "Capability", registry);
        boolean optionalFlag = Boolean.valueOf(reqCapElement.getAttribute(ATTRIBUTE_KEY_OPTIONAL));
        boolean multipleBindingsAllowedFlag = Boolean
                .valueOf(reqCapElement.getAttribute(ATTRIBUTE_KEY_MULTIPLE_BINDINGS));
        boolean identifiesHost = Boolean.valueOf(reqCapElement.getAttribute(ATTRIBUTE_KEY_IDENTIFIES_HOST));

        BeanDefinitionBuilder builder = createGenericCapabilityBuilder(capabilityId, reqCapElement,
                RequiredCapability.class);
        builder.addPropertyValue(ATTRIBUTE_KEY_OPTIONAL, optionalFlag);
        builder.addPropertyValue(ATTRIBUTE_KEY_MULTIPLE_BINDINGS, multipleBindingsAllowedFlag);
        builder.addPropertyValue(ATTRIBUTE_IDENTIFIES_HOST, identifiesHost);

        String capabilityBeanName = generateCapabilityBeanName(unitId, capabilityId);
        registry.registerBeanDefinition(capabilityBeanName, builder.getBeanDefinition());

        reqCapReferences.add(builder.getBeanDefinition());
    }/*from  www .  j a  v  a  2  s.c o  m*/
    return reqCapReferences;
}

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

private ManagedList<AbstractBeanDefinition> parseProvidedCapabilities(Element unitElement, String unitId,
        BeanDefinitionRegistry registry) {

    ManagedList<AbstractBeanDefinition> provCapReferences = new ManagedList<>();
    List<Element> provCapElements = DomUtils.getChildElementsByTagName(unitElement,
            ELEMENT_UNIT_PROVIDED_CAPABILITY);

    for (Element provCapElement : provCapElements) {
        String capabilityId = extractMandatoryIdAttributeFromElement(provCapElement, "Capability", registry);
        BeanDefinitionBuilder capabilityBeanDefBuilder = createGenericCapabilityBuilder(capabilityId,
                provCapElement, Capability.class);
        String capabilityBeanName = generateCapabilityBeanName(unitId, capabilityId);
        registry.registerBeanDefinition(capabilityBeanName, capabilityBeanDefBuilder.getBeanDefinition());
        provCapReferences.add(capabilityBeanDefBuilder.getBeanDefinition());
    }//from  ww w  .  j av  a2 s . co  m
    return provCapReferences;
}

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

private void parseAndRegisterBindings(Element profileElement, File origin, BeanDefinitionRegistry registry,
        ParserContext parserContext) {/*from   www .jav a 2 s . co  m*/

    List<Element> bindingElements = DomUtils.getChildElementsByTagName(profileElement, ELEMENT_BINDING);
    for (Element bindingElement : bindingElements) {
        Element sourceElement = DomUtils.getChildElementByTagName(bindingElement, ELEMENT_BINDING_SOURCE);
        Element targetElement = DomUtils.getChildElementByTagName(bindingElement, ELEMENT_BINDING_TARGET);

        String sourceUnitRef = parseString(sourceElement, "unitRef", null, registry);
        String sourceCapabilityId = parseString(sourceElement, "capabilityId", null, registry);
        String targetUnitRef = parseString(targetElement, "unitRef", null, registry);
        String targetCapabilityId = parseString(targetElement, "capabilityId", null, registry);

        // convention: if target capabilityId is omitted then use the source capability id
        if (StringUtils.isEmpty(targetCapabilityId)) {
            targetCapabilityId = sourceCapabilityId;
        }

        String description = extractDescription(bindingElement, registry);

        BeanDefinitionBuilder bindingBeanBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(BindingFactoryBean.class);
        bindingBeanBuilder.addPropertyValue(PROPERTY_ORIGIN, origin);
        bindingBeanBuilder.addPropertyValue(PROPERTY_DESCRIPTION, description);
        bindingBeanBuilder.addPropertyValue("sourceCapabilityId", Id.createCapabilityId(sourceCapabilityId));
        bindingBeanBuilder.addPropertyReference("sourceUnit", sourceUnitRef);
        bindingBeanBuilder.addPropertyValue("targetCapabilityId", Id.createCapabilityId(targetCapabilityId));
        bindingBeanBuilder.addPropertyReference("targetUnit", targetUnitRef);

        String bindingBeanName = parserContext.getReaderContext()
                .generateBeanName(bindingBeanBuilder.getBeanDefinition());
        registry.registerBeanDefinition(bindingBeanName, bindingBeanBuilder.getBeanDefinition());

        RuntimeBeanReference beanRef = new RuntimeBeanReference(bindingBeanName);
        beanRef.setSource(parserContext.extractSource(bindingElement));

    }
}

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

/**
 * Creates a {@link BeanDefinitionBuilder} instance for the {@link #getBeanClass
 * bean Class} and passes it to the {@link #doParse} strategy method.
 *
 * @param element the element that is to be parsed into a single BeanDefinition
 * @param context the object encapsulating the current state of the parsing
 *            process/*from  ww w. j  a va2 s . c  o  m*/
 * @return the BeanDefinition resulting from the parsing of the supplied
 *         {@link Element}
 * @throws IllegalStateException if the bean {@link Class} returned from
 *             {@link #getBeanClass(org.w3c.dom.Element)} is <code>null</code>
 * @see #doParse
 */
@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext context) {
    preProcess(element);
    setParserContext(context);
    setRegistry(context.getRegistry());
    checkElementNameUnique(element);
    Class<?> beanClass = getClassInternal(element);
    BeanDefinitionBuilder builder = createBeanDefinitionBuilder(element, beanClass);
    builder.getRawBeanDefinition().setSource(context.extractSource(element));
    builder.setScope(isSingleton() ? BeanDefinition.SCOPE_SINGLETON : BeanDefinition.SCOPE_PROTOTYPE);

    // Marker for MULE-4813
    // We don't want lifcycle for the following from spring
    if (!Component.class.isAssignableFrom(beanClass) && !MessageSource.class.isAssignableFrom(beanClass)
            && !OutboundRouterCollection.class.isAssignableFrom(beanClass)
            && !OutboundRouter.class.isAssignableFrom(beanClass)
            && !AbstractMessageProcessorOwner.class.isAssignableFrom(beanClass)
            && !MessagingExceptionHandler.class.isAssignableFrom(beanClass)
            && !Transformer.class.isAssignableFrom(beanClass)) {
        if (Initialisable.class.isAssignableFrom(beanClass)) {
            builder.setInitMethodName(Initialisable.PHASE_NAME);
        }

        if (Disposable.class.isAssignableFrom(beanClass)) {
            builder.setDestroyMethodName(Disposable.PHASE_NAME);
        }
    }

    if (context.isNested()) {
        // Inner bean definition must receive same singleton status as containing bean.
        builder.setScope(context.getContainingBeanDefinition().isSingleton() ? BeanDefinition.SCOPE_SINGLETON
                : BeanDefinition.SCOPE_PROTOTYPE);
    }

    doParse(element, context, builder);
    return builder.getBeanDefinition();
}

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 www  . jav a2  s .c om*/
 * @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());
            }
        }
    }
}

From source file:org.mule.config.spring.parsers.specific.RetryPolicyDefinitionParser.java

/**
 * The BDP magic inside this method will transform this simple config:
 *
 *      <test:connector name="testConnector8">
 *          <ee:reconnect blocking="false" count="5" frequency="1000"/>
 *      </test:connector>//from w  ww. j  a  v  a2  s.co  m
 *
 * into this equivalent config, because of the attribute asynchronous="true":
 *
 *      <test:connector name="testConnector8">
 *          <spring:property name="retryPolicyTemplate">
 *              <spring:bean class="org.mule.retry.async.AsynchronousRetryTemplate">
 *                  <spring:constructor-arg>
 *                      <spring:bean name="delegate" class="org.mule.retry.policies.SimpleRetryPolicyTemplate">
 *                          <spring:property name="count" value="5"/>
 *                          <spring:property name="frequency" value="1000"/>
 *                      </spring:bean>
 *                  </spring:constructor-arg>
 *              </spring:bean>
 *          </spring:property>
 *      </test:connector>
 */
@Override
protected void parseChild(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    super.parseChild(element, parserContext, builder);

    if (asynchronous) {
        // Create the AsynchronousRetryTemplate as a wrapper bean
        BeanDefinitionBuilder bdb = BeanDefinitionBuilder
                .genericBeanDefinition(AsynchronousRetryTemplate.class);
        // Generate a bean name
        String asynchWrapperName = parserContext.getReaderContext().generateBeanName(bdb.getBeanDefinition());
        // Pass in the retry policy as a constructor argument
        String retryPolicyName = getBeanName(element);
        bdb.addConstructorArgReference(retryPolicyName);
        // Register the new bean
        BeanDefinitionHolder holder = new BeanDefinitionHolder(bdb.getBeanDefinition(), asynchWrapperName);
        registerBeanDefinition(holder, parserContext.getRegistry());

        // Set the AsynchronousRetryTemplate wrapper bean on the retry policy's parent instead of the retry policy itself
        BeanDefinition parent = parserContext.getRegistry().getBeanDefinition(getParentBeanName(element));
        parent.getPropertyValues().addPropertyValue(getPropertyName(element),
                new RuntimeBeanReference(asynchWrapperName));
    }
}

From source file:org.mule.module.extension.internal.config.OperationBeanDefinitionParser.java

@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder
            .rootBeanDefinition(OperationMessageProcessorFactoryBean.class);
    builder.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    parseConfigRef(element, builder);/*  w  w  w .ja va  2  s . c o m*/
    builder.addConstructorArgValue(extension);
    builder.addConstructorArgValue(operation);
    builder.addConstructorArgValue(toElementDescriptorBeanDefinition(element));
    builder.addConstructorArgValue(parseNestedOperations(element, parserContext));
    builder.addConstructorArgReference(MuleProperties.OBJECT_MULE_CONTEXT);

    BeanDefinition definition = builder.getBeanDefinition();
    setNoRecurseOnDefinition(definition);
    attachProcessorDefinition(parserContext, definition);

    return definition;
}