Example usage for org.springframework.beans.factory.parsing BeanComponentDefinition BeanComponentDefinition

List of usage examples for org.springframework.beans.factory.parsing BeanComponentDefinition BeanComponentDefinition

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.parsing.*
  5. BeanComponentDefinition
  6. BeanComponentDefinition

Introduction

In this page you can find the example usage for org.springframework.beans.factory.parsing BeanComponentDefinition BeanComponentDefinition.

Prototype

public BeanComponentDefinition(BeanDefinitionHolder beanDefinitionHolder)

Source Link

Document

Create a new BeanComponentDefinition for the given bean.

Usage

From source file:org.opencredo.esper.config.xml.EsperListenerParser.java

/**
 * Parses out a set of configured esper statement listeners.
 * /*w  ww .  j a va  2 s  . c om*/
 * @param element
 *            the esper listeners element
 * @param parserContext
 *            the parser's current context
 * @return a list of configured esper statement listeners
 */
@SuppressWarnings("unchecked")
public ManagedSet parseListeners(Element element, ParserContext parserContext) {
    ManagedSet listeners = new ManagedSet();
    NodeList childNodes = element.getChildNodes();
    for (int i = 0; i < childNodes.getLength(); i++) {
        Node child = childNodes.item(i);
        if (child.getNodeType() == Node.ELEMENT_NODE) {
            Element childElement = (Element) child;
            String localName = child.getLocalName();
            if ("bean".equals(localName)) {
                BeanDefinitionHolder holder = parserContext.getDelegate()
                        .parseBeanDefinitionElement(childElement);
                parserContext.registerBeanComponent(new BeanComponentDefinition(holder));
                listeners.add(new RuntimeBeanReference(holder.getBeanName()));
            } else if ("ref".equals(localName)) {
                String ref = childElement.getAttribute("bean");
                listeners.add(new RuntimeBeanReference(ref));
            }
        }
    }
    return listeners;
}

From source file:uk.co.bssd.monitoring.spring.MonitorBeanDefinitionParser.java

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder bean) {

    Element adapterElement = getChildElement(element.getChildNodes(), "adapter");
    String adapterRef = adapterElement.getAttribute("ref");

    Element reporterElement = getChildElement(element.getChildNodes(), "reporter");
    String reporterRef = reporterElement.getAttribute("ref");

    BeanDefinitionBuilder monitorBeanDefinitionBuilder = BeanDefinitionBuilder
            .genericBeanDefinition(Monitor.class);
    monitorBeanDefinitionBuilder.addConstructorArgReference(adapterRef);
    monitorBeanDefinitionBuilder.addConstructorArgReference(reporterRef);

    String monitorBeanName = UUID.randomUUID().toString();
    BeanDefinitionHolder monitorBeanDefinitionHolder = new BeanDefinitionHolder(
            monitorBeanDefinitionBuilder.getBeanDefinition(), monitorBeanName);

    registerBeanDefinition(monitorBeanDefinitionHolder, parserContext.getRegistry());

    BeanComponentDefinition monitorBeanComponentDefinition = new BeanComponentDefinition(
            monitorBeanDefinitionHolder);
    parserContext.registerComponent(monitorBeanComponentDefinition);

    long intervalMs = Long.parseLong(element.getAttribute("monitorIntervalMs"));
    bean.addConstructorArgReference(monitorBeanName);
    bean.addConstructorArgValue(intervalMs);
}

From source file:net.hasor.rsf.spring.parser.RsfDefinitionParser.java

/** ?Xml  */
@Override/*from w  w  w  . j  a v  a  2s  . c om*/
public BeanDefinition parse(Element element, ParserContext parserContext) {
    // Spring 
    String version = SpringVersion.getVersion();
    version = StringUtils.isBlank(version) ? "?" : version;
    Map customEditors = null;
    if (version.charAt(0) == '4' || version.charAt(0) == '5') {
        customEditors = new HashMap<Class<?>, Class<? extends java.beans.PropertyEditor>>();
        customEditors.put(InterAddress.class, RsfAddressPropertyEditor.class);
    } else {
        customEditors = new HashMap();
        customEditors.put("net.hasor.rsf.InterAddress", new RsfAddressPropertyEditor());
    }
    //
    // . Bean 
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
    builder.getRawBeanDefinition().setBeanClass(CustomEditorConfigurer.class);
    builder.setScope(BeanDefinition.SCOPE_SINGLETON);//?
    builder.addPropertyValue("customEditors", customEditors);
    //
    //  .,BeanID net.hasor.rsf.spring.RsfAddressPropertyEditor
    AbstractBeanDefinition propEditors = builder.getBeanDefinition();
    String beanID = RsfAddressPropertyEditor.class.getName();
    BeanDefinitionHolder holder = new BeanDefinitionHolder(propEditors, beanID);
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, parserContext.getRegistry());
    parserContext.registerComponent(new BeanComponentDefinition(holder));
    //
    //
    NamedNodeMap attributes = element.getAttributes();
    //
    return null;
}

From source file:com.github.bjoern2.yolotyrion.spring.xml.RepositorySingleBeanDefinitionParser.java

protected void registerBean(BeanDefinition def, String name, ParserContext parserContext) {
    BeanDefinitionHolder holder = new BeanDefinitionHolder(def, name);
    BeanComponentDefinition component = new BeanComponentDefinition(holder);
    parserContext.registerBeanComponent(component);
}

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.");
    }/*from  w w  w.j a  v a  2 s  . c  o  m*/
    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:org.jdal.vaadin.beans.TableBeanDefinitionParser.java

/**
 * {@inheritDoc}//w w  w.  j  a v a  2s.  c  o  m
 */
@SuppressWarnings("rawtypes")
public BeanDefinition parse(Element element, ParserContext parserContext) {
    // Defaults
    String entity = null;

    if (element.hasAttribute(ENTITY))
        entity = element.getAttribute(ENTITY);

    String name = StringUtils.uncapitalize(StringUtils.substringAfterLast(entity, "."));

    if (element.hasAttribute(ID))
        name = element.getAttribute(ID);

    parserContext.pushContainingComponent(
            new CompositeComponentDefinition(name, parserContext.extractSource(element)));

    // Bean names
    String pageableTableBeanName = name + PAGEABLE_TABLE_SUFFIX;
    String tableBeanName = name + TABLE_SUFFIX;
    String dataSource = name + SERVICE_SUFFIX;
    String paginator = PAGINATOR_VIEW;
    String editor = name + EDITOR_SUFFIX;
    String actions = DefaultsBeanDefinitionParser.DEFAULT_TABLE_ACTIONS;
    String guiFactory = DefaultsBeanDefinitionParser.DEFAULT_GUI_FACTORY;
    String scope = BeanDefinition.SCOPE_PROTOTYPE;
    String pageableTableClass = DEFAULT_PAGEABLE_TABLE_CLASS;
    String tableClass = DEFAULT_TABLE_CLASS;

    if (element.hasAttribute(DATA_SOURCE))
        dataSource = element.getAttribute(DATA_SOURCE);

    if (element.hasAttribute(PAGINATOR))
        paginator = element.getAttribute(PAGINATOR);

    if (element.hasAttribute(ACTIONS))
        actions = element.getAttribute(ACTIONS);

    if (element.hasAttribute(GUI_FACTORY))
        guiFactory = element.getAttribute(GUI_FACTORY);

    if (element.hasAttribute(EDITOR))
        editor = element.getAttribute(EDITOR);

    if (element.hasAttribute(SCOPE))
        scope = element.getAttribute(SCOPE);

    if (element.hasAttribute(PAGEABLE_TABLE_CLASS))
        pageableTableClass = element.getAttribute(PAGEABLE_TABLE_CLASS);

    if (element.hasAttribute(TABLE_CLASS))
        tableClass = element.getAttribute(TABLE_CLASS);

    // create PageableTable
    BeanDefinitionBuilder bdb = BeanDefinitionBuilder.genericBeanDefinition(pageableTableClass);
    bdb.setScope(scope);
    bdb.addPropertyReference(DATA_SOURCE, dataSource);
    bdb.addPropertyReference(PAGINATOR_VIEW, paginator);
    bdb.addPropertyValue(NAME, pageableTableBeanName);
    bdb.addPropertyReference(TABLE, tableBeanName);
    bdb.addPropertyReference(GUI_FACTORY, guiFactory);
    bdb.addPropertyValue(EDITOR_NAME, editor);
    bdb.addPropertyValue(ENTITY_CLASS, entity);

    BeanDefinitionUtils.addPropertyReferenceIfNeeded(bdb, element, TABLE_SERVICE);
    BeanDefinitionUtils.addPropertyReferenceIfNeeded(bdb, element, FILTER);
    BeanDefinitionUtils.addPropertyReferenceIfNeeded(bdb, element, MESSAGE_SOURCE);
    BeanDefinitionUtils.addPropertyReferenceIfNeeded(bdb, element, FILTER_FORM);
    BeanDefinitionUtils.addPropertyValueIfNeeded(bdb, element, SORT_PROPERTY);
    BeanDefinitionUtils.addPropertyValueIfNeeded(bdb, element, ORDER);
    BeanDefinitionUtils.addPropertyValueIfNeeded(bdb, element, PAGE_SIZE);
    BeanDefinitionUtils.addPropertyValueIfNeeded(bdb, element, NATIVE_BUTTONS);
    BeanDefinitionUtils.addPropertyValueIfNeeded(bdb, element, PROPAGATE_SERVICE);

    if (!element.hasAttribute(USE_ACTIONS) || "true".equals(element.getAttribute(USE_ACTIONS)))
        bdb.addPropertyReference(ACTIONS, actions);

    parserContext.getDelegate().parseBeanDefinitionAttributes(element, pageableTableBeanName, null,
            bdb.getBeanDefinition());

    BeanDefinitionHolder holder = new BeanDefinitionHolder(bdb.getBeanDefinition(), pageableTableBeanName);

    // Test Decorators like aop:scoped-proxy
    NodeList childNodes = element.getChildNodes();
    for (int i = 0; i < childNodes.getLength(); i++) {
        Node n = childNodes.item(i);
        if (Node.ELEMENT_NODE != n.getNodeType() || COLUMNS.equals(n.getLocalName()))
            continue;

        NamespaceHandler handler = parserContext.getReaderContext().getNamespaceHandlerResolver()
                .resolve(n.getNamespaceURI());
        if (handler != null) {
            holder = handler.decorate(n, holder, parserContext);
        }
    }

    parserContext.registerBeanComponent(new BeanComponentDefinition(holder));

    // create ConfigurableTable
    bdb = BeanDefinitionBuilder.genericBeanDefinition(tableClass);
    bdb.setScope(BeanDefinition.SCOPE_PROTOTYPE);

    BeanDefinitionUtils.addPropertyReferenceIfNeeded(bdb, element, FIELD_FACTORY);
    BeanDefinitionUtils.addPropertyValueIfNeeded(bdb, element, MULTISELECT);

    if (element.hasAttribute(SELECTABLE)) {
        bdb.addPropertyValue(SELECTABLE, element.getAttribute(SELECTABLE));
    } else {
        // set selectable by default
        bdb.addPropertyValue(SELECTABLE, true);
    }

    // parse columns
    NodeList nl = element.getElementsByTagNameNS(element.getNamespaceURI(), COLUMNS);

    if (nl.getLength() > 0) {
        List columns = parserContext.getDelegate().parseListElement((Element) nl.item(0),
                bdb.getRawBeanDefinition());
        bdb.addPropertyValue(COLUMNS, columns);
    }

    registerBeanDefinition(element, parserContext, tableBeanName, bdb);

    parserContext.popAndRegisterContainingComponent();

    return null;
}

From source file:org.mule.config.spring.MuleHierarchicalBeanDefinitionParserDelegate.java

protected void registerBeanDefinitionHolder(BeanDefinitionHolder bdHolder) {
    //bdHolder = decorateBeanDefinitionIfRequired(ele, bdHolder);
    // Register the final decorated instance.
    BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
    // Send registration event.
    getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}

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

/**
 * Process the given bean element, parsing the bean definition
 * and registering it with the registry.
 *//*from  w  w  w. ja v a2  s. c om*/
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // Register the final decorated instance.
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        } catch (BeanDefinitionStoreException ex) {
            getReaderContext().error(
                    "Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex);
        }
        // Send registration event.
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

From source file:org.springframework.ide.eclipse.beans.core.internal.model.BeansJavaConfig.java

/**
 * register the default annotation processors
 *//* ww  w. j  a v  a  2 s .  c o m*/
protected void registerAnnotationProcessors(ReaderEventListener eventListener) {
    Set<BeanDefinitionHolder> processorDefinitions = AnnotationConfigUtils
            .registerAnnotationConfigProcessors(registry, null);

    // Nest the concrete beans in the surrounding component.
    for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
        eventListener.componentRegistered(new BeanComponentDefinition(processorDefinition));
    }
}