Java ManagedSet.add方法代码示例

import org.springframework.beans.factory.support.ManagedSet; //导入方法依赖的package包/类
/**
 * Parses a list of elements into a set of beans/standard content.
 *
 * @param grandChildren - The set of beans/content in a bean property
 * @param child - The property tag for the parent.
 * @param parent - The parent bean that the tag is nested in.
 * @param parserContext - Provided information and functionality regarding current bean set.
 * @return A managedSet of the nested content.
 */
protected ManagedSet parseSet(ArrayList<Element> grandChildren, Element child, BeanDefinitionBuilder parent,
        ParserContext parserContext) {
    ManagedSet setItems = new ManagedSet();

    for (int i = 0; i < grandChildren.size(); i++) {
        Element grandChild = grandChildren.get(i);

        if (child.getTagName().compareTo("value") == 0) {
            setItems.add(grandChild.getTextContent());
        } else {
            setItems.add(parseBean(grandChild, parent, parserContext));
        }
    }

    String merge = child.getAttribute("merge");
    if (merge != null) {
        setItems.setMergeEnabled(Boolean.valueOf(merge));
    }

    return setItems;
}
 

import org.springframework.beans.factory.support.ManagedSet; //导入方法依赖的package包/类
/**
 * Iterates through the set values and calls helpers to process the value
 *
 * @param setVal the set to process
 * @param propertyName name of the property which has the set value
 * @param nestedBeanStack stack of bean containers which contains the set property
 */
protected void visitSet(Set setVal, String propertyName, Stack<BeanDefinitionHolder> nestedBeanStack) {
    boolean isMergeEnabled = false;
    if (setVal instanceof ManagedSet) {
        isMergeEnabled = ((ManagedSet) setVal).isMergeEnabled();
    }

    ManagedSet newSet = new ManagedSet();
    newSet.setMergeEnabled(isMergeEnabled);

    for (Object elem : setVal) {
        if (isStringValue(elem)) {
            elem = processSetStringPropertyValue(propertyName, setVal, getString(elem), nestedBeanStack,
                    beanProcessors);
        } else {
            elem = visitPropertyValue(propertyName, elem, nestedBeanStack);
        }

        newSet.add(elem);
    }

    setVal.clear();
    setVal.addAll(newSet);
}
 

import org.springframework.beans.factory.support.ManagedSet; //导入方法依赖的package包/类
private void parseLogsElement(Element logsElement, BeanDefinitionBuilder factory, ParserContext ctx) {
    if (logsElement == null) {
        return;
    }

    List<Element> childElements = DomUtils.getChildElementsByTagName(logsElement, "log");

    ManagedSet<BeanDefinition> logs = new ManagedSet<BeanDefinition>(childElements.size());

    for (Element element : childElements) {

        BeanDefinition bd = ctx.getRegistry().getBeanDefinition(element.getAttribute("ref"));

        if (bd != null) {
            logs.add(bd);
        }
    }

    if (logs.size() != 0) {
        factory.addPropertyValue("eventLogs", logs);
    }
}
 

import org.springframework.beans.factory.support.ManagedSet; //导入方法依赖的package包/类
@Override
public BeanDefinition parseFilterManagerElement(Element filterElement) {

    BeanDefinitionBuilder filterManagerFactory = BeanDefinitionBuilder.rootBeanDefinition(SimpleFilterManager.class);
    filterManagerFactory.setAutowireMode(RootBeanDefinition.AUTOWIRE_BY_TYPE);
    filterManagerFactory.setLazyInit(false);

    filterManagerFactory.addPropertyValue("type", getComponentName());

    List<Element> itemElements = DomUtils.getChildElementsByTagName(filterElement, "item");
    ManagedSet<BeanDefinition> items = new ManagedSet<BeanDefinition>(itemElements.size());

    for (Element element : itemElements) {
        BeanDefinition bd = parseItemElement(element);

        if (bd != null) {
            items.add(bd);
        }
    }
    filterManagerFactory.addPropertyValue("filters", items);

    return filterManagerFactory.getBeanDefinition();
}
 

import org.springframework.beans.factory.support.ManagedSet; //导入方法依赖的package包/类
/**
 * Parses a list of elements into a set of beans/standard content.
 *
 * @param grandChildren - The set of beans/content in a bean property
 * @param child - The property tag for the parent.
 * @param parent - The parent bean that the tag is nested in.
 * @param parserContext - Provided information and functionality regarding current bean set.
 * @return A managedSet of the nested content.
 */
private ManagedSet parseSet(ArrayList<Element> grandChildren, Element child, BeanDefinitionBuilder parent,
        ParserContext parserContext) {
    ManagedSet setItems = new ManagedSet();

    for (int i = 0; i < grandChildren.size(); i++) {
        Element grandChild = grandChildren.get(i);

        if (child.getTagName().compareTo("spring:value") == 0) {
            setItems.add(grandChild.getTextContent());
        } else {
            setItems.add(parseBean(grandChild, parent, parserContext));
        }
    }

    String merge = child.getAttribute("merge");
    if (merge != null) {
        setItems.setMergeEnabled(Boolean.valueOf(merge));
    }

    return setItems;
}
 

import org.springframework.beans.factory.support.ManagedSet; //导入方法依赖的package包/类
private String parseFilterChain(Element element, ParserContext parserContext) {
Element filterChain = DomUtils.getChildElementByTagName(element, AttributeNames.FILTER_CHAIN);
List<Element> filters = DomUtils.getChildElementsByTagName(filterChain, AttributeNames.FILTER);
BeanDefinitionBuilder filterChainBuilder = BeanDefinitionBuilder.genericBeanDefinition(FilterChain.class);
ManagedSet<BeanDefinition> filterBeanDefinitions = new ManagedSet<BeanDefinition>();
for (Element filter : filters) {
    String ref = filter.getAttribute(AttributeNames.REF);
    BeanDefinition filterDefinition = parserContext.getRegistry().getBeanDefinition(ref);
    filterBeanDefinitions.add(filterDefinition);
}
filterChainBuilder.addConstructorArgValue(filterBeanDefinitions);
String filterChainString = StringUtils.uncapitalize(FilterChain.class.getSimpleName());
parserContext.getRegistry().registerBeanDefinition(filterChainString, filterChainBuilder.getBeanDefinition());
return filterChainString;
   }
 

import org.springframework.beans.factory.support.ManagedSet; //导入方法依赖的package包/类
private void parseShardingDataSource(Element element, ParserContext parserContext){
	BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(ShardingDataSourceRepositorySupport.class);
	Element partitionsElement= DomUtils.getChildElementByTagName(element, DATA_SOURCE_PARTITIONS);
	List<Element> partitions= DomUtils.getChildElementsByTagName(partitionsElement, DATA_SOURCE_PARTITION);
	ManagedSet<BeanDefinition> partitionDataSources  = new ManagedSet<BeanDefinition>();
	for(Element each: partitions){
		partitionDataSources.add(parseDataSourcePartition(each,parserContext));
	}
	factory.addPropertyValue("partitionDataSources", partitionDataSources);
	factory.addPropertyValue("databaseType", DatabaseType.valueOf(element.getAttribute(DATA_BASE_TYPE)));
	shardingDataSourceRepositoryDefinition= factory.getBeanDefinition();
}
 

import org.springframework.beans.factory.support.ManagedSet; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
protected void visitSet(String propertyName, Map<String, String> parentPropertyExpressions,
        Map<String, String> propertyExpressions, Set setVal, ConfigurableListableBeanFactory beanFactory,
        Set<String> processedBeanNames) {
    boolean isMergeEnabled = false;
    if (setVal instanceof ManagedSet) {
        isMergeEnabled = ((ManagedSet) setVal).isMergeEnabled();
    }

    ManagedSet newSet = new ManagedSet();
    newSet.setMergeEnabled(isMergeEnabled);

    for (Object elem : setVal) {
        if (hasExpression(elem)) {
            String strValue = getStringValue(elem);
            propertyExpressions.put(propertyName + ExpressionEvaluator.EMBEDDED_PROPERTY_NAME_ADD_INDICATOR,
                    strValue);
        } else {
            // process set value bean definition as a top level bean
            if ((elem instanceof BeanDefinition) || (elem instanceof BeanDefinitionHolder)) {
                String beanName = null;
                BeanDefinition beanDefinition;
                if (elem instanceof BeanDefinition) {
                    beanDefinition = (BeanDefinition) elem;
                } else {
                    beanDefinition = ((BeanDefinitionHolder) elem).getBeanDefinition();
                    beanName = ((BeanDefinitionHolder) elem).getBeanName();
                }

                processBeanDefinition(beanName, beanDefinition, beanFactory, processedBeanNames);
            }

            newSet.add(elem);
        }
    }

    // determine if we need to clear any parent expressions for this list
    if (!isMergeEnabled) {
        // clear any expressions that match the property name minus index
        Map<String, String> adjustedParentExpressions = new HashMap<String, String>();
        for (Map.Entry<String, String> parentExpression : parentPropertyExpressions.entrySet()) {
            if (!parentExpression.getKey().startsWith(
                    propertyName + ExpressionEvaluator.EMBEDDED_PROPERTY_NAME_ADD_INDICATOR)) {
                adjustedParentExpressions.put(parentExpression.getKey(), parentExpression.getValue());
            }
        }

        parentPropertyExpressions.clear();
        parentPropertyExpressions.putAll(adjustedParentExpressions);
    }

    setVal.clear();
    setVal.addAll(newSet);
}
 

import org.springframework.beans.factory.support.ManagedSet; //导入方法依赖的package包/类
private void parseLifecycleElement(Element lifecycleElement, BeanDefinitionBuilder factory) {
    if (lifecycleElement == null) {
        return;
    }

    List<Element> childElements = DomUtils.getChildElementsByTagName(lifecycleElement, "item");

    ManagedSet<BeanDefinition> items = new ManagedSet<BeanDefinition>(childElements.size());

    for (Element element : childElements) {

        BeanDefinition bd = parseItemElement(element);

        if (bd != null) {
            items.add(bd);
        }

    }

    factory.addPropertyValue("lifecycleListeners", items);
}