Example usage for org.springframework.beans.factory.config BeanDefinitionHolder BeanDefinitionHolder

List of usage examples for org.springframework.beans.factory.config BeanDefinitionHolder BeanDefinitionHolder

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.config.*
  5. BeanDefinitionHolder
  6. BeanDefinitionHolder

Introduction

In this page you can find the example usage for org.springframework.beans.factory.config BeanDefinitionHolder BeanDefinitionHolder.

Prototype

public BeanDefinitionHolder(BeanDefinition beanDefinition, String beanName, @Nullable String[] aliases)

Source Link

Document

Create a new BeanDefinitionHolder.

Usage

From source file:org.ff4j.spring.namespace.FF4JPlaceHolderBeanDefinitionParser.java

/** {@inheritDoc} */
public final BeanDefinition parse(Element element, ParserContext parserContext) {
    logger.debug("Initialization from <ff4j:" + TAG_PLACEHOLDER + "> TAG");
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
    builder.getRawBeanDefinition().setBeanClass(FF4jPropertiesPlaceHolderConfigurer.class);
    builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));

    // Reference to FF4J bean
    RuntimeBeanReference refFF4j = new RuntimeBeanReference("ff4j");
    builder.getBeanDefinition().getPropertyValues().addPropertyValue("id", BEANID_PLACEHOLDER_CONF);
    builder.getBeanDefinition().getPropertyValues().addPropertyValue("ff4j", refFF4j);
    builder.getBeanDefinition().getPropertyValues().addPropertyValue("order", 2);

    AbstractBeanDefinition def = builder.getBeanDefinition();
    if (def != null && !parserContext.isNested()) {
        BeanDefinitionHolder holder = new BeanDefinitionHolder(def, BEANID_PLACEHOLDER, new String[0]);
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, parserContext.getRegistry());
    }//from w  w w.j ava2s.c  om
    return def;
}

From source file:org.jdal.aop.SerializableProxyUtils.java

public static BeanDefinitionHolder createSerializableProxy(BeanDefinitionHolder definition,
        BeanDefinitionRegistry registry, boolean proxyTargetClass) {

    String originalBeanName = definition.getBeanName();
    BeanDefinition targetDefinition = definition.getBeanDefinition();

    // Create a scoped proxy definition for the original bean name,
    // "hiding" the target bean in an internal target definition.
    RootBeanDefinition proxyDefinition = new RootBeanDefinition(SerializableProxyFactoryBean.class);
    proxyDefinition.setOriginatingBeanDefinition(definition.getBeanDefinition());
    proxyDefinition.setSource(definition.getSource());
    proxyDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

    String targetBeanName = getTargetBeanName(originalBeanName);
    proxyDefinition.getPropertyValues().add("targetBeanName", targetBeanName);

    if (proxyTargetClass) {
        targetDefinition.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
    } else {//from   w ww  . j a va  2  s. co  m
        proxyDefinition.getPropertyValues().add("proxyTargetClass", Boolean.FALSE);
    }

    // Copy autowire settings from original bean definition.
    proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
    proxyDefinition.setPrimary(targetDefinition.isPrimary());
    if (targetDefinition instanceof AbstractBeanDefinition) {
        proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
    }

    // Set singleton property of FactoryBean
    proxyDefinition.getPropertyValues().add("singleton", !targetDefinition.isPrototype());

    // The target bean should be ignored in favor of the scoped proxy.
    targetDefinition.setAutowireCandidate(false);
    targetDefinition.setPrimary(false);

    // Register the target bean as separate bean in the factory.
    registry.registerBeanDefinition(targetBeanName, targetDefinition);

    // Return the scoped proxy definition as primary bean definition
    // (potentially an inner bean).
    return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());
}

From source file:net.phoenix.thrift.xml.ArgBeanDefinitionParser.java

/**
 * register to the bean factory;//ww  w.  ja  v  a2  s .  c  o  m
 *
 * @param element
 * @param parserContext
 * @param current
 */
private void registerBeanDefinition(Element element, ParserContext parserContext,
        AbstractBeanDefinition current) {
    try {
        Element parent = (Element) element.getParentNode();
        String argsBeanDefinitionName = parent.getAttribute("id");
        String name = argsBeanDefinitionName + "-" + element.getAttribute("name");
        String[] alias = null;
        if (StringUtils.hasLength(name)) {
            alias = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
        }
        BeanDefinitionHolder holder = new BeanDefinitionHolder(current, name, alias);
        registerBeanDefinition(holder, parserContext.getRegistry());
    } catch (BeanDefinitionStoreException ex) {
        parserContext.getReaderContext().error(ex.getMessage(), element);
    }
}

From source file:com.apporiented.spring.override.AbstractGenericBeanDefinitionParser.java

public final BeanDefinition parse(Element element, ParserContext parserContext) {
    if (!enabled) {
        throw new FatalBeanException("Support for " + element.getTagName()
                + " has been disabled. Please add the required jar files " + "to your classpath.");
    }/*ww  w  .j  a  v  a 2  s . c om*/
    AbstractBeanDefinition definition = parseInternal(element, parserContext);
    if (!parserContext.isNested()) {
        try {
            String id = resolveId(element, definition, parserContext);
            if (!StringUtils.hasText(id)) {
                parserContext.getReaderContext().error("Id is required for element '" + element.getLocalName()
                        + "' when used as a top-level tag", element);
            }
            String[] aliases = resolveAliases(element, definition, parserContext);
            BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);
            if (decorator != null) {
                holder = decorator.decorate(element, holder, parserContext);
            }
            registerBeanDefinition(holder, parserContext.getRegistry());
            if (shouldFireEvents()) {
                BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
                postProcessComponentDefinition(componentDefinition);
                parserContext.registerComponent(componentDefinition);
            }
        } catch (BeanDefinitionStoreException ex) {
            parserContext.getReaderContext().error(ex.getMessage(), element);
            return null;
        }
    } else if (decorator != null) {
        BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, "");
        decorator.decorate(element, holder, parserContext);
    }
    return definition;
}

From source file:com.dianping.zebra.monitor.spring.DataSourceAutoMonitor.java

@SuppressWarnings("unchecked")
private void replaceInnerDataSourceInZebra(String beanName, BeanDefinition zebraDataSourceDefinition) {
    MutablePropertyValues propertyValues = zebraDataSourceDefinition.getPropertyValues();
    PropertyValue dataSourcePoolVal = propertyValues.getPropertyValue("dataSourcePool");

    if (dataSourcePoolVal == null) {
        if (logger.isWarnEnabled()) {
            logger.warn("Zebra dataSource's dataSourcePool property not found, maybe its name is modified, "
                    + "change the automonitor's implementation, otherwise some inner dataSource cannot be monitored.");
        }/* www.java2s  . c  om*/
        return;
    }

    Map<TypedStringValue, Object> innerDSDefinitionMap = (Map<TypedStringValue, Object>) dataSourcePoolVal
            .getValue();
    for (Entry<TypedStringValue, Object> innerDSDefEntry : innerDSDefinitionMap.entrySet()) {
        Object innerDSDefVal = innerDSDefEntry.getValue();
        if (innerDSDefVal instanceof BeanDefinitionHolder) {
            BeanDefinitionHolder innerDSDefHolder = (BeanDefinitionHolder) innerDSDefVal;
            BeanDefinition innerDSDefinition = innerDSDefHolder.getBeanDefinition();
            innerDSDefEntry.setValue(
                    new BeanDefinitionHolder(createMonitorableBeanDefinition(beanName, innerDSDefinition),
                            innerDSDefHolder.getBeanName(), innerDSDefHolder.getAliases()));
        }
    }
}

From source file:org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.java

/**
 * Parses the supplied {@code <bean>} element. May return {@code null}
 * if there were errors during parse. Errors are reported to the
 * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
 *///from  ww  w .ja  v a  2 s  .c  o m
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    String id = ele.getAttribute(ID_ATTRIBUTE);
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    List<String> aliases = new ArrayList<>();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }

    String beanName = id;
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        beanName = aliases.remove(0);
        if (logger.isDebugEnabled()) {
            logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases
                    + " as aliases");
        }
    }

    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }

    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) {
                    beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition,
                            this.readerContext.getRegistry(), true);
                } else {
                    beanName = this.readerContext.generateBeanName(beanDefinition);
                    // Register an alias for the plain bean class name, if still possible,
                    // if the generator returned the class name plus a suffix.
                    // This is expected for Spring 1.2/2.0 backwards compatibility.
                    String beanClassName = beanDefinition.getBeanClassName();
                    if (beanClassName != null && beanName.startsWith(beanClassName)
                            && beanName.length() > beanClassName.length()
                            && !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                        aliases.add(beanClassName);
                    }
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Neither XML 'id' nor 'name' specified - " + "using generated bean name ["
                            + beanName + "]");
                }
            } catch (Exception ex) {
                error(ex.getMessage(), ele);
                return null;
            }
        }
        String[] aliasesArray = StringUtils.toStringArray(aliases);
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
}

From source file:org.springframework.beans.factory.xml.DefaultXmlBeanDefinitionParser.java

/**
 * Parse a standard bean definition into a BeanDefinitionHolder,
 * including bean name and aliases./*  w w w .  j a va 2  s  .  c  om*/
 * <p>Bean elements specify their canonical name as "id" attribute
 * and their aliases as a delimited "name" attribute.
 * <p>If no "id" specified, uses the first name in the "name" attribute
 * as canonical name, registering all others as aliases.
 * <p>Callers should specify whether this element represents an inner bean
 * definition or not by setting the <code>isInnerBean</code> argument appropriately
 */
protected BeanDefinitionHolder parseBeanDefinitionElement(Element ele, boolean isInnerBean)
        throws BeanDefinitionStoreException {

    String id = ele.getAttribute(ID_ATTRIBUTE);
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    List aliases = new ArrayList();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, BEAN_NAME_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }

    String beanName = id;
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        beanName = (String) aliases.remove(0);
        if (logger.isDebugEnabled()) {
            logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases
                    + " as aliases");
        }
    }

    BeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName);

    if (!StringUtils.hasText(beanName) && beanDefinition instanceof AbstractBeanDefinition) {
        beanName = BeanDefinitionReaderUtils.generateBeanName((AbstractBeanDefinition) beanDefinition,
                this.beanDefinitionReader.getBeanFactory(), isInnerBean);
        if (logger.isDebugEnabled()) {
            logger.debug("Neither XML 'id' nor 'name' specified - " + "using generated bean name [" + beanName
                    + "]");
        }
    }

    String[] aliasesArray = StringUtils.toStringArray(aliases);
    return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}