bean默认标签解析

小咪咪 2022-10-30 08:27 179阅读 0赞

xml解析的入口：

org.springframework.context.support.AbstractApplicationContext#refresh
    -> org.springframework.context.support.AbstractApplicationContext#obtainFreshBeanFactory
    	-> org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory
    		-> org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)

下面只会展示一些源码以及关键流程节点：

## loadBeanDefinitions ##

创建了一个XmlBeanDefinitionReader 对象，将解析XML的工作委托给他：

// org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory) 
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { 
    	// Create a new XmlBeanDefinitionReader for the given BeanFactory.
    	/** * 委托模式，委托XmlBeanDefinitionReader解析xml */
    	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    
    	// Configure the bean definition reader with this context's
    	// resource loading environment.
    	beanDefinitionReader.setEnvironment(this.getEnvironment());
    	beanDefinitionReader.setResourceLoader(this);
    	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    
    	// Allow a subclass to provide custom initialization of the reader,
    	// then proceed with actually loading the bean definitions.
    	initBeanDefinitionReader(beanDefinitionReader);
    	/** * 真正的解析 */
    	loadBeanDefinitions(beanDefinitionReader);
    }

## doLoadBeanDefinitions ##

使用JDK提供的SAX解析xml为Document对象  
：

// org.springframework.beans.factory.xml.XmlBeanDefinitionReader#doLoadBeanDefinitions
    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    		throws BeanDefinitionStoreException { 
    
    	try { 
    		// 使用JDK提供的SAX解析xml为Document对象
    		Document doc = doLoadDocument(inputSource, resource);
    		// 注册BD
    		int count = registerBeanDefinitions(doc, resource);
    ... ...
    	}

## registerBeanDefinitions ##

又使用委托模式，将从Document对象中解析BD的任务交给BeanDefinitionDocumentReader  
：

// org.springframework.beans.factory.xml.XmlBeanDefinitionReader#registerBeanDefinitions
    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { 
    	/** * 又使用委托模式，将从Document对象中解析BD的任务交给BeanDefinitionDocumentReader */
    	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    	int countBefore = getRegistry().getBeanDefinitionCount();
    	/** * @see DefaultBeanDefinitionDocumentReader#registerBeanDefinitions(org.w3c.dom.Document, org.springframework.beans.factory.xml.XmlReaderContext) */
    	documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    	return getRegistry().getBeanDefinitionCount() - countBefore;
    }

## parseBeanDefinitions ##

开始解析Bean标签：

// org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseBeanDefinitions
    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);
    	}
    }

## parseDefaultElement ##

解析默认标签  
：

// org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseDefaultElement 
    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { 
    	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { 
    		// 处理import标签
    		importBeanDefinitionResource(ele);
    	}
    	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { 
    		// 处理alias标签
    		processAliasRegistration(ele);
    	}
    	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { 
    		// 处理Bean标签
    		processBeanDefinition(ele, delegate);
    	}
    	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { 
    		// 处理beans标签
    		// recurse
    		doRegisterBeanDefinitions(ele);
    	}
    }

## parseBeanDefinitionElement ##

解析元素：

// org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionElement(org.w3c.dom.Element, java.lang.String, org.springframework.beans.factory.config.BeanDefinition)
    public AbstractBeanDefinition parseBeanDefinitionElement(
    		Element ele, String beanName, @Nullable BeanDefinition containingBean) { 
    ... ...
    	try { 
    		// GenericBeanDefinition
    		AbstractBeanDefinition bd = createBeanDefinition(className, parent);
    
    		// 解析Bean标签的属性，只是简单的将xml中属性的值设置到BD，没有任何处理逻辑
    		parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
    		// 处理Bean标签的description子标签
    		bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
    
    		// 解析子元素meta
    		parseMetaElements(ele, bd);
    		// 解析look-up子元素
    		parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
    		// 解析replaced-method子元素
    		parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
    		// 解析constructor-arg子元素
    		parseConstructorArgElements(ele, bd);
    		// 解析property子元素
    		parsePropertyElements(ele, bd);
    		// 解析qualifier子元素
    		parseQualifierElements(ele, bd);
    
    		bd.setResource(this.readerContext.getResource());
    		bd.setSource(extractSource(ele));
    
    		return bd;
    ... ...

## createBeanDefinition ##

创建GenericBeanDefinition：

// org.springframework.beans.factory.support.BeanDefinitionReaderUtils#createBeanDefinition
    public static AbstractBeanDefinition createBeanDefinition(
    		@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException { 
    
    	GenericBeanDefinition bd = new GenericBeanDefinition();
    	bd.setParentName(parentName);
    	if (className != null) { 
    		if (classLoader != null) { 
    			bd.setBeanClass(ClassUtils.forName(className, classLoader));
    		}
    		else { 
    			bd.setBeanClassName(className);
    		}
    	}
    	return bd;
    }

## parseBeanDefinitionAttributes ##

解析Bean标签的属性，只是简单的将xml中属性的值设置到BD，没有任何处理逻辑：

// org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseBeanDefinitionAttributes
    public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
    		@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) { 
    
    	if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) { 
    		error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
    	}
    	else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) { 
    		bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
    	}
    	else if (containingBean != null) { 
    		// Take default from containing bean in case of an inner bean definition.
    		bd.setScope(containingBean.getScope());
    	}
    ... ...

## parseMetaElements ##

meta子元素的的使用：

<bean id="user" class="com.morris.spring.entity.User">
    	<description>这是一个描述信息，没什么卵用</description>
    	<meta key="str" value="I'm a meta attribute."/>
    </bean>

这段代码并不会直接体现在User的属性当中，而是一个额外的声明，当需要使用里面的信息的时候可以通过BeanDefinition的getAttribute(key)方法进行获取。

public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) { 
    	NodeList nl = ele.getChildNodes();
    	for (int i = 0; i < nl.getLength(); i++) { 
    		Node node = nl.item(i);
    		if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) { 
    			Element metaElement = (Element) node;
    			String key = metaElement.getAttribute(KEY_ATTRIBUTE);
    			String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
    			BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
    			attribute.setSource(extractSource(metaElement));
    			attributeAccessor.addMetadataAttribute(attribute);
    		}
    	}
    }

## parseLookupOverrideSubElements ##

子元素lookup-method称为获取器注入，是一种特殊的方法注入，它是把一个方法声明为返回某种类型的bean，但实际要返回的bean是在配置文件里面配置的，此方法可用在设计有些可插拔的功能上，解除程序依赖，先来看下怎么使用：

// 父接口
    public interface Person { 
    	void hi();
    }
    
    // 子类
    public class Student implements Person { 
    	@Override
    	public void hi() { 
    		System.out.println("I am a student.");
    	}
    }
    
    // 调用类
    public abstract class HelloService { 
    
    	public void hi() { 
    		getPerson().hi();
    	}
    
    	public abstract Person getPerson();
    }
    
    // xml中的配置
    <bean id="student" class="com.morris.spring.entity.Student"/>
    <bean id="helloService" class="com.morris.spring.service.HelloService">
    	<lookup-method name="getPerson" bean="student"/>
    </bean>

如果有一天需要将Person的实现类替换为Teacher类，只需要新增Teacher类，并修改配置文件即可。

parseLookupOverrideSubElements()的源码如下：

// org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseLookupOverrideSubElements
    public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) { 
    	NodeList nl = beanEle.getChildNodes();
    	for (int i = 0; i < nl.getLength(); i++) { 
    		Node node = nl.item(i);
    		if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) { 
    			Element ele = (Element) node;
    			String methodName = ele.getAttribute(NAME_ATTRIBUTE);
    			String beanRef = ele.getAttribute(BEAN_ELEMENT);
    			LookupOverride override = new LookupOverride(methodName, beanRef);
    			override.setSource(extractSource(ele));
    			// loop-up元素放入的BD的overrides属性中
    			overrides.addOverride(override);
    		}
    	}
    }

## parseReplacedMethodSubElements ##

方法替换：可以在运行时用新的方法替换现有的方法。与之前的lookup-method不同的是，replaced-method不但可以动态地替换返回实体bean，而且还能动态地更改原有方法的逻辑，先来看下怎么使用：

// 原始类
    public class HiService { 
    	public void hi() { 
    		System.out.println("hi");
    	}
    }
    
    // 替换类，必须实现MethodReplacer接口
    import org.springframework.beans.factory.support.MethodReplacer;
    import java.lang.reflect.Method;
    
    public class HiReplacer implements MethodReplacer { 
    	@Override
    	public Object reimplement(Object obj, Method method, Object[] args) throws Throwable { 
    		System.out.println("hello");
    		return null;
    	}
    }
    
    // xml中的配置
    <bean id="hiReplacer" class="com.morris.spring.service.HiReplacer"/>
    <bean id="hiService" class="com.morris.spring.service.HiService">
    	<replaced-method name="hi" replacer="hiReplacer"/>
    </bean>

parseReplacedMethodSubElements()的源码如下：

// org.springframework.beans.factory.xml.BeanDefinitionParserDelegate#parseReplacedMethodSubElements
    public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) { 
    	NodeList nl = beanEle.getChildNodes();
    	for (int i = 0; i < nl.getLength(); i++) { 
    		Node node = nl.item(i);
    		if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) { 
    			Element replacedMethodEle = (Element) node;
    			String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
    			String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
    			ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
    			// Look for arg-type match elements.
    			List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);
    			for (Element argTypeEle : argTypeEles) { 
    				String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);
    				match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle));
    				if (StringUtils.hasText(match)) { 
    					replaceOverride.addTypeIdentifier(match);
    				}
    			}
    			replaceOverride.setSource(extractSource(replacedMethodEle));
    			// 解析replaced-method子元素为ReplaceOverride加入到BD的overrides属性中，与loop-up元素是同一个属性
    			overrides.addOverride(replaceOverride);
    		}
    	}
    }