Java Examples for org.springframework.beans.factory.config.BeanDefinitionHolder

/**
	 * {@inheritDoc}
	 */
@Override
@Nullable
protected AbstractBeanDefinition parseInternal(@Nullable Element element, @Nullable ParserContext parserContext) {
    // Here we parse the Spring elements such as < property>
    if (parserContext == null || element == null)
        throw GlobalUtils.createNotInitializedException("element and parserContext");
    // Here we parse the Spring elements such as < property>
    String dataHolderType = element.getAttribute(XsdElementConstants.ATTR_RUNTIMEDATAHOLDER_DATAHOLDERTYPE).toUpperCase();
    if (null == dataHolderType || !StringUtils.hasText(dataHolderType)) {
        throw GlobalUtils.createNotInitializedException("dataHolderType attribute in xml test case");
    }
    RumtimeDataHolderType enumDataHolderType = RumtimeDataHolderType.valueOf(dataHolderType);
    BeanDefinitionHolder holder = parserContext.getDelegate().parseBeanDefinitionElement(element);
    BeanDefinition bDef = holder.getBeanDefinition();
    switch(enumDataHolderType) {
        case PAGESOURCEPARSED:
            bDef.setBeanClassName(PageParsedDataHolder.class.getName());
            break;
        case MANUALASSIGNED:
            bDef.setBeanClassName(ManualAssignedValueDataHolder.class.getName());
            break;
        case CASESERVICEPARSED:
            bDef.setBeanClassName(CaseServiceParsedDataHolder.class.getName());
            break;
        case STEPSERVICEPARSED:
            bDef.setBeanClassName(StepServiceParsedDataHolder.class.getName());
            break;
        case RANDOMALPHATEXT:
            bDef.setBeanClassName(RandomAlphaTextValueDataHolder.class.getName());
            break;
        case RANDOMNUMBERS:
            bDef.setBeanClassName(RandomNumericValueDataHolder.class.getName());
            break;
        case RANDOMTEXTNUMBERS:
            bDef.setBeanClassName(RandomAlphaNumericValueDataHolder.class.getName());
            break;
        case RANDOMEMAIL:
            bDef.setBeanClassName(RandomEmailDataHolder.class.getName());
            break;
        default:
            break;
    }
    String dataType = element.getAttribute(XsdElementConstants.ATTR_RUNTIMEDATAHOLDER_DATATYPE).toUpperCase();
    if (null != dataType && StringUtils.hasText(dataType)) {
        EnumRunTimeDataType enumDataType = EnumRunTimeDataType.valueOf(dataType);
        bDef.getConstructorArgumentValues().addGenericArgumentValue(enumDataType);
    }
    String dataValue = element.getAttribute(XsdElementConstants.ATTR_RUNTIMEDATAHOLDER_DATAVALUE);
    if (StringUtils.hasText(dataValue)) {
        bDef.getConstructorArgumentValues().addGenericArgumentValue(dataValue);
    }
    String leftBoundry = element.getAttribute(XsdElementConstants.ATTR_RUNTIMEDATAHOLDER_LEFTBOUNDRY);
    if (StringUtils.hasText(leftBoundry)) {
        bDef.getConstructorArgumentValues().addGenericArgumentValue(leftBoundry);
    }
    String rightBoundry = element.getAttribute(XsdElementConstants.ATTR_RUNTIMEDATAHOLDER_RIGHTBOUNDRY);
    if (StringUtils.hasText(rightBoundry)) {
        bDef.getConstructorArgumentValues().addGenericArgumentValue(rightBoundry);
    }
    String page = element.getAttribute(XsdElementConstants.ATTR_RUNTIMEDATAHOLDER_PAGE);
    if (StringUtils.hasText(page)) {
        bDef.getConstructorArgumentValues().addGenericArgumentValue(new RuntimeBeanReference(page));
    }
    String beanID = element.getAttribute("id");
    bDef.getConstructorArgumentValues().addGenericArgumentValue(beanID);
    String mappedBeanID = element.getAttribute(XsdElementConstants.ATTR_RUNTIMEDATAHOLDER_SUBCASEMAPPEDDATAHOLDERID);
    if (StringUtils.hasText(mappedBeanID)) {
        bDef.getConstructorArgumentValues().addGenericArgumentValue(mappedBeanID);
    }
    String indexOfSameTypeDataOnPage = element.getAttribute(XsdElementConstants.ATTR_RUNTIMEDATAHOLDER_INDEXOFSAMETYPEDATAONPAGE);
    if (StringUtils.hasText(indexOfSameTypeDataOnPage)) {
        int index = Integer.parseInt(indexOfSameTypeDataOnPage);
        bDef.getConstructorArgumentValues().addGenericArgumentValue(index);
    }
    String randomTextLength = element.getAttribute(XsdElementConstants.ATTR_RUNTIMEDATAHOLDER_RANDOMINPUTLENGTH);
    if (StringUtils.hasText(randomTextLength)) {
        int length = Integer.parseInt(randomTextLength);
        bDef.getConstructorArgumentValues().addGenericArgumentValue(length);
    }
    parserContext.getRegistry().registerBeanDefinition(element.getAttribute("id"), bDef);
    return (AbstractBeanDefinition) bDef;
}

/**
     * 从element创建指定configuration point的bean。如果element�属于该configuration
     * pointçš„å??字空间，则返回<code>null</code>。
     */
public static BeanDefinitionHolder parseConfigurationPointBean(Element element, ConfigurationPoint cp, ParserContext parserContext, BeanDefinitionBuilder containingBeanBuilder) {
    assertNotNull(cp, "configurationPoint");
    BeanDefinitionParserDelegate delegate = parserContext.getDelegate();
    boolean isInnerBean = containingBeanBuilder != null;
    BeanDefinition containingBean = isInnerBean ? containingBeanBuilder.getRawBeanDefinition() : null;
    ElementSelector customSelector = ns(cp.getNamespaceUri());
    // 解�custom element。
    if (customSelector.accept(element)) {
        AbstractBeanDefinition bean = (AbstractBeanDefinition) delegate.parseCustomElement(element, containingBean);
        String beanName = trimToNull(element.getAttribute("id"));
        if (beanName == null) {
            beanName = BeanDefinitionReaderUtils.generateBeanName(bean, parserContext.getRegistry(), isInnerBean);
        }
        return new BeanDefinitionHolder(bean, beanName);
    }
    return null;
}

public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder holder, ParserContext parserContext) {
    String jclRef = node.getAttributes().getNamedItem(JCL_REF).getNodeValue();
    GenericBeanDefinition bd = new GenericBeanDefinition();
    bd.setFactoryBeanName(JCL_FACTORY);
    bd.setFactoryMethodName(JCL_FACTORY_METHOD);
    bd.setConstructorArgumentValues(holder.getBeanDefinition().getConstructorArgumentValues());
    bd.setPropertyValues(holder.getBeanDefinition().getPropertyValues());
    bd.getConstructorArgumentValues().addIndexedArgumentValue(0, new ConstructorArgumentValues.ValueHolder(parserContext.getRegistry().getBeanDefinition(jclRef)));
    bd.getConstructorArgumentValues().addIndexedArgumentValue(1, new ConstructorArgumentValues.ValueHolder(holder.getBeanDefinition().getBeanClassName()));
    BeanDefinitionHolder newHolder = new BeanDefinitionHolder(bd, holder.getBeanName());
    createDependencyOnJcl(node, newHolder, parserContext);
    return newHolder;
}

/**
	 * {@inheritDoc}
	 */
@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);
    BeanDefinitionUtils.addPropertyValueIfNeeded(bdb, element, CONTAINER_CLASS);
    BeanDefinitionUtils.addPropertyValueIfNeeded(bdb, element, DIALOG);
    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.addPropertyValueIfNeeded(bdb, element, MULTISELECT);
    if (element.hasAttribute(FIELD_FACTORY))
        bdb.addPropertyReference(FIELD_FACTORY_PROPERTY, element.getAttribute(FIELD_FACTORY));
    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;
}

/** Extracts the actual value from the given {@link ValueHolder}, resolving
     * bean references through the bean factory.
     *
     * @param holder The holder to resolve
     *
     * @return The actual value of the holder
     */
protected Object getActualValue(final ValueHolder holder) {
    Validate.notNull(holder, "The value holder cannot be null.");
    log.trace("Start getActualValue");
    Object value = holder.getValue();
    if (value instanceof BeanDefinitionHolder) {
        // Constructor argument is an inner bean
        throw new IllegalArgumentException("Inner bean definitions are not supported");
    }
    if (value instanceof BeanReference) {
        BeanReference ref = (BeanReference) value;
        if (log.isDebugEnabled()) {
            log.debug("Value is a reference to " + ref.getBeanName() + ", resolving reference");
        }
        value = beanFactory.getBean(ref.getBeanName());
    } else if (value instanceof TypedStringValue) {
        TypedStringValue typedStringValue = (TypedStringValue) value;
        value = typedStringValue.getValue();
    }
    if (log.isTraceEnabled()) {
        log.trace("Finishing getActualValue, actual value is " + value);
    }
    return value;
}

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.");
    }
    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;
}

private static ManagedList<BeanDefinition> extractBeanSubElements(Element parentElement, ParserContext parserContext) {
    ManagedList<BeanDefinition> list = new ManagedList<>();
    list.setSource(parserContext.extractSource(parentElement));
    for (Element beanElement : DomUtils.getChildElementsByTagName(parentElement, "bean")) {
        BeanDefinitionHolder beanDef = parserContext.getDelegate().parseBeanDefinitionElement(beanElement);
        beanDef = parserContext.getDelegate().decorateBeanDefinitionIfRequired(beanElement, beanDef);
        list.add(beanDef.getBeanDefinition());
    }
    return list;
}

public <T> void parse(Class<T> beanClass, String[] args) {
    OptionParser parser = new OptionParser();
    parser.acceptsAll(Arrays.asList("h", "help"), "Usage information");
    CommandLineMetaData metaData = new CommandLineMetaData(beanClass);
    metaData.register(parser);
    OptionSet optionSet;
    try {
        optionSet = parser.parse(args);
        if (optionSet.has("help")) {
            // triggers usage
            throw new UsageException(parser, metaData, null);
        }
        CommandLineBeanDefinition beanDef = new CommandLineBeanDefinition(beanClass, metaData, optionSet);
        String beanName = beanNameGenerator.generateBeanName(beanDef, this.registry);
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDef, beanName);
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    } catch (OptionException e) {
        throw new UsageException(parser, metaData, e);
    } catch (OperandException e) {
        throw new UsageException(parser, metaData, e);
    }
}

/**
	 * Parses the supplied <code><bean></code> element. May return <code>null</code>
	 * if there were errors during parse. Errors are reported to the
	 * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
	 */
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
    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");
        }
    }
    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;
}

/**
	 * 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}.
	 */
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, 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;
}

@Test
public void testAutowiredMethodParameterWithStaticallyQualifiedCandidate() {
    GenericApplicationContext context = new GenericApplicationContext();
    ConstructorArgumentValues cavs = new ConstructorArgumentValues();
    cavs.addGenericArgumentValue(JUERGEN);
    RootBeanDefinition person = new RootBeanDefinition(QualifiedPerson.class, cavs, null);
    context.registerBeanDefinition(JUERGEN, ScopedProxyUtils.createScopedProxy(new BeanDefinitionHolder(person, JUERGEN), context, true).getBeanDefinition());
    context.registerBeanDefinition("autowired", new RootBeanDefinition(QualifiedMethodParameterTestBean.class));
    AnnotationConfigUtils.registerAnnotationConfigProcessors(context);
    context.refresh();
    QualifiedMethodParameterTestBean bean = (QualifiedMethodParameterTestBean) context.getBean("autowired");
    assertEquals(JUERGEN, bean.getPerson().getName());
}

@SuppressWarnings("unchecked")
@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(KBaseFactoryBean.class);
    String id = element.getAttribute(ATTRIBUTE_ID);
    emptyAttributeCheck(element.getLocalName(), ATTRIBUTE_ID, id);
    factory.addPropertyValue("kBaseName", id);
    factory.addPropertyValue("id", id);
    factory.addPropertyValue("packages", element.getAttribute(ATTRIBUTE_PACKAGES));
    factory.addPropertyValue("includes", element.getAttribute(ATTRIBUTE_INCLUDES));
    factory.addPropertyValue("eventProcessingMode", element.getAttribute(ATTRIBUTE_EVENT_MODE));
    factory.addPropertyValue("equalsBehavior", element.getAttribute(ATTRIBUTE_EQUALS));
    factory.addPropertyValue("declarativeAgenda", element.getAttribute(ATTRIBUTE_DECLARATIVE_AGENDA));
    factory.addPropertyValue("scope", element.getAttribute(ATTRIBUTE_SCOPE));
    factory.addPropertyValue("def", element.getAttribute(ATTRIBUTE_DEFAULT));
    element.setAttribute("name", id);
    List<Element> ksessionElements = DomUtils.getChildElementsByTagName(element, "ksession");
    if (ksessionElements != null && !ksessionElements.isEmpty()) {
        for (Element kbaseElement : ksessionElements) {
            BeanDefinitionHolder obj = (BeanDefinitionHolder) parserContext.getDelegate().parsePropertySubElement(kbaseElement, null);
            obj.getBeanDefinition().getPropertyValues().addPropertyValue("kBaseName", id);
            obj.getBeanDefinition().getPropertyValues().addPropertyValue("kBase", new RuntimeBeanReference(id));
        }
    }
    return factory.getBeanDefinition();
}

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    List<String> nodes = null;
    try {
        nodes = getChildren(this.configPath);
        List<BeanDefinitionHolder> bdHolder = new ArrayList<>();
        for (String node : nodes) {
            List<BeanDefinitionHolder> tmp = publishNode(node);
            if (tmp != null) {
                bdHolder.addAll(tmp);
            }
        }
        for (BeanDefinitionHolder definitionHolder : bdHolder) {
            registerBeanDefinition(definitionHolder, registry);
        }
        if (logger.isDebugEnabled()) {
            StringBuffer sb = new StringBuffer("[");
            int counter = 1;
            for (BeanDefinitionHolder dh : bdHolder) {
                sb.append(dh.getBeanName());
                if (counter++ != bdHolder.size()) {
                    sb.append(",");
                }
            }
            sb.append("] registered into spring's container.");
            logger.debug(sb.toString());
        }
    } catch (UnifiedConfigException e) {
        throw new BeanCreationException("Failed to create bean", e);
    }
}

/** {@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());
    }
    return def;
}

/** {@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());
    }
    return def;
}

private void configureDefaultActivitiRegistry(String registryBeanName, BeanDefinitionRegistry registry) {
    if (!beanAlreadyConfigured(registry, registryBeanName, ActivitiStateHandlerRegistry.class)) {
        String registryName = ActivitiStateHandlerRegistry.class.getName();
        log.info("registering a " + registryName + " instance under bean name " + ActivitiContextUtils.ACTIVITI_REGISTRY_BEAN_NAME + ".");
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition();
        rootBeanDefinition.setBeanClassName(registryName);
        rootBeanDefinition.getPropertyValues().addPropertyValue("processEngine", this.processEngine);
        BeanDefinitionHolder holder = new BeanDefinitionHolder(rootBeanDefinition, registryBeanName);
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }
}

public BeanDefinitionHolder parseAsHolder(Element componentElement, ParserContext parserContext) {
    // save parser context
    this.parserContext = parserContext;
    this.defaults = new BlueprintDefaultsDefinition(componentElement.getOwnerDocument(), parserContext);
    // let Spring do its standard parsing
    BeanDefinitionHolder bdHolder = parseComponentDefinitionElement(componentElement, null);
    BeanDefinition bd = bdHolder.getBeanDefinition();
    if (bd != null) {
        bd.setAttribute(ParsingUtils.BLUEPRINT_MARKER_NAME, Boolean.TRUE);
    }
    return bdHolder;
}

@Deprecated
private void registerStateHandlerAnnotationBeanFactoryPostProcessor(Element element, ParserContext context) {
    Class clz = StateHandlerAnnotationBeanFactoryPostProcessor.class;
    BeanDefinitionBuilder postProcessorBuilder = BeanDefinitionBuilder.genericBeanDefinition(clz.getName());
    BeanDefinitionHolder postProcessorHolder = new BeanDefinitionHolder(postProcessorBuilder.getBeanDefinition(), ActivitiContextUtils.ANNOTATION_STATE_HANDLER_BEAN_FACTORY_POST_PROCESSOR_BEAN_NAME);
    configureProcessEngine(postProcessorBuilder.getBeanDefinition(), element);
    BeanDefinitionReaderUtils.registerBeanDefinition(postProcessorHolder, context.getRegistry());
}

private void configureDefaultActivitiRegistry(String registryBeanName, BeanDefinitionRegistry registry) {
    if (!beanAlreadyConfigured(registry, registryBeanName, ActivitiStateHandlerRegistry.class)) {
        String registryName = ActivitiStateHandlerRegistry.class.getName();
        log.info("registering a " + registryName + " instance under bean name " + ActivitiContextUtils.ACTIVITI_REGISTRY_BEAN_NAME + ".");
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition();
        rootBeanDefinition.setBeanClassName(registryName);
        rootBeanDefinition.getPropertyValues().addPropertyValue("processEngine", this.processEngine);
        BeanDefinitionHolder holder = new BeanDefinitionHolder(rootBeanDefinition, registryBeanName);
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }
}

@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
    RootBeanDefinition handlerMappingDef = new RootBeanDefinition(AtmosRequestMappingHandlerMapping.class);
    handlerMappingDef.setSource(parserContext.extractSource(element));
    boolean autoRefreshable = false;
    Element autoRefreshableElem = DomUtils.getChildElementByTagName(element, "autoRefreshable");
    if (autoRefreshableElem != null) {
        autoRefreshable = Boolean.parseBoolean(autoRefreshableElem.getAttribute("value"));
    }
    List<Element> dirElemList = DomUtils.getChildElementsByTagName(element, "location");
    String[] dirStrArr = new String[dirElemList.size()];
    for (int i = 0; i < dirStrArr.length; i++) {
        dirStrArr[i] = dirElemList.get(i).getTextContent();
    }
    handlerMappingDef.getPropertyValues().addPropertyValue(PROPERTY_USER_SOURCE_LOCATION, dirStrArr);
    handlerMappingDef.getPropertyValues().addPropertyValue(PROPERTY_AUTO_REFRESHABLE, autoRefreshable);
    String handlerMappingName = parserContext.getReaderContext().registerWithGeneratedName(handlerMappingDef);
    BeanDefinitionHolder handlerMappingBeanDefinitionHolder = new BeanDefinitionHolder(handlerMappingDef, handlerMappingName);
    BeanDefinitionReaderUtils.registerBeanDefinition(handlerMappingBeanDefinitionHolder, parserContext.getRegistry());
    RootBeanDefinition propertySourceConfigurerDef = new RootBeanDefinition(PropertySourcesPlaceholderConfigurer.class);
    String propertySourceConfigurerName = parserContext.getReaderContext().registerWithGeneratedName(propertySourceConfigurerDef);
    BeanDefinitionHolder propertySourceConfigurerBeanDefinitionHolder = new BeanDefinitionHolder(propertySourceConfigurerDef, propertySourceConfigurerName);
    BeanDefinitionReaderUtils.registerBeanDefinition(propertySourceConfigurerBeanDefinitionHolder, parserContext.getRegistry());
    return handlerMappingDef;
}

/**
     * {@inheritDoc}
     */
@Override
protected void doParse(final Element element, final ParserContext parserContext, final BeanDefinitionBuilder builder) {
    BeanDefinitionBuilder factoryBuilder = BeanDefinitionBuilder.genericBeanDefinition(FtpServerFactory.class);
    List<Element> childs = SpringUtil.getChildElements(element);
    for (Element childElm : childs) {
        String childName = childElm.getLocalName();
        if ("listeners".equals(childName)) {
            Map<?, ?> listeners = parseListeners(childElm, parserContext, builder);
            if (listeners.size() > 0) {
                factoryBuilder.addPropertyValue("listeners", listeners);
            }
        } else if ("ftplets".equals(childName)) {
            Map<?, ?> ftplets = parseFtplets(childElm, parserContext, builder);
            factoryBuilder.addPropertyValue("ftplets", ftplets);
        } else if ("file-user-manager".equals(childName) || "db-user-manager".equals(childName)) {
            Object userManager = parserContext.getDelegate().parseCustomElement(childElm, builder.getBeanDefinition());
            factoryBuilder.addPropertyValue("userManager", userManager);
        } else if ("user-manager".equals(childName)) {
            factoryBuilder.addPropertyValue("userManager", SpringUtil.parseSpringChildElement(childElm, parserContext, builder));
        } else if ("native-filesystem".equals(childName)) {
            Object fileSystem = parserContext.getDelegate().parseCustomElement(childElm, builder.getBeanDefinition());
            factoryBuilder.addPropertyValue("fileSystem", fileSystem);
        } else if ("filesystem".equals(childName)) {
            factoryBuilder.addPropertyValue("fileSystem", SpringUtil.parseSpringChildElement(childElm, parserContext, builder));
        } else if ("commands".equals(childName)) {
            Object commandFactory = parserContext.getDelegate().parseCustomElement(childElm, builder.getBeanDefinition());
            factoryBuilder.addPropertyValue("commandFactory", commandFactory);
        } else if ("messages".equals(childName)) {
            MessageResource mr = parseMessageResource(childElm, parserContext, builder);
            factoryBuilder.addPropertyValue("messageResource", mr);
        } else {
            throw new FtpServerConfigurationException("Unknown configuration name: " + childName);
        }
    }
    // Configure login limits
    ConnectionConfigFactory connectionConfig = new ConnectionConfigFactory();
    if (StringUtils.hasText(element.getAttribute("max-logins"))) {
        connectionConfig.setMaxLogins(SpringUtil.parseInt(element, "max-logins"));
    }
    if (StringUtils.hasText(element.getAttribute("max-threads"))) {
        connectionConfig.setMaxThreads(SpringUtil.parseInt(element, "max-threads"));
    }
    if (StringUtils.hasText(element.getAttribute("max-anon-logins"))) {
        connectionConfig.setMaxAnonymousLogins(SpringUtil.parseInt(element, "max-anon-logins"));
    }
    if (StringUtils.hasText(element.getAttribute("anon-enabled"))) {
        connectionConfig.setAnonymousLoginEnabled(SpringUtil.parseBoolean(element, "anon-enabled", true));
    }
    if (StringUtils.hasText(element.getAttribute("max-login-failures"))) {
        connectionConfig.setMaxLoginFailures(SpringUtil.parseInt(element, "max-login-failures"));
    }
    if (StringUtils.hasText(element.getAttribute("login-failure-delay"))) {
        connectionConfig.setLoginFailureDelay(SpringUtil.parseInt(element, "login-failure-delay"));
    }
    factoryBuilder.addPropertyValue("connectionConfig", connectionConfig.createConnectionConfig());
    BeanDefinition factoryDefinition = factoryBuilder.getBeanDefinition();
    String factoryName = parserContext.getReaderContext().generateBeanName(factoryDefinition);
    BeanDefinitionHolder factoryHolder = new BeanDefinitionHolder(factoryDefinition, factoryName);
    registerBeanDefinition(factoryHolder, parserContext.getRegistry());
    // set the factory on the listener bean
    builder.getRawBeanDefinition().setFactoryBeanName(factoryName);
    builder.getRawBeanDefinition().setFactoryMethodName("createServer");
}

@Override
public void after(Object target, Object[] args, Object result, Throwable throwable) {
    if (result == null || throwable != null || !(result instanceof Set)) {
        return;
    }
    try {
        final Set<Object> set = (Set<Object>) result;
        for (Object o : set) {
            if (o instanceof BeanDefinitionHolder) {
                final BeanDefinitionHolder beanDefinitionHolder = (BeanDefinitionHolder) o;
                if (filter.isTarget(SpringBeansTargetScope.COMPONENT_SCAN, beanDefinitionHolder.getBeanName(), beanDefinitionHolder.getBeanDefinition())) {
                    final String className = beanDefinitionHolder.getBeanDefinition().getBeanClassName();
                    this.instrumentor.transform(this.classLoader, className, this.transformer);
                    this.filter.addTransformed(className);
                }
            }
        }
    } catch (Throwable t) {
        if (logger.isWarnEnabled()) {
            logger.warn("AFTER. Caused:{}", t.getMessage(), t);
        }
    }
}

/**
     * Parses out a set of configured esper statement listeners.
     * 
     * @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;
}

@Override
public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder beanDefinitionHolder, ParserContext parserContext) {
    String publishType = null;
    String beanClassName;
    // factory will be stored as an attribute.
    if (beanDefinitionHolder.getBeanDefinition().getAttribute("originalClassName") != null) {
        beanClassName = beanDefinitionHolder.getBeanDefinition().getAttribute("originalClassName").toString();
    } else {
        beanClassName = beanDefinitionHolder.getBeanDefinition().getBeanClassName();
    }
    if (node.getAttributes().getNamedItem(ATTR) != null) {
        // publish as type if specified
        publishType = node.getAttributes().getNamedItem(ATTR).getNodeValue();
    } else {
        // fallback to publish as itself
        publishType = beanClassName;
    }
    // capture the "ID" of the bean as an attribute so it can be queried for
    beanDefinitionHolder.getBeanDefinition().setAttribute("id", beanDefinitionHolder.getBeanName());
    NodeList nodes = node.getChildNodes();
    for (int i = 0; i < nodes.getLength(); i++) {
        Node n = nodes.item(i);
        if (stripNamespace(n.getNodeName()).equals(Const.ATTRIBUTES)) {
            NodeList attrnodes = n.getChildNodes();
            for (int y = 0; y < attrnodes.getLength(); y++) {
                Node an = attrnodes.item(y);
                if (stripNamespace(an.getNodeName()).equals(Const.ATTR)) {
                    beanDefinitionHolder.getBeanDefinition().setAttribute(an.getAttributes().getNamedItem(Const.KEY).getNodeValue(), an.getAttributes().getNamedItem(Const.VALUE).getNodeValue());
                }
            }
        }
    }
    try {
        List<Class<?>> classesToPublish = new ArrayList<Class<?>>();
        Class<?> clazz = findClass(beanClassName);
        if (specialPublishTypes.INTERFACES.name().equals(publishType)) {
            if (clazz.isInterface()) {
                // publish as self if interface already (re-publish flow)
                classesToPublish.add(clazz);
            } else {
                classesToPublish.addAll(ClassUtils.getAllInterfaces(clazz));
            }
        } else if (specialPublishTypes.CLASSES.name().equals(publishType)) {
            classesToPublish.addAll(ClassUtils.getAllSuperclasses(clazz));
            classesToPublish.add(clazz);
        } else if (specialPublishTypes.ALL.name().equals(publishType)) {
            classesToPublish.addAll(ClassUtils.getAllInterfaces(clazz));
            classesToPublish.addAll(ClassUtils.getAllSuperclasses(clazz));
            classesToPublish.add(clazz);
        } else {
            classesToPublish.add(getClass().getClassLoader().loadClass(publishType));
        }
        String beanFactoryId = null;
        if (parserContext.getRegistry().containsBeanDefinition(Const.FACTORY_MARKER) == false) {
            beanFactoryId = UUID.randomUUID().toString();
            parserContext.getRegistry().registerBeanDefinition(Const.FACTORY_MARKER, BeanDefinitionBuilder.genericBeanDefinition(Marker.class).setScope(BeanDefinition.SCOPE_PROTOTYPE).addConstructorArgValue(beanFactoryId).getBeanDefinition());
        } else {
            beanFactoryId = (String) parserContext.getRegistry().getBeanDefinition(Const.FACTORY_MARKER).getConstructorArgumentValues().getArgumentValue(0, String.class).getValue();
        }
        for (Class cls : classesToPublish) {
            PublishedBeanRegistry.registerBean(beanDefinitionHolder.getBeanName(), cls, beanFactoryId);
        }
    } catch (ClassNotFoundException e) {
        throw new RuntimeException("Cannot find class for publish type: " + publishType + " specified on publish of bean id: " + beanDefinitionHolder.getBeanName(), e);
    }
    return beanDefinitionHolder;
}

@Override
public void after(Object target, Object[] args, Object result, Throwable throwable) {
    if (result == null || throwable != null || !(result instanceof Set)) {
        return;
    }
    try {
        final Set<Object> set = (Set<Object>) result;
        for (Object o : set) {
            if (o instanceof BeanDefinitionHolder) {
                final BeanDefinitionHolder beanDefinitionHolder = (BeanDefinitionHolder) o;
                if (filter.isTarget(SpringBeansTargetScope.COMPONENT_SCAN, beanDefinitionHolder.getBeanName(), beanDefinitionHolder.getBeanDefinition())) {
                    final String className = beanDefinitionHolder.getBeanDefinition().getBeanClassName();
                    this.instrumentor.transform(this.classLoader, className, this.transformer);
                    this.filter.addTransformed(className);
                }
            }
        }
    } catch (Throwable t) {
        if (logger.isWarnEnabled()) {
            logger.warn("AFTER. Caused:{}", t.getMessage(), t);
        }
    }
}

/**
     * {@inheritDoc}
     */
@Override
protected void doParse(final Element element, final ParserContext parserContext, final BeanDefinitionBuilder builder) {
    BeanDefinitionBuilder factoryBuilder = BeanDefinitionBuilder.genericBeanDefinition(SmscServerFactory.class);
    List<Element> childs = SpringUtil.getChildElements(element);
    for (Element childElm : childs) {
        String childName = childElm.getLocalName();
        if ("listeners".equals(childName)) {
            Map<?, ?> listeners = this.parseListeners(childElm, parserContext, builder);
            if (listeners.size() > 0) {
                factoryBuilder.addPropertyValue("listeners", listeners);
            }
        } else if ("smsclets".equals(childName)) {
            Map<?, ?> smsclets = this.parseSmsclets(childElm, parserContext, builder);
            factoryBuilder.addPropertyValue("smsclets", smsclets);
        } else if ("message-manager".equals(childName)) {
            Object userManager = parserContext.getDelegate().parseCustomElement(childElm, builder.getBeanDefinition());
            factoryBuilder.addPropertyValue("messageManager", userManager);
        } else if ("file-user-manager".equals(childName) || "db-user-manager".equals(childName)) {
            Object userManager = parserContext.getDelegate().parseCustomElement(childElm, builder.getBeanDefinition());
            factoryBuilder.addPropertyValue("userManager", userManager);
        } else if ("user-manager".equals(childName)) {
            factoryBuilder.addPropertyValue("userManager", SpringUtil.parseSpringChildElement(childElm, parserContext, builder));
        } else if ("commands".equals(childName)) {
            Object commandFactory = parserContext.getDelegate().parseCustomElement(childElm, builder.getBeanDefinition());
            factoryBuilder.addPropertyValue("commandFactory", commandFactory);
        } else {
            throw new SmscServerConfigurationException("Unknown configuration name: " + childName);
        }
    }
    // Configure the connection config
    ConnectionConfigFactory connectionConfig = new ConnectionConfigFactory();
    if (StringUtils.hasText(element.getAttribute("max-binds"))) {
        connectionConfig.setMaxBinds(SpringUtil.parseInt(element, "max-binds"));
    }
    if (StringUtils.hasText(element.getAttribute("min-threads"))) {
        connectionConfig.setMinThreads(SpringUtil.parseInt(element, "min-threads"));
    }
    if (StringUtils.hasText(element.getAttribute("max-threads"))) {
        connectionConfig.setMaxThreads(SpringUtil.parseInt(element, "max-threads"));
    }
    if (StringUtils.hasText(element.getAttribute("max-bind-failures"))) {
        connectionConfig.setMaxBindFailures(SpringUtil.parseInt(element, "max-bind-failures"));
    }
    if (StringUtils.hasText(element.getAttribute("bind-failure-delay"))) {
        connectionConfig.setBindFailureDelay(SpringUtil.parseInt(element, "bind-failure-delay"));
    }
    factoryBuilder.addPropertyValue("connectionConfig", connectionConfig.createConnectionConfig());
    // Configure the delivery manager
    DeliveryManagerConfigFactory deliveryManagerConfig = new DeliveryManagerConfigFactory();
    if (StringUtils.hasText(element.getAttribute("delivery-threads"))) {
        deliveryManagerConfig.setManagerThreads(SpringUtil.parseInt(element, "delivery-threads"));
    }
    if (StringUtils.hasText(element.getAttribute("min-delivery-threads"))) {
        deliveryManagerConfig.setMinThreads(SpringUtil.parseInt(element, "min-delivery-threads"));
    }
    if (StringUtils.hasText(element.getAttribute("max-delivery-threads"))) {
        deliveryManagerConfig.setMaxThreads(SpringUtil.parseInt(element, "max-delivery-threads"));
    }
    if (StringUtils.hasText(element.getAttribute("delivery-retry-periods"))) {
        deliveryManagerConfig.setDeliveryRetryPeriods(element.getAttribute("delivery-retry-periods"));
    }
    if (StringUtils.hasText(element.getAttribute("delivery-poll-time"))) {
        deliveryManagerConfig.setDeliveryPollTime(SpringUtil.parseInt(element, "delivery-poll-time"));
    }
    factoryBuilder.addPropertyValue("deliveryManagerConfig", deliveryManagerConfig.createDeliveryManagerConfig());
    if (StringUtils.hasText(element.getAttribute("sessionLockTimeout"))) {
        factoryBuilder.addPropertyValue("session-lock-timeout", SpringUtil.parseInt(element, "session-lock-timeout"));
    }
    BeanDefinition factoryDefinition = factoryBuilder.getBeanDefinition();
    String factoryName = parserContext.getReaderContext().generateBeanName(factoryDefinition);
    BeanDefinitionHolder factoryHolder = new BeanDefinitionHolder(factoryDefinition, factoryName);
    this.registerBeanDefinition(factoryHolder, parserContext.getRegistry());
    // set the factory on the listener bean
    builder.getRawBeanDefinition().setFactoryBeanName(factoryName);
    builder.getRawBeanDefinition().setFactoryMethodName("createServer");
}

// patterned after Spring Integration IntegrationComponentScanRegistrar
@Override
public void registerBeanDefinitions(final AnnotationMetadata importingClassMetadata, final BeanDefinitionRegistry registry) {
    Map<String, Object> componentScan = importingClassMetadata.getAnnotationAttributes(RemoteApplicationEventScan.class.getName(), false);
    Set<String> basePackages = new HashSet<>();
    for (String pkg : (String[]) componentScan.get("value")) {
        if (StringUtils.hasText(pkg)) {
            basePackages.add(pkg);
        }
    }
    for (String pkg : (String[]) componentScan.get("basePackages")) {
        if (StringUtils.hasText(pkg)) {
            basePackages.add(pkg);
        }
    }
    for (Class<?> clazz : (Class[]) componentScan.get("basePackageClasses")) {
        basePackages.add(ClassUtils.getPackageName(clazz));
    }
    if (basePackages.isEmpty()) {
        basePackages.add(ClassUtils.getPackageName(importingClassMetadata.getClassName()));
    }
    BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(BusJacksonMessageConverter.class);
    beanDefinitionBuilder.addPropertyValue("packagesToScan", basePackages.toArray(new String[basePackages.size()]));
    AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
    BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, "busJsonConverter");
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

/**
	 * Parses inner bean definition from an dom element.
	 *
	 * @param element the dom element
	 * @param parserContext the parser context
	 * @return bean component definition
	 */
public static BeanComponentDefinition parseInnerHandlerDefinition(Element element, ParserContext parserContext) {
    // parses out the inner bean definition for concrete implementation if defined
    List<Element> childElements = DomUtils.getChildElementsByTagName(element, "bean");
    BeanComponentDefinition innerComponentDefinition = null;
    if (childElements != null && childElements.size() == 1) {
        Element beanElement = childElements.get(0);
        BeanDefinitionParserDelegate delegate = parserContext.getDelegate();
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(beanElement);
        bdHolder = delegate.decorateBeanDefinitionIfRequired(beanElement, bdHolder);
        BeanDefinition inDef = bdHolder.getBeanDefinition();
        innerComponentDefinition = new BeanComponentDefinition(inDef, bdHolder.getBeanName());
    }
    String ref = element.getAttribute(REF_ATTRIBUTE);
    if (StringUtils.hasText(ref) && innerComponentDefinition != null) {
        parserContext.getReaderContext().error("Ambiguous definition. Inner bean " + (innerComponentDefinition == null ? innerComponentDefinition : innerComponentDefinition.getBeanDefinition().getBeanClassName()) + " declaration and \"ref\" " + ref + " are not allowed together on element " + createElementDescription(element) + ".", parserContext.extractSource(element));
    }
    return innerComponentDefinition;
}

public static BeanComponentDefinition parseInnerHandlerDefinition(Element element, ParserContext parserContext) {
    // parses out the inner bean definition for concrete implementation if defined
    List<Element> childElements = DomUtils.getChildElementsByTagName(element, "bean");
    BeanComponentDefinition innerComponentDefinition = null;
    if (childElements != null && childElements.size() == 1) {
        Element beanElement = childElements.get(0);
        BeanDefinitionParserDelegate delegate = parserContext.getDelegate();
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(beanElement);
        bdHolder = delegate.decorateBeanDefinitionIfRequired(beanElement, bdHolder);
        BeanDefinition inDef = bdHolder.getBeanDefinition();
        innerComponentDefinition = new BeanComponentDefinition(inDef, bdHolder.getBeanName());
    }
    String ref = element.getAttribute(REF_ATTRIBUTE);
    if (StringUtils.hasText(ref) && innerComponentDefinition != null) {
        parserContext.getReaderContext().error("Ambiguous definition. Inner bean " + (innerComponentDefinition.getBeanDefinition().getBeanClassName()) + " declaration and \"ref\" " + ref + " are not allowed together on element " + IntegrationNamespaceUtils.createElementDescription(element) + ".", parserContext.extractSource(element));
    }
    return innerComponentDefinition;
}

public void testParseWithAnonymousBean() {
    String beanName = "";
    Element beanElement = createBeanElementBuilder(beanName).toXml();
    Element referenceElement = elementBuilder.toXml();
    referenceElement.appendChild(beanElement);
    RootBeanDefinition beanDefinition = new RootBeanDefinition(String.class);
    BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, beanName);
    delegate.parseBeanDefinitionElement(beanElement, null);
    helperControl.setReturnValue(holder);
    helperControl.replay();
    // method to test
    Object actual = parser.parse(referenceElement, parserContext, true);
    assertSame(holder, actual);
    // assert the bean definition was not registered.
    assertEquals(0, registry.getBeanDefinitionCount());
}

private BeanDefinitionHolder handlerAnalyzerDefinition(Element element, RootBeanDefinition definition, ParserContext parserContext) {
    Element beanElement = DomUtils.getChildElementByTagName(element, BEAN_ELEMENT);
    if (beanElement != null) {
        //Compute the inner bean of the analyzer
        BeanDefinitionParserDelegate delegate = parserContext.getDelegate();
        BeanDefinitionHolder holder = delegate.parseBeanDefinitionElement(beanElement, definition);
        if (holder != null) {
            holder = delegate.decorateBeanDefinitionIfRequired(beanElement, holder);
        }
        return holder;
    }
    return null;
}

public static BeanComponentDefinition parseInnerBeanDefinition(Element element, ParserContext parserContext) {
    List<Element> childElements = DomUtils.getChildElementsByTagName(element, "bean");
    BeanComponentDefinition innerComponentDefinition = null;
    if (childElements != null && childElements.size() == 1) {
        Element beanElement = childElements.get(0);
        if (!"http://www.springframework.org/schema/beans".equals(beanElement.getNamespaceURI())) {
            throw new IllegalStateException("Illegal inner child element");
        }
        BeanDefinitionParserDelegate delegate = parserContext.getDelegate();
        BeanDefinitionHolder beanDefinitionHolder = delegate.parseBeanDefinitionElement(beanElement);
        beanDefinitionHolder = delegate.decorateBeanDefinitionIfRequired(beanElement, beanDefinitionHolder);
        BeanDefinition beanDefinition = beanDefinitionHolder.getBeanDefinition();
        innerComponentDefinition = new BeanComponentDefinition(beanDefinition, beanDefinitionHolder.getBeanName());
    }
    return innerComponentDefinition;
}

@Override
protected Set<BeanDefinitionHolder> doScan(String... scanPackages) {
    Set<BeanDefinitionHolder> definitions = super.doScan(scanPackages);
    if (definitions.isEmpty()) {
        log.warn("No bean definition found in target packages " + Arrays.toString(scanPackages));
    } else {
        for (BeanDefinitionHolder holder : definitions) {
            GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();
            processBeanDefinition(definition);
        }
    }
    return definitions;
}

private static void registerComponent(ParserContext parserContext, BeanDefinitionBuilder builder, String beanName) {
    builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    parserContext.getRegistry().registerBeanDefinition(beanName, builder.getBeanDefinition());
    BeanDefinitionHolder holder = new BeanDefinitionHolder(builder.getBeanDefinition(), beanName);
    parserContext.registerComponent(new BeanComponentDefinition(holder));
}

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    String accessTokenProviderRef = element.getAttribute("access-token-provider");
    builder.addConstructorArgReference(element.getAttribute("resource"));
    BeanDefinitionBuilder request = BeanDefinitionBuilder.genericBeanDefinition(DefaultAccessTokenRequest.class);
    request.setScope("request");
    request.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    request.addConstructorArgValue("#{request.parameterMap}");
    request.addPropertyValue("currentUri", "#{request.getAttribute('currentUri')}");
    BeanDefinitionHolder requestDefinition = new BeanDefinitionHolder(request.getRawBeanDefinition(), parserContext.getReaderContext().generateBeanName(request.getRawBeanDefinition()));
    parserContext.getRegistry().registerBeanDefinition(requestDefinition.getBeanName(), requestDefinition.getBeanDefinition());
    BeanDefinitionHolder requestHolder = ScopedProxyUtils.createScopedProxy(requestDefinition, parserContext.getRegistry(), false);
    BeanDefinitionBuilder scopedContext = BeanDefinitionBuilder.genericBeanDefinition(DefaultOAuth2ClientContext.class);
    scopedContext.setScope("session");
    scopedContext.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    BeanDefinitionHolder contextDefinition = new BeanDefinitionHolder(scopedContext.getRawBeanDefinition(), parserContext.getReaderContext().generateBeanName(scopedContext.getRawBeanDefinition()));
    parserContext.getRegistry().registerBeanDefinition(contextDefinition.getBeanName(), contextDefinition.getBeanDefinition());
    BeanDefinitionHolder contextHolder = ScopedProxyUtils.createScopedProxy(contextDefinition, parserContext.getRegistry(), false);
    scopedContext.addConstructorArgValue(requestHolder.getBeanDefinition());
    BeanDefinitionBuilder bareContext = BeanDefinitionBuilder.genericBeanDefinition(DefaultOAuth2ClientContext.class);
    BeanDefinitionBuilder context = BeanDefinitionBuilder.genericBeanDefinition(OAuth2ClientContextFactoryBean.class);
    context.addPropertyValue("scopedContext", contextHolder.getBeanDefinition());
    context.addPropertyValue("bareContext", bareContext.getBeanDefinition());
    context.addPropertyReference("resource", element.getAttribute("resource"));
    builder.addConstructorArgValue(context.getBeanDefinition());
    if (StringUtils.hasText(accessTokenProviderRef)) {
        builder.addPropertyReference("accessTokenProvider", accessTokenProviderRef);
    }
    parserContext.getDelegate().parsePropertyElements(element, builder.getBeanDefinition());
}

/**
     * Calls the parent search that will search and register all the candidates.
     * Then the registered objects are post processed to set them as
     * MapperFactoryBeans
     */
@Override
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
    if (beanDefinitions.isEmpty()) {
        logger.warn("No eqler was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
    } else {
        for (BeanDefinitionHolder holder : beanDefinitions) {
            GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();
            if (logger.isDebugEnabled()) {
                logger.debug("Creating EqlerFactoryBean with name '" + holder.getBeanName() + "' and '" + definition.getBeanClassName() + "' eqlerInterface");
            }
            // the mapper interface is the original class of the bean
            // but, the actual class of the bean is MapperFactoryBean
            definition.getPropertyValues().add("eqlerInterface", definition.getBeanClassName());
            definition.setBeanClass(EqlerFactoryBean.class);
        }
    }
    return beanDefinitions;
}

@Override
protected AbstractBeanDefinition parse(Element element, NamedNodeMap attributes, ParserContext parserContext) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
    builder.getRawBeanDefinition().setBeanClass(SpringFactoryBean.class);
    //�例
    builder.setScope(BeanDefinition.SCOPE_SINGLETON);
    //
    String shareEvent = revertProperty(attributes, "shareEvent");
    if (StringUtils.isNotBlank(shareEvent)) {
        builder.addPropertyValue("shareEvent", Boolean.parseBoolean(shareEvent));
    }
    //
    String startWith = revertProperty(attributes, "startWith");
    String startWithRef = revertProperty(attributes, "startWithRef");
    if (StringUtils.isNotBlank(startWith) || StringUtils.isNotBlank(startWithRef)) {
        ManagedList list = new ManagedList();
        list.setSource(ArrayList.class);
        list.setMergeEnabled(false);
        builder.addPropertyValue("modules", list);
        if (StringUtils.isNotBlank(startWithRef)) {
            //-startWithRef
            String[] refs = startWithRef.split(",");
            for (String refName : refs) {
                list.add(new RuntimeBeanReference(refName));
            }
        } else {
            //-startWith
            BeanDefinitionBuilder startWithBuilder = BeanDefinitionBuilder.genericBeanDefinition(startWith);
            AbstractBeanDefinition startWithDefine = startWithBuilder.getBeanDefinition();
            String beanName = new DefaultBeanNameGenerator().generateBeanName(startWithDefine, parserContext.getRegistry());
            list.add(new BeanDefinitionHolder(startWithDefine, beanName));
        }
    }
    String refPropertiesBean = revertProperty(attributes, "refProperties");
    builder.addPropertyValue("refProperties", refPropertiesBean);
    //
    String configFile = null;
    String factoryID = revertProperty(attributes, beanID());
    if (StringUtils.isBlank(factoryID)) {
        factoryID = AppContext.class.getName();
    }
    BeanDefinitionParser parser = new BeanDefinitionParser(factoryID);
    //
    Node node = element.getFirstChild();
    while (node != null) {
        if (node.getNodeType() == Node.ELEMENT_NODE) {
            Element entry = (Element) node;
            if (entry.getLocalName().equals("configFile")) {
                configFile = entry.getFirstChild().getNodeValue();
                if (StringUtils.isBlank(configFile)) {
                    configFile = node.getNodeValue();
                }
            } else if (entry.getLocalName().equals("bean")) {
                parser.parse((Element) node, parserContext);
            }
        }
        node = node.getNextSibling();
    }
    if (StringUtils.isNotBlank(configFile)) {
        builder.addPropertyValue("config", configFile);
    }
    //
    return builder.getBeanDefinition();
}

/**
     * Registers a BeanNameAutoProxyCreator class that wraps the bean being
     * monitored. The proxy is associated with the PerformanceMonitorInterceptor
     * for the bean, which is created when parsing the methods attribute from
     * the springconfiguration xml file.
     *
     * @param source An Attribute node from the spring configuration
     * @param holder A container for the beans I will create
     * @param context the context currently parsing my spring config
     */
private void registerProxyCreator(Node source, BeanDefinitionHolder holder, ParserContext context) {
    String beanName = holder.getBeanName();
    String proxyName = beanName + "Proxy";
    String interceptorName = beanName + "PerformanceMonitorInterceptor";
    BeanDefinitionBuilder initializer = BeanDefinitionBuilder.rootBeanDefinition(BeanNameAutoProxyCreator.class);
    initializer.addPropertyValue("beanNames", beanName);
    initializer.addPropertyValue("interceptorNames", interceptorName);
    BeanDefinitionRegistry registry = context.getRegistry();
    registry.registerBeanDefinition(proxyName, initializer.getBeanDefinition());
}

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder bean) {
    super.doParse(element, parserContext, bean);
    if (!parserContext.getRegistry().containsBeanDefinition(OLINGO_ODATA_EXCEPTION_HANDLER)) {
        AbstractBeanDefinition definition = BeanDefinitionBuilder.genericBeanDefinition(ODataExceptionMapperImpl.class).getBeanDefinition();
        definition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
        BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, OLINGO_ODATA_EXCEPTION_HANDLER, new String[0]);
        registerBeanDefinition(holder, parserContext.getRegistry());
    }
    if (!parserContext.getRegistry().containsBeanDefinition(OLINGO_ODATA_PROVIDER)) {
        AbstractBeanDefinition definition = BeanDefinitionBuilder.genericBeanDefinition(ODataApplication.MyProvider.class).getBeanDefinition();
        definition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
        BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, OLINGO_ODATA_PROVIDER, new String[0]);
        registerBeanDefinition(holder, parserContext.getRegistry());
    }
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(OlingoRootLocator.class);
    builder.setScope(BeanDefinition.SCOPE_PROTOTYPE);
    builder.addPropertyReference(SERVICE_FACTORY, element.getAttribute(FACTORY));
    if (element.hasAttribute(PATH_SPLIT)) {
        builder.addPropertyValue(PATH_SPLIT, element.getAttribute(PATH_SPLIT));
    }
    AbstractBeanDefinition definition = builder.getBeanDefinition();
    BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, OLINGO_ROOT_LOCATOR + "-" + element.getAttribute(ID) + "-" + element.getAttribute(FACTORY));
    registerBeanDefinition(holder, parserContext.getRegistry());
    ManagedList<BeanDefinition> services = new ManagedList<BeanDefinition>(3);
    services.add(definition);
    services.add(parserContext.getRegistry().getBeanDefinition(OLINGO_ODATA_EXCEPTION_HANDLER));
    services.add(parserContext.getRegistry().getBeanDefinition(OLINGO_ODATA_PROVIDER));
    bean.addPropertyValue(SERVICE_BEANS, services);
}

public static BeanComponentDefinition parseInnerBeanDefinition(Element element, ParserContext parserContext) {
    // parses out inner bean definition for concrete implementation if defined
    List<Element> childElements = DomUtils.getChildElementsByTagName(element, "bean");
    BeanComponentDefinition innerComponentDefinition = null;
    if (childElements != null && childElements.size() == 1) {
        Element beanElement = childElements.get(0);
        BeanDefinitionParserDelegate delegate = parserContext.getDelegate();
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(beanElement);
        bdHolder = delegate.decorateBeanDefinitionIfRequired(beanElement, bdHolder);
        BeanDefinition inDef = bdHolder.getBeanDefinition();
        String beanName = BeanDefinitionReaderUtils.generateBeanName(inDef, parserContext.getRegistry());
        innerComponentDefinition = new BeanComponentDefinition(inDef, beanName);
        parserContext.registerBeanComponent(innerComponentDefinition);
    }
    String ref = element.getAttribute(REF_ATTRIBUTE);
    //NOSONAR
    Assert.isTrue(//NOSONAR
    !StringUtils.hasText(ref) || innerComponentDefinition == null, "Ambiguous definition. Inner bean " + (innerComponentDefinition == null ? innerComponentDefinition : innerComponentDefinition.getBeanDefinition().getBeanClassName()) + " declaration and \"ref\" " + ref + " are not allowed together.");
    return innerComponentDefinition;
}

private void registerMissingDefaultableBeanDefinitions(BeanDefinitionRegistry registry, ListableBeanFactory factory) {
    // see if any template definitions exist, which requires a converter, which requires a mapping context
    BeanDefinitionHolder[] templateBeans = getBeanDefinitionsOfType(registry, factory, CassandraOperations.class, true, true);
    if (templateBeans.length >= 1) {
        return;
    }
    // need a session & converter for the default template
    // see if an actual Session definition exists
    String sessionBeanName = findSessionBeanName(registry, factory);
    // see if any converter bean definitions exist, which requires a mapping context
    BeanDefinitionHolder[] converterBeans = getBeanDefinitionsOfType(registry, factory, MappingCassandraConverter.class, true, false);
    if (converterBeans.length > 1) {
        throw createAmbiguousBeansException(converterBeans.length, CassandraConverter.class, CassandraTemplate.class);
    }
    if (converterBeans.length == 1) {
        registerDefaultTemplate(registry, sessionBeanName, converterBeans[0].getBeanName());
        return;
    }
    // see if any mapping context bean definitions exist
    BeanDefinitionHolder[] contextBeans = getBeanDefinitionsOfType(registry, factory, CassandraMappingContext.class, true, false);
    if (contextBeans.length > 1) {
        // then throw, because we need to create a default converter, but we wouldn't know which mapping context to use
        throw createAmbiguousBeansException(contextBeans.length, MappingCassandraConverter.class, CassandraMappingContext.class);
    }
    // create the mapping context if necessary
    BeanDefinitionHolder contextBean = contextBeans.length == 1 ? contextBeans[0] : registerDefaultContext(registry);
    // create the default converter & template bean definitions
    BeanDefinitionHolder converter = registerDefaultConverter(registry, contextBean.getBeanName());
    registerDefaultTemplate(registry, sessionBeanName, converter.getBeanName());
}

/**
     * The main parsing algorithm for the <code>remoting-destination</code> tag.
     * 
     * @param element the element being parsed
     * @param parserContext the current parser context
     * @param exportedBeanReference reference to the bean being exported as a remoting destination
     * @return a bean definition holder for the {@link RemotingDestinationExporter} bean
     */
protected BeanDefinitionHolder parseInternal(Element element, ParserContext parserContext, String exportedBeanReference) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(REMOTING_DESTINATION_EXPORTER_CLASS_NAME);
    builder.getRawBeanDefinition().setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    validateRemotingDestination(element, parserContext);
    String destinationId = element.getAttribute(DESTINATION_ID_ATTR);
    String brokerId = element.getAttribute(MESSAGE_BROKER_ATTR);
    builder.addPropertyValue(SERVICE_PROPERTY, exportedBeanReference);
    builder.addDependsOn(exportedBeanReference);
    destinationId = StringUtils.hasText(destinationId) ? destinationId : exportedBeanReference;
    builder.addPropertyValue(DESTINATION_ID_PROPERTY, destinationId);
    brokerId = StringUtils.hasText(brokerId) ? brokerId : BeanIds.MESSAGE_BROKER;
    builder.addPropertyReference(MESSAGE_BROKER_PROPERTY, brokerId);
    ParsingUtils.mapOptionalAttributes(element, parserContext, builder, CHANNELS_ATTR, INCLUDE_METHODS_ATTR, EXCLUDE_METHODS_ATTR, SERVICE_ADAPTER_ATTR);
    String beanName = ParsingUtils.registerInfrastructureComponent(element, parserContext, builder);
    return new BeanDefinitionHolder(builder.getBeanDefinition(), beanName);
}

/**
	 * Returns a string representation of the given value object.
	 */
public static String getValueName(Object value) {
    // Ignore bean name of inner beans
    if (value instanceof BeanDefinitionHolder) {
        value = ((BeanDefinitionHolder) value).getBeanDefinition();
    }
    StringBuffer name = new StringBuffer();
    if (value instanceof String) {
        name.append('"').append(value).append('"');
    } else if (value instanceof BeanDefinition) {
        name.append("bean ");
        if (value instanceof RootBeanDefinition) {
            name.append('[');
            name.append(((RootBeanDefinition) value).getBeanClassName());
            name.append(']');
        } else {
            name.append('<');
            name.append(((BeanDefinition) value).getParentName());
            name.append('>');
        }
    } else if (value instanceof RuntimeBeanReference) {
        name.append("reference ");
        String beanName = ((RuntimeBeanReference) value).getBeanName();
        name.append('<').append(beanName).append(">");
    } else if (value != null) {
        String valueName = null;
        if (value.getClass().isArray()) {
            valueName = "[" + StringUtils.arrayToDelimitedString((Object[]) value, ", ") + "]";
        } else {
            valueName = value.toString();
        }
        if (valueName.length() > 30) {
            name.append(valueName.substring(0, 12)).append(" .. ").append(valueName.substring(valueName.length() - 13));
        } else {
            name.append(valueName);
        }
    } else {
        name.append("<null>");
    }
    return name.toString();
}

/**
     * Calls the parent search that will search and register all the candidates.
     * Then the registered objects are post processed to set them as
     * MapperFactoryBeans
     */
@Override
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    val beanDefinitions = super.doScan(basePackages);
    if (beanDefinitions.isEmpty()) {
        log.warn("No SpringRestClientEnabled was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
    } else {
        for (BeanDefinitionHolder holder : beanDefinitions) {
            val definition = (GenericBeanDefinition) holder.getBeanDefinition();
            if (log.isDebugEnabled()) {
                log.debug("Creating SpringRestClientFactoryBean with name '" + holder.getBeanName() + "' and '" + definition.getBeanClassName() + "' interfaceClazz");
            }
            // the mapper interface is the original class of the bean
            // but, the actual class of the bean is MapperFactoryBean
            definition.getPropertyValues().add("interfaceClazz", definition.getBeanClassName());
            definition.setBeanClass(SpringRestClientFactoryBean.class);
        }
    }
    return beanDefinitions;
}

public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext pc) {
    String name = pc.getDelegate().getLocalName(node);
    // We only handle elements
    if (node instanceof Element) {
        if (Elements.INTERCEPT_METHODS.equals(name)) {
            return interceptMethodsBDD.decorate(node, definition, pc);
        }
        if (Elements.FILTER_CHAIN_MAP.equals(name)) {
            if (filterChainMapBDD == null) {
                loadParsers();
            }
            if (filterChainMapBDD == null) {
                reportMissingWebClasses(name, pc, node);
            }
            return filterChainMapBDD.decorate(node, definition, pc);
        }
    }
    reportUnsupportedNodeType(name, pc, node);
    return null;
}

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    String accessTokenProviderRef = element.getAttribute("access-token-provider");
    builder.addConstructorArgReference(element.getAttribute("resource"));
    BeanDefinitionBuilder request = BeanDefinitionBuilder.genericBeanDefinition(DefaultAccessTokenRequest.class);
    request.setScope("request");
    request.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    request.addConstructorArgValue("#{request.parameterMap}");
    request.addPropertyValue("currentUri", "#{request.getAttribute('currentUri')}");
    BeanDefinitionHolder requestDefinition = new BeanDefinitionHolder(request.getRawBeanDefinition(), parserContext.getReaderContext().generateBeanName(request.getRawBeanDefinition()));
    parserContext.getRegistry().registerBeanDefinition(requestDefinition.getBeanName(), requestDefinition.getBeanDefinition());
    BeanDefinitionHolder requestHolder = ScopedProxyUtils.createScopedProxy(requestDefinition, parserContext.getRegistry(), false);
    BeanDefinitionBuilder scopedContext = BeanDefinitionBuilder.genericBeanDefinition(DefaultOAuth2ClientContext.class);
    scopedContext.setScope("session");
    scopedContext.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    BeanDefinitionHolder contextDefinition = new BeanDefinitionHolder(scopedContext.getRawBeanDefinition(), parserContext.getReaderContext().generateBeanName(scopedContext.getRawBeanDefinition()));
    parserContext.getRegistry().registerBeanDefinition(contextDefinition.getBeanName(), contextDefinition.getBeanDefinition());
    BeanDefinitionHolder contextHolder = ScopedProxyUtils.createScopedProxy(contextDefinition, parserContext.getRegistry(), false);
    scopedContext.addConstructorArgValue(requestHolder.getBeanDefinition());
    BeanDefinitionBuilder bareContext = BeanDefinitionBuilder.genericBeanDefinition(DefaultOAuth2ClientContext.class);
    BeanDefinitionBuilder context = BeanDefinitionBuilder.genericBeanDefinition(OAuth2ClientContextFactoryBean.class);
    context.addPropertyValue("scopedContext", contextHolder.getBeanDefinition());
    context.addPropertyValue("bareContext", bareContext.getBeanDefinition());
    context.addPropertyReference("resource", element.getAttribute("resource"));
    builder.addConstructorArgValue(context.getBeanDefinition());
    if (StringUtils.hasText(accessTokenProviderRef)) {
        builder.addPropertyReference("accessTokenProvider", accessTokenProviderRef);
    }
    parserContext.getDelegate().parsePropertyElements(element, builder.getBeanDefinition());
}

/**
	 * Calls the parent search that will search and register all the candidates.
	 * Then the registered objects are post processed to set them as
	 * MapperFactoryBeans
	 */
@Override
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
    if (beanDefinitions.isEmpty()) {
        logger.warn("No DaoService was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
    } else {
        for (BeanDefinitionHolder holder : beanDefinitions) {
            GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();
            if (logger.isDebugEnabled()) {
                logger.debug("Creating DaoFactoryBean with name '" + holder.getBeanName() + "' and '" + definition.getBeanClassName() + "' daoInterface");
            }
            // the mapper interface is the original class of the bean
            // but, the actual class of the bean is HibernateDaoFactoryBean
            definition.getPropertyValues().add("daoInterface", definition.getBeanClassName());
            definition.getPropertyValues().add("funcs", functions);
            definition.getPropertyValues().add("entityManager", entityManager);
            definition.getPropertyValues().add("sessionFactory", sessionFactory);
            definition.setBeanClass(DaoFactoryBean.class);
            definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
        }
    }
    return beanDefinitions;
}

/**
       * @see org.springframework.beans.factory.xml.BeanDefinitionDecorator#decorate(org.w3c.dom.Node,
       *      org.springframework.beans.factory.config.BeanDefinitionHolder,
       *      org.springframework.beans.factory.xml.ParserContext)
       */
public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) {
    // doesn't already exist
    if (!parserContext.getRegistry().containsBeanDefinition(SEAM_COMPONENT_POST_PROCESSOR_BEAN_NAME)) {
        Class cls;
        try {
            cls = ClassUtils.forName(SEAM_COMPONENT_POST_PROCESSOR);
        } catch (ClassNotFoundException e) {
            throw new IllegalStateException("Unable to load class '" + SEAM_COMPONENT_POST_PROCESSOR + "' make sure you have the jboss-seam-spring.jar in your classpath.", e);
        }
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        beanDefinition.getPropertyValues().addPropertyValue("order", Ordered.LOWEST_PRECEDENCE);
        parserContext.getRegistry().registerBeanDefinition(SEAM_COMPONENT_POST_PROCESSOR_BEAN_NAME, beanDefinition);
    }
    // get the optional beanClass
    String beanClassName = definition.getBeanDefinition().getBeanClassName();
    if (node.getAttributes().getNamedItem(BEAN_CLASS_ATTR) != null) {
        beanClassName = node.getAttributes().getNamedItem(BEAN_CLASS_ATTR).getNodeValue();
    }
    String beanName = definition.getBeanName();
    // get the name of the seam component to create
    String seamName = beanName;
    if (node.getAttributes().getNamedItem(SEAM_NAME_ATTR) != null) {
        seamName = node.getAttributes().getNamedItem(SEAM_NAME_ATTR).getNodeValue();
    }
    // get the name of the spring bean to use
    String springName = beanName;
    if (node.getAttributes().getNamedItem(SPRING_NAME_ATTR) != null) {
        springName = node.getAttributes().getNamedItem(SPRING_NAME_ATTR).getNodeValue();
    }
    // get the interception type to use
    Boolean interceptionType = null;
    if (node.getAttributes().getNamedItem(INTERCEPT_TYPE_ATTR) != null) {
        interceptionType = Boolean.valueOf(node.getAttributes().getNamedItem(INTERCEPT_TYPE_ATTR).getNodeValue());
    }
    // get the requested scope
    ScopeType scope = ScopeType.valueOf(node.getAttributes().getNamedItem("scope").getNodeValue());
    if (scope != ScopeType.STATELESS && !BeanDefinition.SCOPE_PROTOTYPE.equals(definition.getBeanDefinition().getScope())) {
        throw new IllegalStateException("The spring bean scope must be prototype to use a seam scope other than STATELESS.");
    }
    if (!(parserContext.getRegistry() instanceof BeanFactory)) {
        throw new RuntimeException("For some reason your registry is not a BeanFactory");
    }
    SpringComponent.addSpringComponent(seamName, springName, beanClassName, scope, (BeanFactory) parserContext.getRegistry(), interceptionType);
    if (node.getAttributes().getNamedItem(AUTO_CREATE_ATTR) != null) {
        if (Boolean.valueOf(node.getAttributes().getNamedItem(AUTO_CREATE_ATTR).getNodeValue())) {
            Init.instance().addAutocreateVariable(seamName);
        }
    }
    return definition;
}

/**
       * @see org.springframework.beans.factory.xml.BeanDefinitionDecorator#decorate(org.w3c.dom.Node,
       *      org.springframework.beans.factory.config.BeanDefinitionHolder,
       *      org.springframework.beans.factory.xml.ParserContext)
       */
public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) {
    // doesn't already exist
    if (!parserContext.getRegistry().containsBeanDefinition(SEAM_COMPONENT_POST_PROCESSOR_BEAN_NAME)) {
        Class cls;
        try {
            cls = ClassUtils.forName(SEAM_COMPONENT_POST_PROCESSOR);
        } catch (ClassNotFoundException e) {
            throw new IllegalStateException("Unable to load class '" + SEAM_COMPONENT_POST_PROCESSOR + "' make sure you have the jboss-seam-spring.jar in your classpath.", e);
        }
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        beanDefinition.getPropertyValues().addPropertyValue("order", Ordered.LOWEST_PRECEDENCE);
        parserContext.getRegistry().registerBeanDefinition(SEAM_COMPONENT_POST_PROCESSOR_BEAN_NAME, beanDefinition);
    }
    // get the optional beanClass
    String beanClassName = definition.getBeanDefinition().getBeanClassName();
    if (node.getAttributes().getNamedItem(BEAN_CLASS_ATTR) != null) {
        beanClassName = node.getAttributes().getNamedItem(BEAN_CLASS_ATTR).getNodeValue();
    }
    String beanName = definition.getBeanName();
    // get the name of the seam component to create
    String seamName = beanName;
    if (node.getAttributes().getNamedItem(SEAM_NAME_ATTR) != null) {
        seamName = node.getAttributes().getNamedItem(SEAM_NAME_ATTR).getNodeValue();
    }
    // get the name of the spring bean to use
    String springName = beanName;
    if (node.getAttributes().getNamedItem(SPRING_NAME_ATTR) != null) {
        springName = node.getAttributes().getNamedItem(SPRING_NAME_ATTR).getNodeValue();
    }
    // get the interception type to use
    Boolean interceptionType = null;
    if (node.getAttributes().getNamedItem(INTERCEPT_TYPE_ATTR) != null) {
        interceptionType = Boolean.valueOf(node.getAttributes().getNamedItem(INTERCEPT_TYPE_ATTR).getNodeValue());
    }
    // get the requested scope
    ScopeType scope = ScopeType.valueOf(node.getAttributes().getNamedItem("scope").getNodeValue());
    if (scope != ScopeType.STATELESS && !BeanDefinition.SCOPE_PROTOTYPE.equals(definition.getBeanDefinition().getScope())) {
        throw new IllegalStateException("The spring bean scope must be prototype to use a seam scope other than STATELESS.");
    }
    if (!(parserContext.getRegistry() instanceof BeanFactory)) {
        throw new RuntimeException("For some reason your registry is not a BeanFactory");
    }
    SpringComponent.addSpringComponent(seamName, springName, beanClassName, scope, (BeanFactory) parserContext.getRegistry(), interceptionType);
    if (node.getAttributes().getNamedItem(AUTO_CREATE_ATTR) != null) {
        if (Boolean.valueOf(node.getAttributes().getNamedItem(AUTO_CREATE_ATTR).getNodeValue())) {
            Init.instance().addAutocreateVariable(seamName);
        }
    }
    return definition;
}

/**
       * @see org.springframework.beans.factory.xml.BeanDefinitionDecorator#decorate(org.w3c.dom.Node,
       *      org.springframework.beans.factory.config.BeanDefinitionHolder,
       *      org.springframework.beans.factory.xml.ParserContext)
       */
public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) {
    // doesn't already exist
    if (!parserContext.getRegistry().containsBeanDefinition(SEAM_COMPONENT_POST_PROCESSOR_BEAN_NAME)) {
        Class cls;
        try {
            cls = ClassUtils.forName(SEAM_COMPONENT_POST_PROCESSOR);
        } catch (ClassNotFoundException e) {
            throw new IllegalStateException("Unable to load class '" + SEAM_COMPONENT_POST_PROCESSOR + "' make sure you have the jboss-seam-spring.jar in your classpath.", e);
        }
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        beanDefinition.getPropertyValues().addPropertyValue("order", Ordered.LOWEST_PRECEDENCE);
        parserContext.getRegistry().registerBeanDefinition(SEAM_COMPONENT_POST_PROCESSOR_BEAN_NAME, beanDefinition);
    }
    // get the optional beanClass
    String beanClassName = definition.getBeanDefinition().getBeanClassName();
    if (node.getAttributes().getNamedItem(BEAN_CLASS_ATTR) != null) {
        beanClassName = node.getAttributes().getNamedItem(BEAN_CLASS_ATTR).getNodeValue();
    }
    String beanName = definition.getBeanName();
    // get the name of the seam component to create
    String seamName = beanName;
    if (node.getAttributes().getNamedItem(SEAM_NAME_ATTR) != null) {
        seamName = node.getAttributes().getNamedItem(SEAM_NAME_ATTR).getNodeValue();
    }
    // get the name of the spring bean to use
    String springName = beanName;
    if (node.getAttributes().getNamedItem(SPRING_NAME_ATTR) != null) {
        springName = node.getAttributes().getNamedItem(SPRING_NAME_ATTR).getNodeValue();
    }
    // get the interception type to use
    Boolean interceptionType = null;
    if (node.getAttributes().getNamedItem(INTERCEPT_TYPE_ATTR) != null) {
        interceptionType = Boolean.valueOf(node.getAttributes().getNamedItem(INTERCEPT_TYPE_ATTR).getNodeValue());
    }
    // get the requested scope
    ScopeType scope = ScopeType.valueOf(node.getAttributes().getNamedItem("scope").getNodeValue());
    if (scope != ScopeType.STATELESS && !BeanDefinition.SCOPE_PROTOTYPE.equals(definition.getBeanDefinition().getScope())) {
        throw new IllegalStateException("The spring bean scope must be prototype to use a seam scope other than STATELESS.");
    }
    if (!(parserContext.getRegistry() instanceof BeanFactory)) {
        throw new RuntimeException("For some reason your registry is not a BeanFactory");
    }
    SpringComponent.addSpringComponent(seamName, springName, beanClassName, scope, (BeanFactory) parserContext.getRegistry(), interceptionType);
    if (node.getAttributes().getNamedItem(AUTO_CREATE_ATTR) != null) {
        if (Boolean.valueOf(node.getAttributes().getNamedItem(AUTO_CREATE_ATTR).getNodeValue())) {
            Init.instance().addAutocreateVariable(seamName);
        }
    }
    return definition;
}

/**
       * @see org.springframework.beans.factory.xml.BeanDefinitionDecorator#decorate(org.w3c.dom.Node,
       *      org.springframework.beans.factory.config.BeanDefinitionHolder,
       *      org.springframework.beans.factory.xml.ParserContext)
       */
public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) {
    // doesn't already exist
    if (!parserContext.getRegistry().containsBeanDefinition(SEAM_COMPONENT_POST_PROCESSOR_BEAN_NAME)) {
        Class cls;
        try {
            cls = ClassUtils.forName(SEAM_COMPONENT_POST_PROCESSOR);
        } catch (ClassNotFoundException e) {
            throw new IllegalStateException("Unable to load class '" + SEAM_COMPONENT_POST_PROCESSOR + "' make sure you have the jboss-seam-spring.jar in your classpath.", e);
        }
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        beanDefinition.getPropertyValues().addPropertyValue("order", Ordered.LOWEST_PRECEDENCE);
        parserContext.getRegistry().registerBeanDefinition(SEAM_COMPONENT_POST_PROCESSOR_BEAN_NAME, beanDefinition);
    }
    // get the optional beanClass
    String beanClassName = definition.getBeanDefinition().getBeanClassName();
    if (node.getAttributes().getNamedItem(BEAN_CLASS_ATTR) != null) {
        beanClassName = node.getAttributes().getNamedItem(BEAN_CLASS_ATTR).getNodeValue();
    }
    String beanName = definition.getBeanName();
    // get the name of the seam component to create
    String seamName = beanName;
    if (node.getAttributes().getNamedItem(SEAM_NAME_ATTR) != null) {
        seamName = node.getAttributes().getNamedItem(SEAM_NAME_ATTR).getNodeValue();
    }
    // get the name of the spring bean to use
    String springName = beanName;
    if (node.getAttributes().getNamedItem(SPRING_NAME_ATTR) != null) {
        springName = node.getAttributes().getNamedItem(SPRING_NAME_ATTR).getNodeValue();
    }
    // get the interception type to use
    Boolean interceptionType = null;
    if (node.getAttributes().getNamedItem(INTERCEPT_TYPE_ATTR) != null) {
        interceptionType = Boolean.valueOf(node.getAttributes().getNamedItem(INTERCEPT_TYPE_ATTR).getNodeValue());
    }
    // get the requested scope
    ScopeType scope = ScopeType.valueOf(node.getAttributes().getNamedItem("scope").getNodeValue());
    if (scope != ScopeType.STATELESS && !BeanDefinition.SCOPE_PROTOTYPE.equals(definition.getBeanDefinition().getScope())) {
        throw new IllegalStateException("The spring bean scope must be prototype to use a seam scope other than STATELESS.");
    }
    if (!(parserContext.getRegistry() instanceof BeanFactory)) {
        throw new RuntimeException("For some reason your registry is not a BeanFactory");
    }
    SpringComponent.addSpringComponent(seamName, springName, beanClassName, scope, (BeanFactory) parserContext.getRegistry(), interceptionType);
    if (node.getAttributes().getNamedItem(AUTO_CREATE_ATTR) != null) {
        if (Boolean.valueOf(node.getAttributes().getNamedItem(AUTO_CREATE_ATTR).getNodeValue())) {
            Init.instance().addAutocreateVariable(seamName);
        }
    }
    return definition;
}

public ElementConfiguration parseProperty(Object value) {
    LOGGER.debug("value : " + value);
    if (value instanceof TypedStringValue) {
        TypedStringValue stringValue = (TypedStringValue) value;
        if (stringValue.getTargetTypeName() != null) {
            return getEnumObjectConfiguration(stringValue);
        } else {
            PrimitiveConfiguration primitiveConfiguration = objectConfigurationFactory.createPrimitiveConfiguration();
            if (useSPEL(stringValue)) {
                ExpressionParser parser = new SpelExpressionParser();
                String expAsStringWithToken = stringValue.getValue().trim();
                String expAsString = expAsStringWithToken.substring(2, expAsStringWithToken.length() - 1).trim();
                LOGGER.trace("This property is a SPEL expression: " + expAsString);
                // String regex = "systemProperties\\['([^\\s]+)'\\]";
                Expression exp = parser.parseExpression(expAsString);
                StandardEvaluationContext sec = null;
                if (sec == null) {
                    sec = new StandardEvaluationContext();
                    sec.addPropertyAccessor(new EnvironmentAccessor());
                    sec.addPropertyAccessor(new BeanExpressionContextAccessor());
                    sec.addPropertyAccessor(new BeanFactoryAccessor());
                    sec.addPropertyAccessor(new MapAccessor());
                }
                primitiveConfiguration.setValue(String.valueOf(exp.getValue()));
            } else {
                LOGGER.trace("This property is NOT a SPEL expression: " + stringValue.getValue());
                primitiveConfiguration.setValue(stringValue.getValue());
            }
            return primitiveConfiguration;
        }
    } else if (value instanceof RuntimeBeanReference) {
        RuntimeBeanReference beanReference = (RuntimeBeanReference) value;
        ReferenceConfiguration referenceConfiguration = objectConfigurationFactory.createReferenceConfiguration();
        referenceConfiguration.setReferenceName(beanReference.getBeanName());
        return referenceConfiguration;
    } else if (value instanceof ManagedList<?>) {
        return parseValueList((ManagedList<?>) value);
    } else if (value instanceof ManagedMap<?, ?>) {
        return parseValueMap((ManagedMap<?, ?>) value);
    } else if (value instanceof BeanDefinitionHolder) {
        BeanDefinitionHolder beanDefinitionHolder = (BeanDefinitionHolder) value;
        return parseBeanDefinition(beanDefinitionHolder.getBeanDefinition());
    } else {
        throw new UnsupportedOperationException("The type of property value is not suppported : " + value + " (class : " + value.getClass().getName() + ")");
    }
}

/**
     * 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
     * @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);
    Map<String, List<String>> auth = new HashMap<String, List<String>>();
    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())) {
            String method = child.getAttribute("method");
            if (auth.get(method) == null) {
                auth.put(method, new ArrayList<String>());
            }
            auth.get(method).add(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));
}

public BeanDefinitionHolder decorate(final Node node, final BeanDefinitionHolder definition, final ParserContext parserContext) {
    final BeanDefinition beanDefinition = definition.getBeanDefinition();
    final String dtoSupportProperty = node.getAttributes().getNamedItem(XSD_ATTR__PROPERTY).getNodeValue();
    final MutablePropertyValues properties = beanDefinition.getPropertyValues();
    properties.add(dtoSupportProperty, new RuntimeBeanReference(dtoSupportBeanName));
    return definition;
}

protected BeanDefinitionBuilder createBeanBuilder(final Class clazz, final String id) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(clazz);
    final AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
    BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, nextId(id));
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, parserContext.getRegistry());
    return builder;
}

@Test
public void existingBeanDefinitionHolder() {
    BeanDefinitionHolder bdh = new BeanDefinitionHolder(this.beanDefinition, "");
    this.propertyValues.addPropertyValue(this.key, bdh);
    Map<String, String> m = new HashMap<String, String>();
    m.put("additional-key", "additional-value");
    this.propertyValues.addPropertyValue("sourceMap", m);
    this.propertyAugmenter.augment(this.beanFactory, this.beanClass, this.key, this.additionalProperties);
    assertTrue(this.propertyValues.contains(this.key));
    assertContainsKey("additional-key");
}

/**
   * Determine whether the specified bean definition qualifies as an autowire candidate, to be injected into other beans which
   * declare a dependency of matching type.
   * 
   * @param beanName the name of the bean definition to check
   * @param mbd the merged bean definition to check
   * @param descriptor the descriptor of the dependency to resolve
   * @param resolver the AutowireCandidateResolver to use for the actual resolution algorithm
   * @return whether the bean should be considered as autowire candidate
   */
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd, DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {
    String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
    resolveBeanClass(mbd, beanDefinitionName);
    if (mbd.isFactoryMethodUnique) {
        boolean resolve;
        synchronized (mbd.constructorArgumentLock) {
            resolve = (mbd.resolvedConstructorOrFactoryMethod == null);
        }
        if (resolve) {
            new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
        }
    }
    return resolver.isAutowireCandidate(new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);
}

/**
	 * Handle the <reader/>, <processor/>, or <writer/> that
	 * is defined within the item handler.
	 */
private void handleItemHandlerElement(AbstractBeanDefinition enclosing, String propertyName, String adapterClassName, MutablePropertyValues propertyValues, Element element, ParserContext parserContext) {
    List<Element> beanElements = DomUtils.getChildElementsByTagName(element, BEAN_ELE);
    List<Element> refElements = DomUtils.getChildElementsByTagName(element, REF_ELE);
    if (beanElements.size() + refElements.size() != 1) {
        parserContext.getReaderContext().error("The <" + element.getNodeName() + "/> must have exactly one of either a <" + BEAN_ELE + "/> element or a <" + REF_ELE + "/> element.", element);
    } else if (beanElements.size() == 1) {
        Element beanElement = beanElements.get(0);
        BeanDefinitionHolder beanDefinitionHolder = parserContext.getDelegate().parseBeanDefinitionElement(beanElement, enclosing);
        parserContext.getDelegate().decorateBeanDefinitionIfRequired(beanElement, beanDefinitionHolder);
        propertyValues.addPropertyValue(propertyName, beanDefinitionHolder);
    } else if (refElements.size() == 1) {
        propertyValues.addPropertyValue(propertyName, parserContext.getDelegate().parsePropertySubElement(refElements.get(0), null));
    }
    handleAdapterMethodAttribute(propertyName, adapterClassName, propertyValues, element);
}

private void registerOn(Class<?> type, boolean customComponent) {
    AnnotatedGenericBeanDefinition definition = new AnnotatedGenericBeanDefinition(type);
    if (!customComponent) {
        definition.setLazyInit(true);
    }
    definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_NO);
    definition.setPrimary(customComponent);
    definition.setRole(customComponent ? BeanDefinition.ROLE_APPLICATION : BeanDefinition.ROLE_INFRASTRUCTURE);
    String name = beanNameGenerator.generateBeanName(definition, (BeanDefinitionRegistry) beanFactory);
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(definition, name);
    ScopeMetadata scopeMetadata = scopeResolver.resolveScopeMetadata(definition);
    definitionHolder = applyScopeOn(definitionHolder, scopeMetadata);
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, (BeanDefinitionRegistry) beanFactory);
}

@Override
public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder holder, ParserContext ctx) {
    if (!ctx.getRegistry().containsBeanDefinition(PluginRegistry.PLUGIN_REGISTRY_BEAN_NAME)) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(PluginRegistryImpl.class);
        ctx.getRegistry().registerBeanDefinition(PluginRegistry.PLUGIN_REGISTRY_BEAN_NAME, builder.getBeanDefinition());
        logger.debug("No BeanDefinition for PluginRegistry found, create and register one");
    }
    Element root = (Element) node;
    List<Element> all = new ArrayList<Element>(6);
    all.add(root);
    List<Element> children = DomUtils.getChildElementsByTagName(root, new String[] { EXTENSION_NODE });
    all.addAll(children);
    List<PluginExtension> exts = parsePlugin(all, holder.getBeanDefinition(), holder.getBeanName());
    if (!exts.isEmpty()) {
        PluginExtension ext = exts.get(0);
        BeanDefinition registryBean = ctx.getRegistry().getBeanDefinition(PluginRegistry.PLUGIN_REGISTRY_BEAN_NAME);
        MutablePropertyValues props = registryBean.getPropertyValues();
        PropertyValue prop = props.getPropertyValue(PluginRegistry.PLUGIN_REGISTRYIMPL_PLUGINS_FIELD_NAME);
        if (prop == null) {
            Map<String, List<PluginExtension>> extensions = new HashMap<String, List<PluginExtension>>(1);
            extensions.put(ext.getBeanClassName(), exts);
            prop = new PropertyValue(PluginRegistry.PLUGIN_REGISTRYIMPL_PLUGINS_FIELD_NAME, extensions);
            logger.debug("No 'extensions' property found in PluginRegistry bean definition, create a new one");
            props.addPropertyValue(prop);
        } else {
            Map<String, List<PluginExtension>> extensions = (Map<String, List<PluginExtension>>) prop.getValue();
            List<PluginExtension> oexts = extensions.get(ext.getBeanClassName());
            if (oexts == null) {
                oexts = new ArrayList<PluginExtension>(exts.size());
                extensions.put(ext.getBeanClassName(), oexts);
            }
            for (PluginExtension e : exts) {
                if (oexts.contains(e)) {
                    throw new CloudRuntimeException(String.format("duplicated extension declaration[interfaceRef:%s, beanName:%s, beanClass:%s]", e.getReferenceInterface(), ext.getBeanName(), ext.getBeanClassName()));
                }
            }
            oexts.addAll(exts);
        }
        logger.debug(String.format("Add extensions declared by bean[name=%s, class=%s] to 'extensions' property of PluginRegistry bean definition", ext.getBeanName(), ext.getBeanClassName()));
    }
    return holder;
}

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    for (Method method : REFLECTIONS.getMethodsAnnotatedWith(Factory.class)) {
        String methodName = method.getName();
        Class sourceType = getSourceType(method);
        Class targetType = method.getReturnType();
        Class beanType = method.getDeclaringClass();
        BeanDefinitionHolder holder = createConverterBean(beanType, methodName, sourceType, targetType);
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }
    for (Field field : REFLECTIONS.getFieldsAnnotatedWith(ServiceName.class)) {
        Class targetClass = field.getType();
        Alias alias = field.getAnnotation(Alias.class);
        ServiceName name = field.getAnnotation(ServiceName.class);
        PortName port = field.getAnnotation(PortName.class);
        Protocol protocol = field.getAnnotation(Protocol.class);
        External external = field.getAnnotation(External.class);
        String serviceName = name != null ? name.value() : null;
        //We copy the service since we are going to add properties to it.
        Service serviceInstance = new ServiceBuilder(getService(serviceName)).build();
        String servicePort = port != null ? port.value() : null;
        String serviceProtocol = protocol != null ? protocol.value() : DEFAULT_PROTOCOL;
        Boolean serviceExternal = external != null && external.value();
        String serviceAlias = alias != null ? alias.value() : createAlias(serviceName, targetClass, serviceProtocol, servicePort, serviceExternal);
        //Add annotation info as additional properties
        serviceInstance.getAdditionalProperties().put(ALIAS, serviceAlias);
        serviceInstance.getAdditionalProperties().put(PROTOCOL, serviceProtocol);
        serviceInstance.getAdditionalProperties().put(EXTERNAL, serviceExternal);
        //We don't want to add a fallback value to the attributes.
        if (port != null) {
            serviceInstance.getAdditionalProperties().put(PORT, servicePort);
        }
        BeanDefinitionHolder holder = createServiceDefinition(serviceInstance, serviceAlias, serviceProtocol, servicePort, targetClass);
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }
}

//    @Override
//    public Step createInstance() throws Exception {
//
//        final Predicate<Quad> predicate = filter == null ? null : new PredicateQuadExpr(filter);
//
//        ItemReaderQuad reader = new ItemReaderQuad(source, query);
//        reader.setPageSize(readSize);
//
//        ItemProcessor<? super Quad, ? extends Quad> processor;
//        if(predicate != null) {
//            ValidatingItemProcessor<Quad> validatingProcessor = new ValidatingItemProcessor<Quad>();
//            validatingProcessor.setValidator(new Validator<Quad>() {
//                @Override
//                public void validate(Quad quad) throws ValidationException {
//                    boolean isValid = predicate.apply(quad);
//                    if(!isValid) {
//                        throw new ValidationException("A quad failed validation: " + quad);
//                    }
//                }
//            });
//            validatingProcessor.setFilter(true);
//            validatingProcessor.afterPropertiesSet();
//
//            processor = validatingProcessor;
//        } else {
//            processor = new PassThroughItemProcessor<Quad>();
//        }
//
//        //ItemProcessor<? super Quad, ? extends Quad> processor = new PassThroughItemProcessor<Quad>();
//        ItemWriterQuad writer = new ItemWriterQuad(target, isDelete);
//
//        reader.setPageSize(chunkSize);
//
//        //StepBuilderFactory stepBuilders = batchConfig.stepBuilders();
//        StepBuilder stepBuilder = stepBuilders.get(name);
//
//        AbstractTaskletStepBuilder<?> base = stepBuilder
//                .<Quad, Quad>chunk(chunkSize)
//                .reader(reader)
//                .processor(processor)
//                .writer(writer);
//
//        if(taskExecutor != null) {
//            base = base.taskExecutor(taskExecutor);
//
//            if(throttle != null) {
//                base = base.throttleLimit(throttle);
//            }
//        }
//
//        Step result = base.build();
//
//
////                .taskExecutor(taskExecutor)
////                .throttleLimit(throttleLimit)
////                .build();
//
//        return result;
//    }
//    @Override
//    public Class<?> getObjectType() {
//        return Step.class;
//    }
//    @StepScope
//    @Autowired
@Override
protected Step configureStep(StepBuilder stepBuilder) {
    DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) ((ConfigurableApplicationContext) ctx).getBeanFactory();
    RootBeanDefinition itemReaderBd = new RootBeanDefinition(ItemReaderQuad.class);
    itemReaderBd.setScope("step");
    itemReaderBd.getPropertyValues().add("currentItemCount", "#{ stepExecutionContext[minValue] }").add("maxItemCount", "#{ stepExecutionContext[maxValue] }").add("pageSize", readSize).add("qef", source).add("query", query);
    String itemReaderName = BeanDefinitionReaderUtils.registerWithGeneratedName(itemReaderBd, beanFactory);
    BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(new BeanDefinitionHolder(itemReaderBd, itemReaderName), beanFactory, true);
    BeanDefinitionReaderUtils.registerBeanDefinition(proxyHolder, beanFactory);
    String proxyName = proxyHolder.getBeanName();
    @SuppressWarnings("unchecked") ItemReader<Quad> reader = (ItemReader<Quad>) beanFactory.getBean(proxyName);
    //BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(
    //        ItemReaderQuad tmp = new ItemReaderQuad(source, query);
    //        tmp.setQef(source);
    //        tmp.setQuery(query);
    //        tmp.setPageSize(readSize);
    //
    //        BeanDefinitionProxyUtils.createScopedProxy(beanFactory, bean, scopeName, propertyToSpel)
    //        BeanDefinitionBuilder.genericBeanDefinition().addPropertyValue(name, value)
    //        tmp.setCurrentItemCount(count);
    //        tmp.getExecutionContextKey(key)
    //        String proxyName = itemReaderName + "-proxy";
    //        RootBeanDefinition proxyBd = new RootBeanDefinition(ScopedProxyFactoryBean.class);
    //        proxyBd.getPropertyValues()
    //            .add("targetBeanName", itemReaderName);
    //        beanFactory.registerBeanDefinition(proxyName, proxyBd);
    //        SimpleStepFactoryBean x;
    //        RootBeanDefinition stepBd = new RootBeanDefinition(SimpleStepFactoryBean.class);
    //        stepBd.getPropertyValues()
    //            .add("commitInterval", chunkSize)
    //            .add("itemReader", )
    //            .add("itemProcessor", processor)
    //            .add("writer", writer)
    //            ;
    //SimpleStepFactoryBean<T, S>
    //        ScopedProxyUtils.createScopedProxy(definition, registry, proxyTargetClass)
    //        beanFactory.registerBeanDefinition(name + "itemReader", itemReaderBd);
    //Object bean = beanFactory.getBean("mytest");
    //Object bean = context.getBean("mytest");
    final Predicate<Quad> predicate = filter == null ? null : new PredicateQuadExpr(filter);
    //ItemReaderQuad reader = new ItemReaderQuad(source, query);
    //reader.setPageSize(readSize);
    ItemProcessor<? super Quad, ? extends Quad> processor;
    if (predicate != null) {
        ValidatingItemProcessor<Quad> validatingProcessor = new ValidatingItemProcessor<Quad>();
        validatingProcessor.setValidator(new ValidatorQuadByPredicate(predicate));
        validatingProcessor.setFilter(true);
        try {
            validatingProcessor.afterPropertiesSet();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        processor = validatingProcessor;
    } else {
        processor = new PassThroughItemProcessor<Quad>();
    }
    //ItemProcessor<? super Quad, ? extends Quad> processor = new PassThroughItemProcessor<Quad>();
    ItemWriterQuad writer = new ItemWriterQuad(target, isDelete);
    //reader.setPageSize(chunkSize);
    //SimplePartitioner x
    Step result = stepBuilder.<Quad, Quad>chunk(chunkSize).reader(reader).processor(processor).writer(writer).build();
    if (throttle != null) {
        Step slaveStep = result;
        Partitioner partitioner = new PartitionerSparqlSlice(source, query);
        result = stepBuilder.partitioner(slaveStep).partitioner(name, partitioner).taskExecutor(taskExecutor).gridSize(throttle).build();
    //.partitioner(name + "-partitioner", partitioner).
    }
    return result;
}

/**
		 * Calls the parent search that will search and register all the candidates. Then the
		 * registered objects are post processed to set them as ShardStrategy.
		 */
@Override
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
    //			} else {
    if (init == false) {
        init();
    }
    // .getBean(ShardReduceStrategyContext.class);
    for (BeanDefinitionHolder holder : beanDefinitions) {
        GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();
        if (logger.isDebugEnabled()) {
            logger.debug("Creating Strategy with name '" + holder.getBeanName() + "' and '" + definition.getBeanClassName() + "'.");
        }
    // ShardReduceStrategy reduceStrategy = (ShardReduceStrategy) applicationContext
    // .getBean(holder.getBeanName());
    // ShardedReducer reducer = reduceStrategy.getClass().getAnnotation(
    // ShardedReducer.class);
    //
    // reduceStrategyContext.put(reducer.mapper(), reducer.statements(),
    // reduceStrategy);
    }
    return beanDefinitions;
}

/**
   * Calls the parent search that will search and register all the candidates.
   * Then the registered objects are post processed to set them as
   * MapperFactoryBeans
   */
@Override
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
    if (beanDefinitions.isEmpty()) {
        logger.warn("No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
    } else {
        for (BeanDefinitionHolder holder : beanDefinitions) {
            GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();
            if (logger.isDebugEnabled()) {
                logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + definition.getBeanClassName() + "' mapperInterface");
            }
            // the mapper interface is the original class of the bean
            // but, the actual class of the bean is MapperFactoryBean
            // 此处使用addPropertyValue方法,Spring2.5的MutablePropertyValues
            // 没有add(String propertyName, Object propertyValue)方法
            definition.getPropertyValues().addPropertyValue("mapperInterface", definition.getBeanClassName());
            definition.setBeanClass(MapperFactoryBean.class);
            definition.getPropertyValues().addPropertyValue("addToConfig", this.addToConfig);
            boolean explicitFactoryUsed = false;
            if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
                definition.getPropertyValues().addPropertyValue("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
                explicitFactoryUsed = true;
            } else if (this.sqlSessionFactory != null) {
                definition.getPropertyValues().addPropertyValue("sqlSessionFactory", this.sqlSessionFactory);
                explicitFactoryUsed = true;
            }
            if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {
                if (explicitFactoryUsed) {
                    logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
                }
                definition.getPropertyValues().addPropertyValue("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));
                explicitFactoryUsed = true;
            } else if (this.sqlSessionTemplate != null) {
                if (explicitFactoryUsed) {
                    logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");
                }
                definition.getPropertyValues().addPropertyValue("sqlSessionTemplate", this.sqlSessionTemplate);
                explicitFactoryUsed = true;
            }
            if (!explicitFactoryUsed) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");
                }
                definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
            }
        }
    }
    return beanDefinitions;
}

private static void parseMethods(String url, String id, NodeList nodeList, RootBeanDefinition beanDefinition, ParserContext parserContext) {
    if (nodeList != null && nodeList.getLength() > 0) {
        ManagedList methods = null;
        for (int i = 0; i < nodeList.getLength(); i++) {
            Node node = nodeList.item(i);
            if (node instanceof Element) {
                Element element = (Element) node;
                if ("method".equals(node.getNodeName()) || "method".equals(node.getLocalName())) {
                    String methodName = element.getAttribute("name");
                    if (methodName == null || methodName.length() == 0) {
                        throw new IllegalStateException("<pigeon:method> name attribute == null");
                    }
                    if (methods == null) {
                        methods = new ManagedList();
                    }
                    BeanDefinition methodBeanDefinition = parseMethod(url, methodName, ((Element) node), parserContext, ProviderMethodConfig.class, false);
                    String name = id + "." + methodName;
                    BeanDefinitionHolder methodBeanDefinitionHolder = new BeanDefinitionHolder(methodBeanDefinition, name);
                    methods.add(methodBeanDefinitionHolder);
                }
            }
        }
        if (methods != null) {
            beanDefinition.getPropertyValues().addPropertyValue("methods", methods);
        }
    }
}

protected void handleChildElement(Element ele, ParserContext parserContext, BeanDefinitionBuilder builder) {
    BeanDefinitionParserDelegate delegate = parserContext.getDelegate();
    try {
        Object o = delegate.parsePropertySubElement(ele, builder.getBeanDefinition());
        String clazz = null;
        if (o instanceof BeanDefinitionHolder) {
            clazz = ((BeanDefinitionHolder) o).getBeanDefinition().getBeanClassName();
        } else if (o instanceof RuntimeBeanReference) {
            clazz = parserContext.getRegistry().getBeanDefinition(((RuntimeBeanReference) o).getBeanName()).getBeanClassName();
        } else if (o instanceof RuntimeBeanNameReference) {
            clazz = parserContext.getRegistry().getBeanDefinition(((RuntimeBeanNameReference) o).getBeanName()).getBeanClassName();
        } else {
            parserContext.getReaderContext().error("Don't know how to get bean class from " + o.getClass(), ele);
        }
        handleChildObject(ele, parserContext, builder, Class.forName(clazz), o);
    } catch (ClassNotFoundException e) {
        throw new RuntimeException(e);
    }
}

private void process(BeanDefinitionRegistry registry, ConfigurableListableBeanFactory beanFactory) {
    BeanDefinitionHolder holder = getDataSourceBeanDefinition(beanFactory);
    if (holder != null) {
        String beanName = holder.getBeanName();
        boolean primary = holder.getBeanDefinition().isPrimary();
        logger.info("Replacing '" + beanName + "' DataSource bean with " + (primary ? "primary " : "") + "embedded version");
        registry.registerBeanDefinition(beanName, createEmbeddedBeanDefinition(primary));
    }
}

/**
   * Calls the parent search that will search and register all the candidates.
   * Then the registered objects are post processed to set them as
   * MapperFactoryBeans
   */
@Override
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
    if (beanDefinitions.isEmpty()) {
        LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
    } else {
        processBeanDefinitions(beanDefinitions);
    }
    return beanDefinitions;
}

private BeanDefinition registerConnectionFactoryLocatorBean(BeanDefinitionRegistry registry) {
    Class<?> connectionFactoryRegistryClass = isSocialSecurityAvailable() ? org.springframework.social.security.SocialAuthenticationServiceRegistry.class : ConnectionFactoryRegistry.class;
    if (!registry.containsBeanDefinition(CONNECTION_FACTORY_LOCATOR_ID)) {
        if (logger.isDebugEnabled()) {
            logger.debug("Registering ConnectionFactoryLocator bean (" + connectionFactoryRegistryClass.getName() + ")");
        }
        BeanDefinitionHolder connFactoryLocatorBeanDefHolder = new BeanDefinitionHolder(BeanDefinitionBuilder.genericBeanDefinition(connectionFactoryRegistryClass).getBeanDefinition(), CONNECTION_FACTORY_LOCATOR_ID);
        BeanDefinitionHolder scopedProxy = ScopedProxyUtils.createScopedProxy(connFactoryLocatorBeanDefHolder, registry, false);
        registry.registerBeanDefinition(scopedProxy.getBeanName(), scopedProxy.getBeanDefinition());
    }
    BeanDefinition connectionFactoryLocatorBD = registry.getBeanDefinition(ScopedProxyUtils.getTargetBeanName(CONNECTION_FACTORY_LOCATOR_ID));
    return connectionFactoryLocatorBD;
}

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    List<Class<? extends Annotation>> annotationTypes = getAnnotations();
    Class<? extends Annotation> namedAnnotation = null;
    String[] names = null;
    ScopedProxyMode proxyMode = null;
    if (annotationTypes != null) {
        for (Class<? extends Annotation> annotationType : annotationTypes) {
            AnnotationAttributes attributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(annotationType.getName(), false));
            if (attributes != null && attributes.containsKey("name")) {
                names = attributes.getStringArray("name");
                namedAnnotation = annotationType;
                break;
            }
        }
    }
    // check if Scope annotation is defined and get proxyMode from it
    AnnotationAttributes scopeAttributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(Scope.class.getName(), false));
    if (scopeAttributes != null) {
        proxyMode = scopeAttributes.getEnum("proxyMode");
    }
    BeanDefinition beanDefinition;
    try {
        beanDefinition = buildBeanDefinition(importingClassMetadata, namedAnnotation);
    } catch (Exception e) {
        throw new RuntimeException("Error with onConfigurers", e);
    }
    // implementation didn't return definition so don't continue registration
    if (beanDefinition == null) {
        return;
    }
    if (ObjectUtils.isEmpty(names)) {
        // ok, name(s) not given, generate one
        names = new String[] { beanNameGenerator.generateBeanName(beanDefinition, registry) };
    }
    registry.registerBeanDefinition(names[0], beanDefinition);
    if (names.length > 1) {
        for (int i = 1; i < names.length; i++) {
            registry.registerAlias(names[0], names[i]);
        }
    }
    // wrap in scoped proxy if needed
    if (proxyMode != null && proxyMode != ScopedProxyMode.DEFAULT && proxyMode != ScopedProxyMode.NO) {
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDefinition, names[0]);
        BeanDefinitionHolder scopedProxy = null;
        if (proxyMode == ScopedProxyMode.TARGET_CLASS) {
            scopedProxy = ScopedProxyUtils.createScopedProxy(definitionHolder, registry, true);
        } else if (proxyMode == ScopedProxyMode.INTERFACES) {
            scopedProxy = ScopedProxyUtils.createScopedProxy(definitionHolder, registry, false);
        } else {
            throw new IllegalArgumentException("Unknown proxyMode " + proxyMode);
        }
        BeanDefinitionReaderUtils.registerBeanDefinition(scopedProxy, registry);
    }
}

@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
    CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
    parserContext.pushContainingComponent(compDefinition);
    List<Element> childElements = DomUtils.getChildElements(element);
    for (Element childElement : childElements) {
        if ("bean".equals(childElement.getLocalName())) {
            RootBeanDefinition smartInterceptorDef = createSmartInterceptorDefinition(DelegatingSmartSoapEndpointInterceptor.class, childElement, parserContext);
            BeanDefinitionHolder interceptorDef = createInterceptorDefinition(parserContext, childElement);
            smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, interceptorDef);
            registerSmartInterceptor(parserContext, smartInterceptorDef);
        } else if ("ref".equals(childElement.getLocalName())) {
            RootBeanDefinition smartInterceptorDef = createSmartInterceptorDefinition(DelegatingSmartSoapEndpointInterceptor.class, childElement, parserContext);
            BeanReference interceptorRef = createInterceptorReference(parserContext, childElement);
            smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, interceptorRef);
            registerSmartInterceptor(parserContext, smartInterceptorDef);
        } else if ("payloadRoot".equals(childElement.getLocalName())) {
            List<Element> payloadRootChildren = DomUtils.getChildElements(childElement);
            for (Element payloadRootChild : payloadRootChildren) {
                if ("bean".equals(payloadRootChild.getLocalName())) {
                    RootBeanDefinition smartInterceptorDef = createSmartInterceptorDefinition(PayloadRootSmartSoapEndpointInterceptor.class, childElement, parserContext);
                    BeanDefinitionHolder interceptorDef = createInterceptorDefinition(parserContext, payloadRootChild);
                    String namespaceUri = childElement.getAttribute("namespaceUri");
                    String localPart = childElement.getAttribute("localPart");
                    smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, interceptorDef);
                    smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(1, namespaceUri);
                    smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(2, localPart);
                    registerSmartInterceptor(parserContext, smartInterceptorDef);
                } else if ("ref".equals(payloadRootChild.getLocalName())) {
                    RootBeanDefinition smartInterceptorDef = createSmartInterceptorDefinition(PayloadRootSmartSoapEndpointInterceptor.class, childElement, parserContext);
                    BeanReference interceptorRef = createInterceptorReference(parserContext, payloadRootChild);
                    String namespaceUri = childElement.getAttribute("namespaceUri");
                    String localPart = childElement.getAttribute("localPart");
                    smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, interceptorRef);
                    smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(1, namespaceUri);
                    smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(2, localPart);
                    registerSmartInterceptor(parserContext, smartInterceptorDef);
                }
            }
        } else if ("soapAction".equals(childElement.getLocalName())) {
            List<Element> soapActionChildren = DomUtils.getChildElements(childElement);
            for (Element soapActionChild : soapActionChildren) {
                if ("bean".equals(soapActionChild.getLocalName())) {
                    RootBeanDefinition smartInterceptorDef = createSmartInterceptorDefinition(SoapActionSmartEndpointInterceptor.class, childElement, parserContext);
                    BeanDefinitionHolder interceptorDef = createInterceptorDefinition(parserContext, soapActionChild);
                    String soapAction = childElement.getAttribute("value");
                    smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, interceptorDef);
                    smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(1, soapAction);
                    registerSmartInterceptor(parserContext, smartInterceptorDef);
                } else if ("ref".equals(soapActionChild.getLocalName())) {
                    RootBeanDefinition smartInterceptorDef = createSmartInterceptorDefinition(SoapActionSmartEndpointInterceptor.class, childElement, parserContext);
                    BeanReference interceptorRef = createInterceptorReference(parserContext, soapActionChild);
                    String soapAction = childElement.getAttribute("value");
                    smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, interceptorRef);
                    smartInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(1, soapAction);
                    registerSmartInterceptor(parserContext, smartInterceptorDef);
                }
            }
        }
    }
    parserContext.popAndRegisterContainingComponent();
    return null;
}

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder bean) {
    Map<?, ?> namespaces = parseNamespaces(element, parserContext, bean);
    Map<?, ?> discriminators = parseDiscriminators(element, parserContext, bean);
    Element resourceConfig = DomUtils.getChildElementByTagName(element, "resource-config");
    String pathPrefix = resourceConfig.getAttribute("pathPrefix");
    String prependUri = resourceConfig.getAttribute("prependUri");
    String ignoreWhitespace = resourceConfig.getAttribute("ignoreWhitespace");
    BeanDefinitionBuilder templateProcessor = getTemplateProcessor(resourceConfig);
    bean.addPropertyValue("autowireRequestProcessors", element.getAttribute("autowireRequestProcessors"));
    BeanDefinitionBuilder expressionResolver = BeanDefinitionBuilder.rootBeanDefinition(XPathExpressionResolver.class);
    expressionResolver.addPropertyValue("namespaceMap", namespaces);
    ManagedList requestProcessors = new ManagedList();
    BeanDefinitionBuilder controlResourceLookup = BeanDefinitionBuilder.rootBeanDefinition(PayloadRootBasedResourceLookup.class);
    controlResourceLookup.addPropertyValue("expressionResolver", expressionResolver.getBeanDefinition());
    controlResourceLookup.addPropertyValue("discriminators", discriminators);
    controlResourceLookup.addPropertyValue("pathPrefix", pathPrefix);
    controlResourceLookup.addPropertyValue("prependUri", prependUri);
    controlResourceLookup.addPropertyValue("pathSuffix", "request.xml");
    controlResourceLookup.addPropertyValue("templateProcessor", templateProcessor.getBeanDefinition());
    BeanDefinitionBuilder xmlCompareRequestValidator = BeanDefinitionBuilder.rootBeanDefinition(XmlCompareRequestValidator.class);
    xmlCompareRequestValidator.addPropertyValue("controlResourceLookup", controlResourceLookup.getBeanDefinition());
    xmlCompareRequestValidator.addPropertyValue("ignoreWhitespace", ignoreWhitespace);
    addRequestProcessor(requestProcessors, xmlCompareRequestValidator);
    String[] schemas = parseRequestValidationSchemas(element, bean);
    if (schemas != null) {
        BeanDefinitionBuilder schemaRequestValidator = BeanDefinitionBuilder.rootBeanDefinition(SchemaRequestValidator.class);
        schemaRequestValidator.addPropertyValue("schemas", schemas);
        addRequestProcessor(requestProcessors, schemaRequestValidator);
    }
    BeanDefinitionBuilder responseResourceLookup = BeanDefinitionBuilder.rootBeanDefinition(PayloadRootBasedResourceLookup.class);
    responseResourceLookup.addPropertyValue("expressionResolver", expressionResolver.getBeanDefinition());
    responseResourceLookup.addPropertyValue("discriminators", discriminators);
    responseResourceLookup.addPropertyValue("pathPrefix", pathPrefix);
    responseResourceLookup.addPropertyValue("prependUri", prependUri);
    responseResourceLookup.addPropertyValue("pathSuffix", "response.xml");
    responseResourceLookup.addPropertyValue("templateProcessor", templateProcessor.getBeanDefinition());
    BeanDefinitionBuilder defaultResponseGenerator = BeanDefinitionBuilder.rootBeanDefinition(DefaultResponseGenerator.class);
    defaultResponseGenerator.addPropertyValue("resourceLookup", responseResourceLookup.getBeanDefinition());
    addRequestProcessor(requestProcessors, defaultResponseGenerator);
    bean.addPropertyValue("requestProcessors", requestProcessors);
    if (TRUE.equals(element.getAttribute("autoinjectMock"))) {
        AbstractBeanDefinition injector = BeanDefinitionBuilder.rootBeanDefinition(MockMessageSenderInjector.class).getBeanDefinition();
        BeanDefinitionHolder holder = new BeanDefinitionHolder(injector, parserContext.getReaderContext().generateBeanName(injector));
        registerBeanDefinition(holder, parserContext.getRegistry());
    }
    bean.addPropertyValue("interceptors", parseInterceptors(element, parserContext, bean));
}

private BeanDefinitionHolder parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    BeanDefinitionHolder bdh = null;
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    } else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    } else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        bdh = processBeanDefinition(ele, delegate);
    } else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        // recurse
        doRegisterBeanDefinitions(ele);
    }
    return bdh;
}

/**
     * Resolve candidate to a bean definition and (re)load in Spring.
     * Synchronize to avoid parallel bean definition - usually on reload the beans are interrelated
     * and parallel load will cause concurrent modification exception.
     *
     * @param candidate the candidate to reload
     */
public void defineBean(BeanDefinition candidate) {
    synchronized (getClass()) {
        // TODO sychronize on DefaultListableFactory.beanDefinitionMap?
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
        candidate.setScope(scopeMetadata.getScopeName());
        String beanName = this.beanNameGenerator.generateBeanName(candidate, registry);
        if (candidate instanceof AbstractBeanDefinition) {
            postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
        }
        if (candidate instanceof AnnotatedBeanDefinition) {
            processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
        }
        removeIfExists(beanName);
        if (checkCandidate(beanName, candidate)) {
            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
            definitionHolder = applyScopedProxyMode(scopeMetadata, definitionHolder, registry);
            LOGGER.reload("Registering Spring bean '{}'", beanName);
            LOGGER.debug("Bean definition '{}'", beanName, candidate);
            registerBeanDefinition(definitionHolder, registry);
            DefaultListableBeanFactory bf = maybeRegistryToBeanFactory();
            if (bf != null)
                ResetRequestMappingCaches.reset(bf);
            freezeConfiguration();
        }
        ProxyReplacer.clearAllProxies();
    }
}

@SuppressWarnings({ "rawtypes", "unchecked" })
private static BeanDefinition parse(Element element, ParserContext parserContext, Class<?> beanClass, boolean required) throws ClassNotFoundException {
    RootBeanDefinition bd = new RootBeanDefinition();
    bd.setBeanClass(beanClass);
    // ��许lazy init
    bd.setLazyInit(false);
    // 如果没有id则按照规则生�一个id,注册id到context中
    String id = element.getAttribute("id");
    if ((id == null || id.length() == 0) && required) {
        String generatedBeanName = element.getAttribute("name");
        if (generatedBeanName == null || generatedBeanName.length() == 0) {
            generatedBeanName = element.getAttribute("class");
        }
        if (generatedBeanName == null || generatedBeanName.length() == 0) {
            generatedBeanName = beanClass.getName();
        }
        id = generatedBeanName;
        int counter = 2;
        while (parserContext.getRegistry().containsBeanDefinition(id)) {
            id = generatedBeanName + (counter++);
        }
    }
    if (id != null && id.length() > 0) {
        if (parserContext.getRegistry().containsBeanDefinition(id)) {
            throw new IllegalStateException("Duplicate spring bean id " + id);
        }
        parserContext.getRegistry().registerBeanDefinition(id, bd);
    }
    bd.getPropertyValues().addPropertyValue("id", id);
    if (ProtocolConfig.class.equals(beanClass)) {
        MotanNamespaceHandler.protocolDefineNames.add(id);
    } else if (RegistryConfig.class.equals(beanClass)) {
        MotanNamespaceHandler.registryDefineNames.add(id);
    } else if (BasicServiceInterfaceConfig.class.equals(beanClass)) {
        MotanNamespaceHandler.basicServiceConfigDefineNames.add(id);
    } else if (BasicRefererInterfaceConfig.class.equals(beanClass)) {
        MotanNamespaceHandler.basicRefererConfigDefineNames.add(id);
    } else if (ServiceConfigBean.class.equals(beanClass)) {
        String className = element.getAttribute("class");
        if (className != null && className.length() > 0) {
            RootBeanDefinition classDefinition = new RootBeanDefinition();
            classDefinition.setBeanClass(Class.forName(className, true, Thread.currentThread().getContextClassLoader()));
            classDefinition.setLazyInit(false);
            parseProperties(element.getChildNodes(), classDefinition);
            bd.getPropertyValues().addPropertyValue("ref", new BeanDefinitionHolder(classDefinition, id + "Impl"));
        }
    }
    Set<String> props = new HashSet<String>();
    ManagedMap parameters = null;
    // 把�置文件中的�以set的属性放到bd中
    for (Method setter : beanClass.getMethods()) {
        String name = setter.getName();
        // 必须是setXXX
        if (name.length() <= 3 || !name.startsWith("set") || !Modifier.isPublic(setter.getModifiers()) || setter.getParameterTypes().length != 1) {
            continue;
        }
        String property = (name.substring(3, 4).toLowerCase() + name.substring(4)).replaceAll("_", "-");
        props.add(property);
        if ("id".equals(property)) {
            bd.getPropertyValues().addPropertyValue("id", id);
            continue;
        }
        String value = element.getAttribute(property);
        if ("methods".equals(property)) {
            parseMethods(id, element.getChildNodes(), bd, parserContext);
        }
        if (StringUtils.isBlank(value)) {
            continue;
        }
        value = value.trim();
        if (value.length() == 0) {
            continue;
        }
        Object reference;
        if ("ref".equals(property)) {
            if (parserContext.getRegistry().containsBeanDefinition(value)) {
                BeanDefinition refBean = parserContext.getRegistry().getBeanDefinition(value);
                if (!refBean.isSingleton()) {
                    throw new IllegalStateException("The exported service ref " + value + " must be singleton! Please set the " + value + " bean scope to singleton, eg: <bean id=\"" + value + "\" scope=\"singleton\" ...>");
                }
            }
            reference = new RuntimeBeanReference(value);
        } else if ("protocol".equals(property) && !StringUtils.isBlank(value)) {
            if (!value.contains(",")) {
                reference = new RuntimeBeanReference(value);
            } else {
                parseMultiRef("protocols", value, bd, parserContext);
                reference = null;
            }
        } else if ("registry".equals(property)) {
            parseMultiRef("registries", value, bd, parserContext);
            reference = null;
        } else if ("basicService".equals(property)) {
            reference = new RuntimeBeanReference(value);
        } else if ("basicReferer".equals(property)) {
            reference = new RuntimeBeanReference(value);
        } else if ("extConfig".equals(property)) {
            reference = new RuntimeBeanReference(value);
        } else {
            reference = new TypedStringValue(value);
        }
        if (reference != null) {
            bd.getPropertyValues().addPropertyValue(property, reference);
        }
    }
    if (ProtocolConfig.class.equals(beanClass)) {
        // 把剩余的属性放到protocol的parameters里�
        NamedNodeMap attributes = element.getAttributes();
        int len = attributes.getLength();
        for (int i = 0; i < len; i++) {
            Node node = attributes.item(i);
            String name = node.getLocalName();
            if (!props.contains(name)) {
                if (parameters == null) {
                    parameters = new ManagedMap();
                }
                String value = node.getNodeValue();
                parameters.put(name, new TypedStringValue(value, String.class));
            }
        }
        bd.getPropertyValues().addPropertyValue("parameters", parameters);
    }
    return bd;
}

public BeanComponentDefinition registerBeanDefinition(BeanDefinitionBuilder builder, String id, String[] aliases, ParserContext parserContext) {
    BeanDefinitionHolder holder = new BeanDefinitionHolder(builder.getBeanDefinition(), id, aliases);
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, parserContext.getRegistry());
    BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);
    parserContext.registerComponent(componentDefinition);
    return componentDefinition;
}

private void registerFeignClient(BeanDefinitionRegistry registry, AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
    String className = annotationMetadata.getClassName();
    BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
    validate(attributes);
    definition.addPropertyValue("url", getUrl(attributes));
    definition.addPropertyValue("path", getPath(attributes));
    String name = getName(attributes);
    definition.addPropertyValue("name", name);
    definition.addPropertyValue("type", className);
    definition.addPropertyValue("decode404", attributes.get("decode404"));
    definition.addPropertyValue("fallback", attributes.get("fallback"));
    definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
    definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
    String alias = name + "FeignClient";
    AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
    // has a default, won't be null
    boolean primary = (Boolean) attributes.get("primary");
    beanDefinition.setPrimary(primary);
    String qualifier = getQualifier(attributes);
    if (StringUtils.hasText(qualifier)) {
        alias = qualifier;
    }
    BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[] { alias });
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}

/* 
	 * (non-Javadoc)
	 * @see org.springframework.context.annotation.ImportBeanDefinitionRegistrar#registerBeanDefinitions(org.springframework.core.type.AnnotationMetadata, org.springframework.beans.factory.support.BeanDefinitionRegistry)
	 */
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    linkBuilderBeanDefinitionRegistrar.registerBeanDefinitions(metadata, registry);
    Map<String, Object> attributes = metadata.getAnnotationAttributes(EnableHypermediaSupport.class.getName());
    Collection<HypermediaType> types = Arrays.asList((HypermediaType[]) attributes.get("type"));
    for (HypermediaType type : types) {
        if (JSONPATH_PRESENT) {
            AbstractBeanDefinition linkDiscovererBeanDefinition = getLinkDiscovererBeanDefinition(type);
            registerBeanDefinition(new BeanDefinitionHolder(linkDiscovererBeanDefinition, BeanDefinitionReaderUtils.generateBeanName(linkDiscovererBeanDefinition, registry)), registry);
        }
    }
    if (types.contains(HypermediaType.HAL)) {
        if (JACKSON2_PRESENT) {
            BeanDefinitionBuilder halQueryMapperBuilder = rootBeanDefinition(ObjectMapper.class);
            registerSourcedBeanDefinition(halQueryMapperBuilder, metadata, registry, HAL_OBJECT_MAPPER_BEAN_NAME);
            BeanDefinitionBuilder customizerBeanDefinition = rootBeanDefinition(DefaultObjectMapperCustomizer.class);
            registerSourcedBeanDefinition(customizerBeanDefinition, metadata, registry);
            BeanDefinitionBuilder builder = rootBeanDefinition(Jackson2ModuleRegisteringBeanPostProcessor.class);
            registerSourcedBeanDefinition(builder, metadata, registry);
        }
    }
    if (!types.isEmpty()) {
        BeanDefinitionBuilder linkDiscoverersRegistryBuilder = BeanDefinitionBuilder.rootBeanDefinition(PluginRegistryFactoryBean.class);
        linkDiscoverersRegistryBuilder.addPropertyValue("type", LinkDiscoverer.class);
        registerSourcedBeanDefinition(linkDiscoverersRegistryBuilder, metadata, registry, LINK_DISCOVERER_REGISTRY_BEAN_NAME);
        BeanDefinitionBuilder linkDiscoverersBuilder = BeanDefinitionBuilder.rootBeanDefinition(LinkDiscoverers.class);
        linkDiscoverersBuilder.addConstructorArgReference(LINK_DISCOVERER_REGISTRY_BEAN_NAME);
        registerSourcedBeanDefinition(linkDiscoverersBuilder, metadata, registry);
    }
    registerRelProviderPluginRegistryAndDelegate(registry);
}

private void processBeanProperties(DefaultListableBeanFactory beanFactory, String beanClassName, String replacementPropertiesName, String propertyKey) {
    Class<?> beanClass = loadClass(beanClassName);
    if (beanClass == null) {
        return;
    }
    try {
        // TODO: Required in Grails case and need to reexamine
        beanFactory.getBeanDefinition(replacementPropertiesName);
    } catch (Exception ex) {
        return;
    }
    String[] beanNames = beanFactory.getBeanNamesForType(beanClass);
    for (String beanName : beanNames) {
        BeanDefinition beanDefinition = getBeanDefinition(beanFactory, beanName);
        MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
        PropertyValue originalProperties = propertyValues.getPropertyValue(propertyKey);
        Properties originalPropertyValue = null;
        if (originalProperties != null) {
            Object value = originalProperties.getValue();
            if (value instanceof Properties) {
                originalPropertyValue = (Properties) originalProperties.getValue();
            } else if (value instanceof BeanDefinitionHolder) {
                originalPropertyValue = extractProperties((BeanDefinitionHolder) value);
            } else if (value instanceof BeanReference) {
                originalPropertyValue = extractProperties((BeanReference) value, beanFactory);
            } else if (value instanceof TypedStringValue) {
                originalPropertyValue = extractProperties((TypedStringValue) value);
            } else {
                throw new IllegalStateException("Unable to process property " + originalProperties.getName() + " of " + value.getClass() + " type");
            }
        } else {
            originalPropertyValue = new ManagedProperties();
        }
        ManagedProperties replacementProperties = loadReplacementPropertyValues(beanFactory, replacementPropertiesName);
        replacementProperties.setMergeEnabled(true);
        replacementProperties = (ManagedProperties) replacementProperties.merge(originalPropertyValue);
        propertyValues.addPropertyValue(new PropertyValue(propertyKey, replacementProperties));
    }
}

private void registerBeanByResolvedType(String beanName, Class<?> resolvedType) {
    if (resolvedType == null)
        return;
    final BeanDefinition beanDefinition = getOrCreateBeanDefinition(beanName, resolvedType);
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(beanDefinition, beanName);
    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(beanDefinition);
    ScopedProxyMode scopedProxyMode = scopeMetadata.getScopedProxyMode();
    if (!scopedProxyMode.equals(ScopedProxyMode.NO)) {
        definitionHolder = ScopedProxyUtils.createScopedProxy(definitionHolder, this, scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS));
    }
    registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
}

protected void setFirstChildAsProperty(Element element, ParserContext ctx, BeanDefinitionBuilder bean, String propertyName) {
    Element first = getFirstChild(element);
    if (first == null) {
        throw new IllegalStateException(propertyName + " property must have child elements!");
    }
    String id;
    BeanDefinition child;
    if (first.getNamespaceURI().equals(BeanDefinitionParserDelegate.BEANS_NAMESPACE_URI)) {
        String name = first.getLocalName();
        if ("ref".equals(name)) {
            id = first.getAttribute("bean");
            if (id == null) {
                throw new IllegalStateException("<ref> elements must have a \"bean\" attribute!");
            }
            bean.addPropertyReference(propertyName, id);
            return;
        } else if ("bean".equals(name)) {
            BeanDefinitionHolder bdh = ctx.getDelegate().parseBeanDefinitionElement(first);
            child = bdh.getBeanDefinition();
            bean.addPropertyValue(propertyName, child);
            return;
        } else {
            throw new UnsupportedOperationException("Elements with the name " + name + " are not currently " + "supported as sub elements of " + element.getLocalName());
        }
    }
    child = ctx.getDelegate().parseCustomElement(first, bean.getBeanDefinition());
    bean.addPropertyValue(propertyName, child);
}

@SuppressWarnings("unchecked")
private static BeanDefinition parse(Element element, ParserContext parserContext, Class<?> beanClass, boolean required) {
    RootBeanDefinition beanDefinition = new RootBeanDefinition();
    beanDefinition.setBeanClass(beanClass);
    beanDefinition.setLazyInit(false);
    String id = element.getAttribute("id");
    if ((id == null || id.length() == 0) && required) {
        String generatedBeanName = element.getAttribute("name");
        if (generatedBeanName == null || generatedBeanName.length() == 0) {
            if (ProtocolConfig.class.equals(beanClass)) {
                generatedBeanName = "dubbo";
            } else {
                generatedBeanName = element.getAttribute("interface");
            }
        }
        if (generatedBeanName == null || generatedBeanName.length() == 0) {
            generatedBeanName = beanClass.getName();
        }
        id = generatedBeanName;
        int counter = 2;
        while (parserContext.getRegistry().containsBeanDefinition(id)) {
            id = generatedBeanName + (counter++);
        }
    }
    if (id != null && id.length() > 0) {
        if (parserContext.getRegistry().containsBeanDefinition(id)) {
            throw new IllegalStateException("Duplicate spring bean id " + id);
        }
        parserContext.getRegistry().registerBeanDefinition(id, beanDefinition);
        beanDefinition.getPropertyValues().addPropertyValue("id", id);
    }
    if (ProtocolConfig.class.equals(beanClass)) {
        for (String name : parserContext.getRegistry().getBeanDefinitionNames()) {
            BeanDefinition definition = parserContext.getRegistry().getBeanDefinition(name);
            PropertyValue property = definition.getPropertyValues().getPropertyValue("protocol");
            if (property != null) {
                Object value = property.getValue();
                if (value instanceof ProtocolConfig && id.equals(((ProtocolConfig) value).getName())) {
                    definition.getPropertyValues().addPropertyValue("protocol", new RuntimeBeanReference(id));
                }
            }
        }
    } else if (ServiceBean.class.equals(beanClass)) {
        String className = element.getAttribute("class");
        if (className != null && className.length() > 0) {
            RootBeanDefinition classDefinition = new RootBeanDefinition();
            classDefinition.setBeanClass(ReflectUtils.forName(className));
            classDefinition.setLazyInit(false);
            parseProperties(element.getChildNodes(), classDefinition);
            beanDefinition.getPropertyValues().addPropertyValue("ref", new BeanDefinitionHolder(classDefinition, id + "Impl"));
        }
    } else if (ProviderConfig.class.equals(beanClass)) {
        parseNested(element, parserContext, ServiceBean.class, true, "service", "provider", id, beanDefinition);
    } else if (ConsumerConfig.class.equals(beanClass)) {
        parseNested(element, parserContext, ReferenceBean.class, false, "reference", "consumer", id, beanDefinition);
    }
    Set<String> props = new HashSet<String>();
    ManagedMap parameters = null;
    for (Method setter : beanClass.getMethods()) {
        String name = setter.getName();
        if (name.length() > 3 && name.startsWith("set") && Modifier.isPublic(setter.getModifiers()) && setter.getParameterTypes().length == 1) {
            Class<?> type = setter.getParameterTypes()[0];
            String property = StringUtils.camelToSplitName(name.substring(3, 4).toLowerCase() + name.substring(4), "-");
            props.add(property);
            Method getter = null;
            try {
                getter = beanClass.getMethod("get" + name.substring(3), new Class<?>[0]);
            } catch (NoSuchMethodException e) {
                try {
                    getter = beanClass.getMethod("is" + name.substring(3), new Class<?>[0]);
                } catch (NoSuchMethodException e2) {
                }
            }
            if (getter == null || !Modifier.isPublic(getter.getModifiers()) || !type.equals(getter.getReturnType())) {
                continue;
            }
            if ("parameters".equals(property)) {
                parameters = parseParameters(element.getChildNodes(), beanDefinition);
            } else if ("methods".equals(property)) {
                parseMethods(id, element.getChildNodes(), beanDefinition, parserContext);
            } else if ("arguments".equals(property)) {
                parseArguments(id, element.getChildNodes(), beanDefinition, parserContext);
            } else {
                String value = element.getAttribute(property);
                if (value != null) {
                    value = value.trim();
                    if (value.length() > 0) {
                        if ("registry".equals(property) && RegistryConfig.NO_AVAILABLE.equalsIgnoreCase(value)) {
                            RegistryConfig registryConfig = new RegistryConfig();
                            registryConfig.setAddress(RegistryConfig.NO_AVAILABLE);
                            beanDefinition.getPropertyValues().addPropertyValue(property, registryConfig);
                        } else if ("registry".equals(property) && value.indexOf(',') != -1) {
                            parseMultiRef("registries", value, beanDefinition, parserContext);
                        } else if ("provider".equals(property) && value.indexOf(',') != -1) {
                            parseMultiRef("providers", value, beanDefinition, parserContext);
                        } else if ("protocol".equals(property) && value.indexOf(',') != -1) {
                            parseMultiRef("protocols", value, beanDefinition, parserContext);
                        } else {
                            Object reference;
                            if (isPrimitive(type)) {
                                if ("async".equals(property) && "false".equals(value) || "timeout".equals(property) && "0".equals(value) || "delay".equals(property) && "0".equals(value) || "version".equals(property) && "0.0.0".equals(value) || "stat".equals(property) && "-1".equals(value) || "reliable".equals(property) && "false".equals(value)) {
                                    // 兼容旧版本xsd中的default值
                                    value = null;
                                }
                                reference = value;
                            } else if ("protocol".equals(property) && ExtensionLoader.getExtensionLoader(Protocol.class).hasExtension(value) && (!parserContext.getRegistry().containsBeanDefinition(value) || !ProtocolConfig.class.getName().equals(parserContext.getRegistry().getBeanDefinition(value).getBeanClassName()))) {
                                if ("dubbo:provider".equals(element.getTagName())) {
                                    logger.warn("Recommended replace <dubbo:provider protocol=\"" + value + "\" ... /> to <dubbo:protocol name=\"" + value + "\" ... />");
                                }
                                // 兼容旧版本�置
                                ProtocolConfig protocol = new ProtocolConfig();
                                protocol.setName(value);
                                reference = protocol;
                            } else if ("monitor".equals(property) && (!parserContext.getRegistry().containsBeanDefinition(value) || !MonitorConfig.class.getName().equals(parserContext.getRegistry().getBeanDefinition(value).getBeanClassName()))) {
                                // 兼容旧版本�置
                                reference = convertMonitor(value);
                            } else if ("onreturn".equals(property)) {
                                int index = value.lastIndexOf(".");
                                String returnRef = value.substring(0, index);
                                String returnMethod = value.substring(index + 1);
                                reference = new RuntimeBeanReference(returnRef);
                                beanDefinition.getPropertyValues().addPropertyValue("onreturnMethod", returnMethod);
                            } else if ("onthrow".equals(property)) {
                                int index = value.lastIndexOf(".");
                                String throwRef = value.substring(0, index);
                                String throwMethod = value.substring(index + 1);
                                reference = new RuntimeBeanReference(throwRef);
                                beanDefinition.getPropertyValues().addPropertyValue("onthrowMethod", throwMethod);
                            } else {
                                if ("ref".equals(property) && parserContext.getRegistry().containsBeanDefinition(value)) {
                                    BeanDefinition refBean = parserContext.getRegistry().getBeanDefinition(value);
                                    if (!refBean.isSingleton()) {
                                        throw new IllegalStateException("The exported service ref " + value + " must be singleton! Please set the " + value + " bean scope to singleton, eg: <bean id=\"" + value + "\" scope=\"singleton\" ...>");
                                    }
                                }
                                reference = new RuntimeBeanReference(value);
                            }
                            beanDefinition.getPropertyValues().addPropertyValue(property, reference);
                        }
                    }
                }
            }
        }
    }
    NamedNodeMap attributes = element.getAttributes();
    int len = attributes.getLength();
    for (int i = 0; i < len; i++) {
        Node node = attributes.item(i);
        String name = node.getLocalName();
        if (!props.contains(name)) {
            if (parameters == null) {
                parameters = new ManagedMap();
            }
            String value = node.getNodeValue();
            parameters.put(name, new TypedStringValue(value, String.class));
        }
    }
    if (parameters != null) {
        beanDefinition.getPropertyValues().addPropertyValue("parameters", parameters);
    }
    return beanDefinition;
}

@SuppressWarnings("unchecked")
private static BeanDefinition parse(Element element, ParserContext parserContext, Class<?> beanClass, boolean required) {
    RootBeanDefinition beanDefinition = new RootBeanDefinition();
    beanDefinition.setBeanClass(beanClass);
    beanDefinition.setLazyInit(false);
    String id = element.getAttribute("id");
    if ((id == null || id.length() == 0) && required) {
        String generatedBeanName = element.getAttribute("name");
        if (generatedBeanName == null || generatedBeanName.length() == 0) {
            if (ProtocolConfig.class.equals(beanClass)) {
                generatedBeanName = "dubbo";
            } else {
                generatedBeanName = element.getAttribute("interface");
            }
        }
        if (generatedBeanName == null || generatedBeanName.length() == 0) {
            generatedBeanName = beanClass.getName();
        }
        id = generatedBeanName;
        int counter = 2;
        while (parserContext.getRegistry().containsBeanDefinition(id)) {
            id = generatedBeanName + (counter++);
        }
    }
    if (id != null && id.length() > 0) {
        if (parserContext.getRegistry().containsBeanDefinition(id)) {
            throw new IllegalStateException("Duplicate spring bean id " + id);
        }
        parserContext.getRegistry().registerBeanDefinition(id, beanDefinition);
        beanDefinition.getPropertyValues().addPropertyValue("id", id);
    }
    if (ProtocolConfig.class.equals(beanClass)) {
        for (String name : parserContext.getRegistry().getBeanDefinitionNames()) {
            BeanDefinition definition = parserContext.getRegistry().getBeanDefinition(name);
            PropertyValue property = definition.getPropertyValues().getPropertyValue("protocol");
            if (property != null) {
                Object value = property.getValue();
                if (value instanceof ProtocolConfig && id.equals(((ProtocolConfig) value).getName())) {
                    definition.getPropertyValues().addPropertyValue("protocol", new RuntimeBeanReference(id));
                }
            }
        }
    } else if (ServiceBean.class.equals(beanClass)) {
        String className = element.getAttribute("class");
        if (className != null && className.length() > 0) {
            RootBeanDefinition classDefinition = new RootBeanDefinition();
            classDefinition.setBeanClass(ReflectUtils.forName(className));
            classDefinition.setLazyInit(false);
            parseProperties(element.getChildNodes(), classDefinition);
            beanDefinition.getPropertyValues().addPropertyValue("ref", new BeanDefinitionHolder(classDefinition, id + "Impl"));
        }
    } else if (ProviderConfig.class.equals(beanClass)) {
        parseNested(element, parserContext, ServiceBean.class, true, "service", "provider", id, beanDefinition);
    } else if (ConsumerConfig.class.equals(beanClass)) {
        parseNested(element, parserContext, ReferenceBean.class, false, "reference", "consumer", id, beanDefinition);
    }
    Set<String> props = new HashSet<String>();
    ManagedMap parameters = null;
    for (Method setter : beanClass.getMethods()) {
        String name = setter.getName();
        if (name.length() > 3 && name.startsWith("set") && Modifier.isPublic(setter.getModifiers()) && setter.getParameterTypes().length == 1) {
            Class<?> type = setter.getParameterTypes()[0];
            String property = StringUtils.camelToSplitName(name.substring(3, 4).toLowerCase() + name.substring(4), "-");
            props.add(property);
            Method getter = null;
            try {
                getter = beanClass.getMethod("get" + name.substring(3), new Class<?>[0]);
            } catch (NoSuchMethodException e) {
                try {
                    getter = beanClass.getMethod("is" + name.substring(3), new Class<?>[0]);
                } catch (NoSuchMethodException e2) {
                }
            }
            if (getter == null || !Modifier.isPublic(getter.getModifiers()) || !type.equals(getter.getReturnType())) {
                continue;
            }
            if ("parameters".equals(property)) {
                parameters = parseParameters(element.getChildNodes(), beanDefinition);
            } else if ("methods".equals(property)) {
                parseMethods(id, element.getChildNodes(), beanDefinition, parserContext);
            } else if ("arguments".equals(property)) {
                parseArguments(id, element.getChildNodes(), beanDefinition, parserContext);
            } else {
                String value = element.getAttribute(property);
                if (value != null) {
                    value = value.trim();
                    if (value.length() > 0) {
                        if ("registry".equals(property) && RegistryConfig.NO_AVAILABLE.equalsIgnoreCase(value)) {
                            RegistryConfig registryConfig = new RegistryConfig();
                            registryConfig.setAddress(RegistryConfig.NO_AVAILABLE);
                            beanDefinition.getPropertyValues().addPropertyValue(property, registryConfig);
                        } else if ("registry".equals(property) && value.indexOf(',') != -1) {
                            parseMultiRef("registries", value, beanDefinition, parserContext);
                        } else if ("provider".equals(property) && value.indexOf(',') != -1) {
                            parseMultiRef("providers", value, beanDefinition, parserContext);
                        } else if ("protocol".equals(property) && value.indexOf(',') != -1) {
                            parseMultiRef("protocols", value, beanDefinition, parserContext);
                        } else {
                            Object reference;
                            if (isPrimitive(type)) {
                                if ("async".equals(property) && "false".equals(value) || "timeout".equals(property) && "0".equals(value) || "delay".equals(property) && "0".equals(value) || "version".equals(property) && "0.0.0".equals(value) || "stat".equals(property) && "-1".equals(value) || "reliable".equals(property) && "false".equals(value)) {
                                    // 兼容旧版本xsd中的default值
                                    value = null;
                                }
                                reference = value;
                            } else if ("protocol".equals(property) && ExtensionLoader.getExtensionLoader(Protocol.class).hasExtension(value) && (!parserContext.getRegistry().containsBeanDefinition(value) || !ProtocolConfig.class.getName().equals(parserContext.getRegistry().getBeanDefinition(value).getBeanClassName()))) {
                                if ("dubbo:provider".equals(element.getTagName())) {
                                    logger.warn("Recommended replace <dubbo:provider protocol=\"" + value + "\" ... /> to <dubbo:protocol name=\"" + value + "\" ... />");
                                }
                                // 兼容旧版本�置
                                ProtocolConfig protocol = new ProtocolConfig();
                                protocol.setName(value);
                                reference = protocol;
                            } else if ("monitor".equals(property) && (!parserContext.getRegistry().containsBeanDefinition(value) || !MonitorConfig.class.getName().equals(parserContext.getRegistry().getBeanDefinition(value).getBeanClassName()))) {
                                // 兼容旧版本�置
                                reference = convertMonitor(value);
                            } else if ("onreturn".equals(property)) {
                                int index = value.lastIndexOf(".");
                                String returnRef = value.substring(0, index);
                                String returnMethod = value.substring(index + 1);
                                reference = new RuntimeBeanReference(returnRef);
                                beanDefinition.getPropertyValues().addPropertyValue("onreturnMethod", returnMethod);
                            } else if ("onthrow".equals(property)) {
                                int index = value.lastIndexOf(".");
                                String throwRef = value.substring(0, index);
                                String throwMethod = value.substring(index + 1);
                                reference = new RuntimeBeanReference(throwRef);
                                beanDefinition.getPropertyValues().addPropertyValue("onthrowMethod", throwMethod);
                            } else {
                                if ("ref".equals(property) && parserContext.getRegistry().containsBeanDefinition(value)) {
                                    BeanDefinition refBean = parserContext.getRegistry().getBeanDefinition(value);
                                    if (!refBean.isSingleton()) {
                                        throw new IllegalStateException("The exported service ref " + value + " must be singleton! Please set the " + value + " bean scope to singleton, eg: <bean id=\"" + value + "\" scope=\"singleton\" ...>");
                                    }
                                }
                                reference = new RuntimeBeanReference(value);
                            }
                            beanDefinition.getPropertyValues().addPropertyValue(property, reference);
                        }
                    }
                }
            }
        }
    }
    NamedNodeMap attributes = element.getAttributes();
    int len = attributes.getLength();
    for (int i = 0; i < len; i++) {
        Node node = attributes.item(i);
        String name = node.getLocalName();
        if (!props.contains(name)) {
            if (parameters == null) {
                parameters = new ManagedMap();
            }
            String value = node.getNodeValue();
            parameters.put(name, new TypedStringValue(value, String.class));
        }
    }
    if (parameters != null) {
        beanDefinition.getPropertyValues().addPropertyValue("parameters", parameters);
    }
    return beanDefinition;
}

/**
                 * @param def Registered BeanDefinition.
                 * @throws BeansException in case of errors.
                 */
private void processNested(BeanDefinition def) throws BeansException {
    Iterator<PropertyValue> iterVals = def.getPropertyValues().getPropertyValueList().iterator();
    while (iterVals.hasNext()) {
        PropertyValue val = iterVals.next();
        if (excludedPropsList.contains(val.getName())) {
            iterVals.remove();
            continue;
        }
        if (val.getValue() instanceof Iterable) {
            Iterator iterNested = ((Iterable) val.getValue()).iterator();
            while (iterNested.hasNext()) {
                Object item = iterNested.next();
                if (item instanceof BeanDefinitionHolder) {
                    BeanDefinitionHolder h = (BeanDefinitionHolder) item;
                    try {
                        if (h.getBeanDefinition().getBeanClassName() != null)
                            Class.forName(h.getBeanDefinition().getBeanClassName());
                        processNested(h.getBeanDefinition());
                    } catch (ClassNotFoundException ignored) {
                        iterNested.remove();
                    }
                }
            }
        }
    }
}

@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    String interfaceName = element.getAttribute(INTERFACE_ATTR);
    String setupRef = element.getAttribute(SETUP_REF_ATTR);
    // Create the Interceptor definition
    RootBeanDefinition interceptorDefinition = new RootBeanDefinition(UsurperMethodInterceptor.class);
    if (StringUtils.hasText(setupRef)) {
        interceptorDefinition.getPropertyValues().addPropertyValue(USURPER_GENERATOR_SETUP_PROP, setupRef);
    }
    try {
        BeanDefinitionHolder holder = new BeanDefinitionHolder(interceptorDefinition, USURPER_INTERCEPTOR_BEAN_ID);
        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);
    }
    List<String> interceptorNames = new ArrayList<String>();
    interceptorNames.add(USURPER_INTERCEPTOR_BEAN_ID);
    // Create the target Class definition.
    RootBeanDefinition targetDefinition = new RootBeanDefinition(ProxyFactoryBean.class);
    targetDefinition.setSource(parserContext.extractSource(element));
    targetDefinition.getPropertyValues().addPropertyValue(PROXYFACTORYBEAN_PROXY_INTERFACES_PROP, interfaceName);
    targetDefinition.getPropertyValues().addPropertyValue(PROXYFACTORYBEAN_INTERCEPTOR_NAMES_PROP, interceptorNames);
    return targetDefinition;
}

public BeanMetadataElement parseConverter(Element element, ParserContext parserContext) {
    String converterRef = element.getAttribute("ref");
    if (StringUtils.hasText(converterRef)) {
        return new RuntimeBeanReference(converterRef);
    }
    Element beanElement = DomUtils.getChildElementByTagName(element, "bean");
    if (beanElement != null) {
        BeanDefinitionHolder beanDef = parserContext.getDelegate().parseBeanDefinitionElement(beanElement);
        beanDef = parserContext.getDelegate().decorateBeanDefinitionIfRequired(beanElement, beanDef);
        return beanDef;
    }
    parserContext.getReaderContext().error("Element <converter> must specify 'ref' or contain a bean definition for the converter", element);
    return null;
}

@Override
protected Object resolveValue(Object value) {
    BeanDefinition definition = null;
    String beanName = null;
    if (value instanceof BeanDefinition) {
        definition = (BeanDefinition) value;
        beanName = BeanDefinitionReaderUtils.generateBeanName(definition, registry);
    } else if (value instanceof BeanDefinitionHolder) {
        BeanDefinitionHolder holder = (BeanDefinitionHolder) value;
        definition = holder.getBeanDefinition();
        beanName = holder.getBeanName();
    }
    if (definition != null) {
        boolean nestedScoped = scope.equals(definition.getScope());
        boolean scopeChangeRequiresProxy = !scoped && nestedScoped;
        if (scopeChangeRequiresProxy) {
            // analysed
            return createScopedProxy(beanName, definition, registry, proxyTargetClass);
        }
    }
    // Nested inner bean definitions are recursively analysed here
    value = super.resolveValue(value);
    return value;
}

/**
     * Loads a {@link MutableSource} by examining the value of a Sink.
     * 
     * @param sink
     *            The {@link Sink} configured using a certain type of source.
     * @param value
     *            The Spring representation of that source.
     * @return A {@link MutableSource}, representing the source of the data to
     *         be injected in the {@link Sink}.
     */
private static MutableSource loadSource(MutableContext context, Sink sink, Object value) {
    MutableSource result = null;
    if (value instanceof String) {
        return load(sink, (String) value);
    } else if (value instanceof RuntimeBeanReference) {
        result = load(sink, (RuntimeBeanReference) value, context);
    } else if (value instanceof TypedStringValue) {
        result = load(sink, (TypedStringValue) value);
    } else if (value instanceof BeanDefinitionHolder) {
        result = load(sink, (BeanDefinitionHolder) value, context);
    } else if (value instanceof ManagedList) {
        result = load(sink, (ManagedList) value, context);
    } else if (value instanceof ManagedMap) {
        result = load(context, sink, (ManagedMap) value);
    } else if (value instanceof ManagedProperties) {
        result = load(sink, (ManagedProperties) value);
    } else {
        System.err.println("No support for " + value.getClass().getName());
        return null;
    }
    result.setId("source" + (counter++));
    return result;
}

/**
	 * Determine whether the specified bean definition qualifies as an autowire candidate,
	 * to be injected into other beans which declare a dependency of matching type.
	 * @param beanName the name of the bean definition to check
	 * @param mbd the merged bean definition to check
	 * @param descriptor the descriptor of the dependency to resolve
	 * @return whether the bean should be considered as autowire candidate
	 */
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd, DependencyDescriptor descriptor) {
    resolveBeanClass(mbd, beanName);
    if (mbd.isFactoryMethodUnique) {
        boolean resolve;
        synchronized (mbd.constructorArgumentLock) {
            resolve = (mbd.resolvedConstructorOrFactoryMethod == null);
        }
        if (resolve) {
            new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
        }
    }
    return getAutowireCandidateResolver().isAutowireCandidate(new BeanDefinitionHolder(mbd, beanName, getAliases(beanName)), descriptor);
}

@Override
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
    return false;
}

@SuppressWarnings("unchecked")
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
    if (descriptor.getDependencyType().isInterface()) {
        return super.isAutowireCandidate(bdHolder, descriptor);
    } else {
        return findEnvironmentAnnotation(descriptor.getDependencyType()) == null || super.isAutowireCandidate(bdHolder, descriptor);
    }
}

@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
    BeanDefinitionHolder beanDefHolder = parserContext.getDelegate().parseBeanDefinitionElement(element);
    AbstractBeanDefinition def = (AbstractBeanDefinition) beanDefHolder.getBeanDefinition();
    return def;
}

@Override
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
    return autowireCandidateResolver.isAutowireCandidate(bdHolder, descriptor);
}

protected void registerBeanDefinition(BeanDefinitionHolder beanDefinitionHolder, BeanDefinitionRegistry beanDefinitionRegistry) {
    //register other beans here if necessary
    super.registerBeanDefinition(beanDefinitionHolder, beanDefinitionRegistry);
}

protected BeanDefinition register(String id, BeanDefinitionBuilder builder, ParserContext parserContext) {
    BeanDefinition def = builder.getBeanDefinition();
    BeanDefinitionHolder holder = new BeanDefinitionHolder(def, id);
    BeanDefinitionReaderUtils.registerBeanDefinition(holder, parserContext.getRegistry());
    return def;
}

@Override
public BeanDefinitionHolder decorate(Node source, BeanDefinitionHolder holder, ParserContext ctx) {
    holder.getBeanDefinition().setAttribute(attributeName, ((Attr) source).getValue());
    return holder;
}

public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder beanDefinitionHolder, ParserContext parserContext) {
    return null;
}

/* (non-Javadoc) */
protected BeanDefinitionHolder newBeanDefinitionHolder(BeanDefinitionBuilder builder) {
    return new BeanDefinitionHolder(builder.getBeanDefinition(), generateBeanName());
}