private void parseNested(Element element, String eltType, ParserContext parserContext, BeanDefinitionBuilder builder, RedissonNamespaceParserSupport helper) { NodeList list = element.getElementsByTagNameNS( RedissonNamespaceParserSupport.REDISSON_NAMESPACE, eltType); if (list.getLength() == 1) { Element elt = (Element) list.item(0); helper.setAttribute(elt, RedissonNamespaceParserSupport.READ_WRITE_LOCK_REF_ATTRIBUTE, helper.getAttribute(element, RedissonNamespaceParserSupport.ID_ATTRIBUTE)); parserContext.getDelegate() .parseCustomElement(elt, builder.getRawBeanDefinition()); } } }
if (!isDefaultNamespace(ele)) { return parseNestedCustomElement(ele, bd); else if (nodeNameEquals(ele, BEAN_ELEMENT)) { BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd); if (nestedBd != null) { nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd); else if (nodeNameEquals(ele, REF_ELEMENT)) { refName = ele.getAttribute(PARENT_REF_ATTRIBUTE); toParent = true; if (!StringUtils.hasLength(refName)) { error("'bean' or 'parent' is required for <ref> element", ele); return null; if (!StringUtils.hasText(refName)) { error("<ref> element contains empty target attribute", ele); return null; ref.setSource(extractSource(ele)); return ref; else if (nodeNameEquals(ele, IDREF_ELEMENT)) { return parseIdRefElement(ele); else if (nodeNameEquals(ele, VALUE_ELEMENT)) { return parseValueElement(ele, defaultValueType);
NodeList nl = ele.getChildNodes(); Element subElement = null; for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) && !nodeNameEquals(node, META_ELEMENT)) { error(elementName + " must not contain more than one sub-element", ele); boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE); boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE); if ((hasRefAttribute && hasValueAttribute) || ((hasRefAttribute || hasValueAttribute) && subElement != null)) { error(elementName + " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele); String refName = ele.getAttribute(REF_ATTRIBUTE); if (!StringUtils.hasText(refName)) { error(elementName + " contains empty 'ref' attribute", ele); ref.setSource(extractSource(ele)); return ref; TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE)); valueHolder.setSource(extractSource(ele)); return valueHolder; return parsePropertySubElement(subElement, bd);
protected BeanDefinitionParserDelegate createDelegate( XmlReaderContext readerContext, Element root, @Nullable BeanDefinitionParserDelegate parentDelegate) { BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext); delegate.initDefaults(root, parentDelegate); return delegate; }
protected void parseCollectionElements( NodeList elementNodes, Collection<Object> target, @Nullable BeanDefinition bd, String defaultElementType) { for (int i = 0; i < elementNodes.getLength(); i++) { Node node = elementNodes.item(i); if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) { target.add(parsePropertySubElement((Element) node, bd, defaultElementType)); } } }
/** * Parse the elements at the root level in the document: * "import", "alias", "bean". * @param root the DOM root element of the document */ protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { if (delegate.isDefaultNamespace(root)) { NodeList nl = root.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element) { Element ele = (Element) node; if (delegate.isDefaultNamespace(ele)) { parseDefaultElement(ele, delegate); } else { delegate.parseCustomElement(ele); } } } } else { delegate.parseCustomElement(root); } }
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(); AbstractBeanDefinition bd = builder.getRawBeanDefinition(); NodeList children = stepElement.getChildNodes(); String name = nestedElement.getLocalName(); bd.setDescription(nestedElement.getTextContent()); BeanDefinitionHolder holder = parserContext.getDelegate().parseBeanDefinitionElement(nestedElement); value = parserContext.getDelegate().decorateBeanDefinitionIfRequired(nestedElement, holder); value = parserContext.getDelegate().parseCustomElement(nestedElement); bd.setBeanClass(StepParserStepFactoryBean.class); bd.setAttribute("isNamespaceStep", true); builder.addPropertyValue("tasklet", value); String parentRef = stepElement.getAttribute(PARENT_ATTR); if (StringUtils.hasText(parentRef)) { bd.setParentName(parentRef); String isAbstract = stepElement.getAttribute("abstract"); if (StringUtils.hasText(isAbstract)) { bd.setAbstract(Boolean.valueOf(isAbstract));
@Override protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { Map<Object, Object> parsedMap = parserContext.getDelegate().parseMapElement(element, builder.getRawBeanDefinition()); builder.addPropertyValue("sourceMap", parsedMap); String mapClass = element.getAttribute("map-class"); if (StringUtils.hasText(mapClass)) { builder.addPropertyValue("targetMapClass", mapClass); } String scope = element.getAttribute(SCOPE_ATTRIBUTE); if (StringUtils.hasLength(scope)) { builder.setScope(scope); } } }
@Override protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { List<Object> parsedList = parserContext.getDelegate().parseListElement(element, builder.getRawBeanDefinition()); builder.addPropertyValue("sourceList", parsedList); String listClass = element.getAttribute("list-class"); if (StringUtils.hasText(listClass)) { builder.addPropertyValue("targetListClass", listClass); } String scope = element.getAttribute(SCOPE_ATTRIBUTE); if (StringUtils.hasLength(scope)) { builder.setScope(scope); } } }
@Override @Nullable public BeanDefinition parse(Element element, ParserContext context) { context.pushContainingComponent( new CompositeComponentDefinition(element.getTagName(), context.extractSource(element))); if (element.hasAttribute("path-matcher")) { pathMatcherRef = new RuntimeBeanReference(element.getAttribute("path-matcher")); List<Element> interceptors = DomUtils.getChildElementsByTagName(element, "bean", "ref", "interceptor"); for (Element interceptor : interceptors) { RootBeanDefinition mappedInterceptorDef = new RootBeanDefinition(MappedInterceptor.class); mappedInterceptorDef.setSource(context.extractSource(interceptor)); mappedInterceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); includePatterns = getIncludePatterns(interceptor, "mapping"); excludePatterns = getIncludePatterns(interceptor, "exclude-mapping"); Element beanElem = DomUtils.getChildElementsByTagName(interceptor, "bean", "ref").get(0); interceptorBean = context.getDelegate().parsePropertySubElement(beanElem, null); interceptorBean = context.getDelegate().parsePropertySubElement(interceptor, null);
@Override @Nullable public BeanDefinition parse(Element element, ParserContext parserContext) { CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element)); parserContext.pushContainingComponent(compositeDef); MutablePropertyValues commonProperties = parseCommonContainerProperties(element, parserContext); MutablePropertyValues specificProperties = parseSpecificContainerProperties(element, parserContext); String factoryId = element.getAttribute(FACTORY_ID_ATTRIBUTE); if (StringUtils.hasText(factoryId)) { RootBeanDefinition beanDefinition = createContainerFactory( factoryId, element, parserContext, commonProperties, specificProperties); if (beanDefinition != null) { beanDefinition.setSource(parserContext.extractSource(element)); parserContext.registerBeanComponent(new BeanComponentDefinition(beanDefinition, factoryId)); } } NodeList childNodes = element.getChildNodes(); for (int i = 0; i < childNodes.getLength(); i++) { Node child = childNodes.item(i); if (child.getNodeType() == Node.ELEMENT_NODE) { String localName = parserContext.getDelegate().getLocalName(child); if (LISTENER_ELEMENT.equals(localName)) { parseListener(element, (Element) child, parserContext, commonProperties, specificProperties); } } } parserContext.popAndRegisterContainingComponent(); return null; }
protected List parseNestedProcessorAsList(Element element, ParserContext parserContext, Class factory) { BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(factory); BeanDefinition beanDefinition = builder.getBeanDefinition(); parserContext.getRegistry().registerBeanDefinition(generateChildBeanName(element), beanDefinition); element.setAttribute("name", generateChildBeanName(element)); builder.setSource(parserContext.extractSource(element)); builder.setScope(BeanDefinition.SCOPE_SINGLETON); List list = parserContext.getDelegate().parseListElement(element, builder.getBeanDefinition()); parserContext.getRegistry().removeBeanDefinition(generateChildBeanName(element)); return list; }
public final BeanDefinition parse(Element element, ParserContext parserContext) { AbstractBeanDefinition definition = parseInternal(element, parserContext); if (definition != null && !parserContext.isNested()) { try { String id = resolveId(element, definition, parserContext); if (!StringUtils.hasText(id)) { parserContext.getReaderContext().error( "Id is required for element '" + parserContext.getDelegate().getLocalName(element) + "' when used as a top-level tag", element); String name = element.getAttribute(NAME_ATTRIBUTE); if (StringUtils.hasLength(name)) { aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));
@Override protected void parseNested(Element element, ParserContext parserContext, BeanDefinitionBuilder builder, BeanDefinition bd) { bd.setDependsOn(element.getAttribute( RedissonNamespaceParserSupport.REDISSON_REF_ATTRIBUTE)); List<Element> childElements = DomUtils.getChildElements(element); for (Element elt : childElements) { String localName = elt.getLocalName(); if (BeanDefinitionParserDelegate .QUALIFIER_ELEMENT.equals(localName)) { id = elt.getAttribute( BeanDefinitionParserDelegate.BEAN_REF_ATTRIBUTE); } else { parserContext.getDelegate().parseCustomElement(elt, bd); id = elt.getAttribute( RedissonNamespaceParserSupport.ID_ATTRIBUTE); = builder.getRawBeanDefinition() .getConstructorArgumentValues(); if (args.getArgumentCount() > 0) { builder.addConstructorArgReference(id);
@Nullable 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; }
boolean isAbstract = false; boolean publish = true; NamedNodeMap atts = element.getAttributes(); String bus = element.getAttribute("bus"); if (StringUtils.isEmpty(bus)) { addBusWiringAttribute(bean, BusWiringType.CONSTRUCTOR); } else { bean.addConstructorArgReference(bus); String name = elem.getLocalName(); if ("properties".equals(name)) { Map<?, ?> map = ctx.getDelegate().parseMapElement(elem, bean.getBeanDefinition()); bean.addPropertyValue("properties", map); } else if ("binding".equals(name)) { || "features".equals(name) || "schemaLocations".equals(name) || "handlers".equals(name)) { List<?> list = ctx.getDelegate().parseListElement(elem, bean.getBeanDefinition()); bean.addPropertyValue(name, list); } else if (IMPLEMENTOR.equals(name)) { ctx.getDelegate() .parseConstructorArgElement(elem, bean.getBeanDefinition()); } else { setFirstChildAsProperty(elem, ctx, bean, name);
public static BeanMetadataElement parseListenerElement(Element element, ParserContext parserContext, BeanDefinition enclosing) { String listenerRef = element.getAttribute(REF_ATTR); List<Element> beanElements = DomUtils.getChildElementsByTagName(element, BEAN_ELE); List<Element> refElements = DomUtils.getChildElementsByTagName(element, REF_ELE); verifyListenerAttributesAndSubelements(listenerRef, beanElements, refElements, element, parserContext); if (StringUtils.hasText(listenerRef)) { return new RuntimeBeanReference(listenerRef); } else if (beanElements.size() == 1) { Element beanElement = beanElements.get(0); BeanDefinitionHolder beanDefinitionHolder = parserContext.getDelegate().parseBeanDefinitionElement( beanElement, enclosing); parserContext.getDelegate().decorateBeanDefinitionIfRequired(beanElement, beanDefinitionHolder); return beanDefinitionHolder; } else { return (BeanMetadataElement) parserContext.getDelegate().parsePropertySubElement(refElements.get(0), null); } }
static void parseAndPopulateNamespaceMap(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { String nsPrefix = element.getAttribute("ns-prefix"); String nsUri = element.getAttribute("ns-uri"); String namespaceMapRef = element.getAttribute("namespace-map"); List<Element> mapElements = DomUtils.getChildElementsByTagName(element, "map"); boolean prefixProvided = StringUtils.hasText(nsPrefix); boolean namespaceProvided = StringUtils.hasText(nsUri); boolean namespaceMapProvided = StringUtils.hasText(namespaceMapRef); Map<String, String> namespaceMap = new HashMap<String, String>(1); namespaceMap.put(nsPrefix, nsUri); builder.addConstructorArgValue(namespaceMap); builder.addConstructorArgReference(namespaceMapRef); BeanDefinitionParserDelegate beanParser = parserContext.getDelegate(); beanParser.initDefaults(mapElement.getOwnerDocument().getDocumentElement(), beanParser); builder.addConstructorArgValue(beanParser.parseMapElement(mapElement, builder.getRawBeanDefinition()));
@Override protected AbstractBeanDefinition parseConsumer(Element element, ParserContext parserContext) { BeanDefinitionBuilder cacheWritingMessageHandler = BeanDefinitionBuilder.genericBeanDefinition( CacheWritingMessageHandler.class); if (!element.hasAttribute(REGION_ATTRIBUTE)) { parserContext.getReaderContext().error("'region' attribute is required.", element); } cacheWritingMessageHandler.addConstructorArgReference(element.getAttribute(REGION_ATTRIBUTE)); Element cacheEntries = DomUtils.getChildElementByTagName(element, CACHE_ENTRIES_ELEMENT); if (cacheEntries != null) { Map<?, ?> map = parserContext.getDelegate() .parseMapElement(cacheEntries, cacheWritingMessageHandler.getBeanDefinition()); cacheWritingMessageHandler.addPropertyValue(CACHE_ENTRIES_PROPERTY, map); } return cacheWritingMessageHandler.getBeanDefinition(); } }
String id = ele.getAttribute(ID_ATTRIBUTE); String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); if (StringUtils.hasLength(nameAttr)) { String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS); aliases.addAll(Arrays.asList(nameArr)); if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) { beanName = aliases.remove(0); if (logger.isTraceEnabled()) { checkNameUniqueness(beanName, aliases, ele); AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); if (beanDefinition != null) { if (!StringUtils.hasText(beanName)) { error(ex.getMessage(), ele); return null;