Java ManagedMap類代碼示例

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
private Optional<Map<String, String>> parseProperties(Element el) {
    List<Element> propEls = subElements(el, "properties", "prop");

    if (!propEls.isEmpty()) {
        Map<String, String> props = new ManagedMap<>();

        for (Element propEl : propEls) {
            String name = propEl.getAttribute("name").trim();
            String value = getTextValue(propEl).trim();

            props.put(name, value);
        }

        return Optional.of(props);
    }

    return Optional.empty();
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
/**
 * Checks whether there are any {@link RuntimeBeanReference}s inside the Map
 * and converts it to a ManagedMap if necessary.
 * @param map the original Map
 * @return either the original map or a managed copy of it
 */
private Object manageMapIfNecessary(Map<?, ?> map) {
	boolean containsRuntimeRefs = false;
	for (Object element : map.values()) {
		if (element instanceof RuntimeBeanReference) {
			containsRuntimeRefs = true;
			break;
		}
	}
	if (containsRuntimeRefs) {
		Map<Object, Object> managedMap = new ManagedMap<Object, Object>();
		managedMap.putAll(map);
		return managedMap;
	}
	return map;
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override public void postProcessBeanFactory(
    ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
    String[] igniteConfigNames = configurableListableBeanFactory.getBeanNamesForType(IgniteConfiguration.class);
    if (igniteConfigNames.length != 1) {
        throw new IllegalArgumentException("Spring config must contain exactly one ignite configuration!");
    }
    String[] activeStoreConfigNames = configurableListableBeanFactory.getBeanNamesForType(BaseActiveStoreConfiguration.class);
    if (activeStoreConfigNames.length != 1) {
        throw new IllegalArgumentException("Spring config must contain exactly one active store configuration!");
    }
    BeanDefinition igniteConfigDef = configurableListableBeanFactory.getBeanDefinition(igniteConfigNames[0]);
    MutablePropertyValues propertyValues = igniteConfigDef.getPropertyValues();
    if (!propertyValues.contains(USER_ATTRS_PROP_NAME)) {
        propertyValues.add(USER_ATTRS_PROP_NAME, new ManagedMap());
    }
    PropertyValue propertyValue = propertyValues.getPropertyValue(USER_ATTRS_PROP_NAME);
    Map userAttrs = (Map)propertyValue.getValue();
    TypedStringValue key = new TypedStringValue(CONFIG_USER_ATTR);
    RuntimeBeanReference value = new RuntimeBeanReference(beanName);
    userAttrs.put(key, value);
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
/**
 * Checks whether there are any {@link RuntimeBeanReference}s inside the {@link Map}
 * and converts it to a {@link ManagedMap} if necessary.
 * @param map the original Map
 * @return either the original map or a managed copy of it
 */
private Object manageMapIfNecessary(Map<?, ?> map) {
	boolean containsRuntimeRefs = false;
	for (Object element : map.values()) {
		if (element instanceof RuntimeBeanReference) {
			containsRuntimeRefs = true;
			break;
		}
	}
	if (containsRuntimeRefs) {
		Map<Object, Object> managedMap = new ManagedMap<Object, Object>();
		managedMap.putAll(map);
		return managedMap;
	}
	return map;
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
@Override
public void addMapping(Element element, ManagedMap<String, Object> urlMap, ParserContext context) {
	String pathAttribute = element.getAttribute("path");
	List<String> mappings = Arrays.asList(StringUtils.tokenizeToStringArray(pathAttribute, ","));
	RuntimeBeanReference handlerReference = new RuntimeBeanReference(element.getAttribute("handler"));

	ConstructorArgumentValues cavs = new ConstructorArgumentValues();
	cavs.addIndexedArgumentValue(0, handlerReference);
	if (this.handshakeHandlerReference != null) {
		cavs.addIndexedArgumentValue(1, this.handshakeHandlerReference);
	}
	RootBeanDefinition requestHandlerDef = new RootBeanDefinition(WebSocketHttpRequestHandler.class, cavs, null);
	requestHandlerDef.setSource(context.extractSource(element));
	requestHandlerDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	requestHandlerDef.getPropertyValues().add("handshakeInterceptors", this.interceptorsList);
	String requestHandlerName = context.getReaderContext().registerWithGeneratedName(requestHandlerDef);
	RuntimeBeanReference requestHandlerRef = new RuntimeBeanReference(requestHandlerName);

	for (String mapping : mappings) {
		urlMap.put(mapping, requestHandlerRef);
	}
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
private ManagedMap<String, Object> registerHandlerMapping(Element element,
		ParserContext context, Object source) {

	RootBeanDefinition handlerMappingDef = new RootBeanDefinition(WebSocketHandlerMapping.class);

	String orderAttribute = element.getAttribute("order");
	int order = orderAttribute.isEmpty() ? DEFAULT_MAPPING_ORDER : Integer.valueOf(orderAttribute);
	handlerMappingDef.getPropertyValues().add("order", order);

	String pathHelper = element.getAttribute("path-helper");
	if (StringUtils.hasText(pathHelper)) {
		handlerMappingDef.getPropertyValues().add("urlPathHelper", new RuntimeBeanReference(pathHelper));
	}

	ManagedMap<String, Object> urlMap = new ManagedMap<String, Object>();
	urlMap.setSource(source);
	handlerMappingDef.getPropertyValues().add("urlMap", urlMap);

	registerBeanDef(handlerMappingDef, context, source);
	return urlMap;
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
protected void doParse(Element element, BeanDefinitionBuilder bean) {
    final Map<Object, Object> configuration = new ManagedMap<>();
    final Node keywordValueNode = element
        .getElementsByTagNameNS("http://xdcrafts.github.com/schema/flower", "keyword-value")
        .item(0);
    final Node predicateNode = element
        .getElementsByTagNameNS("http://xdcrafts.github.com/schema/flower", "predicate")
        .item(0);
    if (keywordValueNode != null) {
        configuration.put("keyword-value", keywordValueNode.getTextContent());
    }
    if (predicateNode != null) {
        configuration.put("predicate", new RuntimeBeanReference(predicateNode.getTextContent()));
    }
    bean
        .addPropertyReference("action", element.getAttribute("action"))
        .addPropertyValue("configuration", configuration);
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
protected void doParse(Element element, BeanDefinitionBuilder bean) {
    final ManagedMap<Object, Object> extensions = new ManagedMap<>();
    final NodeList bindingNodes = element
        .getElementsByTagNameNS("http://xdcrafts.github.com/schema/flower", "binding");
    if (bindingNodes != null && bindingNodes.getLength() != 0) {
        for (int i = 0; i < bindingNodes.getLength(); i++) {
            final Node bindingNode = bindingNodes.item(i);
            final String extension = bindingNode
                .getAttributes()
                .getNamedItem("extension")
                .getNodeValue();
            final String selector = bindingNode
                .getAttributes()
                .getNamedItem("selector")
                .getNodeValue();
            extensions.put(new RuntimeBeanReference(extension), new RuntimeBeanReference(selector));
        }
    }
    bean.addPropertyValue("extensions", extensions);
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
/**
 * Retrieves the expression graph map set on the bean with given name. If the bean has not been processed
 * by the bean factory post processor, that is done before retrieving the map
 *
 * @param parentBeanName name of the parent bean to retrieve map for (if empty a new map will be returned)
 * @param beanFactory bean factory to retrieve bean definition from
 * @param processedBeanNames set of bean names that have been processed so far
 * @return expression graph map from parent or new instance
 */
protected Map<String, String> getExpressionGraphFromParent(String parentBeanName,
        ConfigurableListableBeanFactory beanFactory, Set<String> processedBeanNames) {
    Map<String, String> expressionGraph = new HashMap<String, String>();
    if (StringUtils.isBlank(parentBeanName) || !beanFactory.containsBeanDefinition(parentBeanName)) {
        return expressionGraph;
    }

    BeanDefinition beanDefinition = beanFactory.getBeanDefinition(parentBeanName);
    if (!processedBeanNames.contains(parentBeanName)) {
        processBeanDefinition(parentBeanName, beanDefinition, beanFactory, processedBeanNames);
    }

    MutablePropertyValues pvs = beanDefinition.getPropertyValues();
    PropertyValue propertyExpressionsPV = pvs.getPropertyValue(UifPropertyPaths.EXPRESSION_GRAPH);
    if (propertyExpressionsPV != null) {
        Object value = propertyExpressionsPV.getValue();
        if ((value != null) && (value instanceof ManagedMap)) {
            expressionGraph.putAll((ManagedMap) value);
        }
    }

    return expressionGraph;
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
/**
 * Parses a list of elements into a map of beans/standard content.
 *
 * @param grandChildren - The list 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 ManagedMap parseMap(ArrayList<Element> grandChildren, Element child, BeanDefinitionBuilder parent,
        ParserContext parserContext) {
    ManagedMap map = new ManagedMap();

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

    for (int j = 0; j < grandChildren.size(); j++) {
        Object key = findKey(grandChildren.get(j), parent, parserContext);
        Object value = findValue(grandChildren.get(j), parent, parserContext);

        map.put(key, value);
    }

    return map;
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
private BeanDefinition createGroupRegistryDefinition(String name,
		Element element) {
	ManagedMap<String, BeanDefinition> ptpGroupsMap = new ManagedMap<String, BeanDefinition>();

	String currentGroupName = ParticipantsGroupRegistry.GROUPS_REGISTRY__ROOT_GROUPNAME;
	ManagedList<BeanDefinition> rootGrpParticipants = registerGroup(
			ptpGroupsMap, currentGroupName);
	processGroup(ptpGroupsMap, element, currentGroupName,
			rootGrpParticipants);

	RootBeanDefinition grpRegistryDef = new RootBeanDefinition(
			ParticipantsGroupRegistry.class);
	ConstructorArgumentValues cav = grpRegistryDef
			.getConstructorArgumentValues();
	cav.addGenericArgumentValue(ptpGroupsMap);

	return grpRegistryDef;
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
public void parseFields(Element element, RootBeanDefinition beandef, ParserContext parserContext) {
	Element fieldsele = DomUtils.getChildElementByTagName(element, FIELDS);
	if (fieldsele == null) {
		return;
	}
	List<Element> fieldlist = DomUtils.getChildElementsByTagName(fieldsele, FIELD);
	if (fieldlist.size() == 0) {
		return;
	}
	Map<String, RuntimeBeanReference> fields = new ManagedMap<String, RuntimeBeanReference>();
	String fieldname = null;
	for (Element field : fieldlist) {
		fieldname = field.getAttribute(NAME);
		if (!(StringUtils.hasLength(fieldname))) {
			System.out.println("Tag 'field' must have a 'name' attribute");
			return;
		}
		if("".equals(DomUtils.getTextValue(field))){
			fields.put(fieldname, null);
		} else {
			fields.put(fieldname, new RuntimeBeanReference(DomUtils.getTextValue(field)));
		}
	}
	beandef.getPropertyValues().addPropertyValue(FIELDS, fields);
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
private XStream createStream() {
	XStream stream = new XStream();
	stream.registerConverter(new BeanDefinitionConverter(stream.getMapper()));
	stream.registerConverter(new BeanDefinitionHolderConverter(stream.getMapper()));
	stream.registerConverter(new TypedStringValueConverter());
	stream.registerConverter(new ManagedCollectionConverter(stream.getMapper()));
	stream.registerConverter(new ManagedMapConverter(stream.getMapper()));
	stream.registerConverter(new RuntimeBeanReferenceConverter());
	stream.alias("map", ManagedMap.class);
	stream.alias("list", ManagedList.class);
	stream.alias("set", ManagedSet.class);
	stream.alias("array", ManagedArray.class);
	stream.aliasType("bean", BeanDefinition.class);
	stream.alias("bean", BeanDefinitionHolder.class);
	stream.alias("ref", RuntimeBeanReference.class);
	return stream;
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {
	ManagedMap<?, ?> map = (ManagedMap<?, ?>) source;
	for (Map.Entry<?, ?> entry : map.entrySet()) {
		writer.startNode("entry");
		writer.startNode("key");
		if (entry.getKey().getClass().equals(TypedStringValue.class)) {
			writer.startNode("value");
			writer.setValue(((TypedStringValue) entry.getKey()).getValue());
			writer.endNode();
		} else {
			writeItem(entry.getKey(), context, writer);
		}
		writer.endNode();
		if (entry.getValue().getClass().equals(TypedStringValue.class)) {
			writer.startNode("value");
			writer.setValue(((TypedStringValue) entry.getValue()).getValue());
			writer.endNode();
		} else {
			writeItem(entry.getValue(), context, writer);
		}
		writer.endNode();
	}
}
 

import org.springframework.beans.factory.support.ManagedMap; //導入依賴的package包/類
/**
 * Parses a list of elements into a map of beans/standard content.
 *
 * @param grandChildren - The list 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 ManagedMap parseMap(ArrayList<Element> grandChildren, Element child, BeanDefinitionBuilder parent,
        ParserContext parserContext) {
    ManagedMap map = new ManagedMap();
    String merge = child.getAttribute("merge");

    for (int j = 0; j < grandChildren.size(); j++) {
        Object key = findKey(grandChildren.get(j));
        Object value = findValue(grandChildren.get(j));
        map.put(key, value);
    }

    if (merge != null) {
        map.setMergeEnabled(Boolean.valueOf(merge));
    }

    return map;
}