Spring源码学习--解析BeanDefinition
loadBeanDefinitions解析流程
1.XmlBeanDefinitionReader
|—— 1）通过流的方式解析xml文件，并封装成inputResource对象
|—— 2）通过jdk的dom4j解析xml，并封装成document对象
|—— 3）registerBeanDefinitions()
|———— createBeanDefinitionDocumentReader()获取BeanDefinitionDocumentReader对象，该对象负责对document对象进行解析
|———— documentReader.registerBeanDefinitions对document对象解析并把解析的标签封装成BeanDefinition
|—————— parseDefaultElement默认标签解析
|———————— import
|———————— alias
|———————— bean
|———————— beans
|—————— delegate.parseCustomElement 自定义标签解析
|———————— getNamespaceURI(ele) 获取namespace
|—————————— http://www.springframework.org/schema/context
|———————— NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri)
|—————————— 获取NamespaceHandler对象
|—————————— PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation , this.classLoader)； 获取uri 和 NamespaceHandler的映射
|———————————— 扫描jar报里面所有的META-INF/spring.handlers文件
|—————————— handlerMappings.get(namespaceUri) 根据namespaceUri 获取NamespaceHandler对象
|—————————— Class handlerClass = ClassUtils.forName(className , this.classLoader) 反射获取Namespace实例
|—————————— namespaceHandler.init() ; 调用对应的init方法
|—————————— 返回NamespaceHandler对象
|———————— handler.parse(ele , new ParserContext(this.readerContext , this , containingBd)) 调用parse方法，解析自定义标签
解析默认标签是由 DefaultBeanDefinitionDocumentReader的parseDefaultElement()方法去解析的，分别解析（import、alias、bean和beans）4种标签
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, "import")) {
this.importBeanDefinitionResource(ele);
} else if (delegate.nodeNameEquals(ele, "alias")) {
this.processAliasRegistration(ele);
} else if (delegate.nodeNameEquals(ele, "bean")) {
this.processBeanDefinition(ele, delegate);
} else if (delegate.nodeNameEquals(ele, "beans")) {
this.doRegisterBeanDefinitions(ele);
}
}
解析默认标签
bean标签的解析，是最复杂，也是最重要的
首先进入this.processBeanDefinition(ele, delegate) 方法
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 进行元素解析，返回BeanDefinitionHolder实例
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
// 不为空的情况
if (bdHolder != null) {
// 判断默认标签中的子节点是否在有自定义属性
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 对解析后的bdHolder进行注册
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
} catch (BeanDefinitionStoreException var5) {
this.getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, var5);
}
// 发出响应，告诉这个bean已经加载完成了
this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
对应的时序图
1. 解析Bean标签 （最重要）
根据上面代码，先从元素解析开始，也就是
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
// 解析id属性
String id = ele.getAttribute("id");
// 解析name属性
String nameAttr = ele.getAttribute("name");
List<String> aliases = new ArrayList();
if (StringUtils.hasLength(nameAttr)) {
// 将name属性 用,;来分割，并转成list集合
// ps:tokenizeToStrignArray跟split功能一样，但能自动去掉空白的单词
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, ",; ");
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
// 如果没有定义id属性，并且name集合不为null，获取第一个name来当beanName
if (!StringUtils.hasText(id) && !aliases.isEmpty()) {
beanName = (String)aliases.remove(0);
if (this.logger.isTraceEnabled()) {
this.logger.trace("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
// 判断这个beanName在容器中是否已经存在了
this.checkNameUniqueness(beanName, aliases, ele);
}
// 解析其他属性，并封装到实现类GenericBGeanDefinition实现类的实例中
AbstractBeanDefinition beanDefinition = this.parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
try {
// 如果没有定义beanName，则根据Spring中提供的命名规则为当前bean生成对应的beanName
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);
} else {
beanName = this.readerContext.generateBeanName(beanDefinition);
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() && !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
aliases.add(beanClassName);
}
}
if (this.logger.isTraceEnabled()) {
this.logger.trace("Neither XML 'id' nor 'name' specified - using generated bean name [" + beanName + "]");
}
} catch (Exception var9) {
this.error(var9.getMessage(), ele);
return null;
}
}
String[] aliasesArray = StringUtils.toStringArray(aliases);
// 将获取到的信息，封装到BeanDefinitionHolder实例中
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
} else {
return null;
}
}
上面的代码可以概括为
- 1）提取元素中的id以及name属性
- 2）进一步解析其他所有属性并统一封装到GenericBeanDefinition类型的实例中
- 3）如果检测到bean没有指定beanName，那么使用默认规则为该Bean生成beanName
- 4）将获取到的信息封装到BeanDefinitionHolder的实例中
进一步查看第2步的解析过程
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
// 解析class属性
if (ele.hasAttribute("class")) {
className = ele.getAttribute("class").trim();
}
String parent = null;
// 解析parent属性
if (ele.hasAttribute("parent")) {
parent = ele.getAttribute("parent");
}
try {
// 创建GenericBeanDefinition来封装属性
AbstractBeanDefinition bd = this.createBeanDefinition(className, parent);
// 解析bean的各种属性
this.parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
// 提取description
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, "description"));
// 解析元数据
this.parseMetaElements(ele, bd);
// 解析lookup-method属性
this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
// 解析replaced-method属性
this.parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
// 解析构造函数参数
this.parseConstructorArgElements(ele, bd);
// 解析property子元素
this.parsePropertyElements(ele, bd);
// 解析qualifier子元素
this.parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(this.extractSource(ele));
AbstractBeanDefinition var7 = bd;
return var7;
} catch (ClassNotFoundException var13) {
this.error("Bean class [" + className + "] not found", ele, var13);
} catch (NoClassDefFoundError var14) {
this.error("Class that bean class [" + className + "] depends on not found", ele, var14);
} catch (Throwable var15) {
this.error("Unexpected failure during bean definition parsing", ele, var15);
} finally {
this.parseState.pop();
}
return null;
}
1.1.创建用于属性承载的BeanDefinitin
BeanDefinition是一个接口，在Spring中有三种实现：RootBeanDefinition、ChildBeanDefinition、GenericBeanDefinition。三种都继承了AbstractBeanDefinition
一般来说父<bean>用RootBeanDefinition表示，子<bean>用ChildBeanDefinition表示
RootBeanDefinition： 可以单独作为一个BeanDefinition ，不可以设置parentName，设置了会报错
ChildBeanDefinition：不可以单独作为一个类，创建时必须指定parentName，在构造的时候传入进去
其中BeanDefinition是配置文件<bean>元素标签在容器中的内部表现形式。<bean>元素标签拥有class、scope、lazy-init等配置属性，BeanDefinition则提供了响应的beanClass、scope、lazyInit属性，是一一对应的。并注册到BeanDefinitionRegistry中。
BeanDefinitionRegistry就像是Spring配置信息的内存数据库，主要是以map的形式保存，后续操作直接从BeanDefinitionRegistry中读取配置信息。
上面代码可以看到，要解析属性，首先要创建承载属性的实例方法，就是createBeanDefinition(className, parent)
protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName) throws ClassNotFoundException {
return BeanDefinitionReaderUtils.createBeanDefinition(parentName, className, this.readerContext.getBeanClassLoader());
}
BeanDefinitionReaderUtils
public static AbstractBeanDefinition createBeanDefinition(@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
GenericBeanDefinition bd = new GenericBeanDefinition();
// parentName可能为null
bd.setParentName(parentName);
if (className != null) {
if (classLoader != null) {
// 如果classLoader不为空，则使用已传入的classLoader同一虚拟机加载类对象，否则只是记录className
bd.setBeanClass(ClassUtils.forName(className, classLoader));
} else {
bd.setBeanClassName(className);
}
}
return bd;
}
1.2 解析各种属性
创建完bean后，就能对bean信息的各种属性解析。
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd) 这个方法是对ele所有元素属性进行解析
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName, @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
// 后面把singleton = "true" 改成了 scope = "singleton" ,所以废弃了 singleton这个属性
if (ele.hasAttribute("singleton")) {
this.error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
// 解析scope属性
} else if (ele.hasAttribute("scope")) {
bd.setScope(ele.getAttribute("scope"));
} else if (containingBean != null) {
// 没有定义scope的话，默认使用父类的scope
bd.setScope(containingBean.getScope());
}
// 解析abstract属性
if (ele.hasAttribute("abstract")) {
bd.setAbstract("true".equals(ele.getAttribute("abstract")));
}
// 解析lazy-init属性
String lazyInit = ele.getAttribute("lazy-init");
if (this.isDefaultValue(lazyInit)) {
lazyInit = this.defaults.getLazyInit();
}
// 如果没有设置或者设置成其他字符都会被设置为false
bd.setLazyInit("true".equals(lazyInit));
// 解析autowire属性
String autowire = ele.getAttribute("autowire");
bd.setAutowireMode(this.getAutowireMode(autowire));
String autowireCandidate;
// 解析depends-on属性
if (ele.hasAttribute("depends-on")) {
autowireCandidate = ele.getAttribute("depends-on");
bd.setDependsOn(StringUtils.tokenizeToStringArray(autowireCandidate, ",; "));
}
// 解析autowire-candidate属性
autowireCandidate = ele.getAttribute("autowire-candidate");
String destroyMethodName;
if (this.isDefaultValue(autowireCandidate)) {
destroyMethodName = this.defaults.getAutowireCandidates();
if (destroyMethodName != null) {
String[] patterns = StringUtils.commaDelimitedListToStringArray(destroyMethodName);
bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
}
} else {
bd.setAutowireCandidate("true".equals(autowireCandidate));
}
// 解析primary属性
if (ele.hasAttribute("primary")) {
bd.setPrimary("true".equals(ele.getAttribute("primary")));
}
// init-method
if (ele.hasAttribute("init-method")) {
destroyMethodName = ele.getAttribute("init-method");
bd.setInitMethodName(destroyMethodName);
} else if (this.defaults.getInitMethod() != null) {
bd.setInitMethodName(this.defaults.getInitMethod());
bd.setEnforceInitMethod(false);
}
// destroy-method
if (ele.hasAttribute("destroy-method")) {
destroyMethodName = ele.getAttribute("destroy-method");
bd.setDestroyMethodName(destroyMethodName);
} else if (this.defaults.getDestroyMethod() != null) {
bd.setDestroyMethodName(this.defaults.getDestroyMethod());
bd.setEnforceDestroyMethod(false);
}
// factory-method
if (ele.hasAttribute("factory-method")) {
bd.setFactoryMethodName(ele.getAttribute("factory-method"));
}
// factory-bean
if (ele.hasAttribute("factory-bean")) {
bd.setFactoryBeanName(ele.getAttribute("factory-bean"));
}
return bd;
}
1.3 解析子元素meta
元数据是定义一个额外的声明，例如：
<bean id="myTestBean" class="bean.TestBean" >
<meta key="testStr" value="aaaaaa" />
</bean>
public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
// 获取当前节点的所有子元素
NodeList nl = ele.getChildNodes();
for(int i = 0; i < nl.getLength(); ++i) {
Node node = nl.item(i);
// 判断是否有meta标签
if (this.isCandidateElement(node) && this.nodeNameEquals(node, "meta")) {
Element metaElement = (Element)node;
String key = metaElement.getAttribute("key");
String value = metaElement.getAttribute("value");
// 使用key、value构造BeanMetadataAttribute
BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
attribute.setSource(this.extractSource(metaElement));
// 记录信息
attributeAccessor.addMetadataAttribute(attribute);
}
}
}
1.4 解析子元素 lookup-method
一个抽象方法声明返回某种bean，其实现是通过配置来实现的
作用：动态替换实体bean
<!-- 将student的实体类传入到TestBean中的属性 -->
<bean id="getLookupTestBean" class="test.lookup.TestBean">
<lookup-method name="getBean" bean="student" />
</bean>
<bean id="student" class="test.pojo.Student">
</bean>
public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
NodeList nl = beanEle.getChildNodes();
for(int i = 0; i < nl.getLength(); ++i) {
Node node = nl.item(i);
// 仅当在Spring默认bean的子元素下，且为<lookup-method>时 有效
if (this.isCandidateElement(node) && this.nodeNameEquals(node, "lookup-method")) {
Element ele = (Element)node;
// 获取要装饰的方法
String methodName = ele.getAttribute("name");
// 获取配置返回的bean
String beanRef = ele.getAttribute("bean");
LookupOverride override = new LookupOverride(methodName, beanRef);
override.setSource(this.extractSource(ele));
overrides.addOverride(override);
}
}
}
代码跟解析元数据 parseMetaElements的代码大同小区，区别就是if判断还有承载的实体类不同
1.5 解析子元素replaced-method
作用：运行时，用新方法替换现有的方法。
使用方式：创建一个类，实现MethodReplacer接口，并在reimplement方法中，写新方法的逻辑即可
// 要被替换的方法的bean
<bean id="testChangeMethod" class="test.replacementhod.TestChangeMethod">
<replaced-method name="changeMe" replacer="replacer" />
</bean>
// 新方法的bean
<bean id="replacer" class="test.replacemtthod.TestMethodReplacer" />
public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
NodeList nl = beanEle.getChildNodes();
for(int i = 0; i < nl.getLength(); ++i) {
Node node = nl.item(i);
// 仅当在Spring默认的bean的子元素下，切为<replaced-method>时有效
if (this.isCandidateElement(node) && this.nodeNameEquals(node, "replaced-method")) {
Element replacedMethodEle = (Element)node;
// 提取要替换的旧方法
String name = replacedMethodEle.getAttribute("name");
// 提取对应的新的方法
String callback = replacedMethodEle.getAttribute("replacer");
ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, "arg-type");
Iterator var11 = argTypeEles.iterator();
while(var11.hasNext()) {
Element argTypeEle = (Element)var11.next();
// 记录参数
String match = argTypeEle.getAttribute("match");
match = StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle);
if (StringUtils.hasText(match)) {
replaceOverride.addTypeIdentifier(match);
}
}
replaceOverride.setSource(this.extractSource(replacedMethodEle));
overrides.addOverride(replaceOverride);
}
}
}
1.6 解析子元素constructor-arg
作用：选择一个构造函数来实例化该bean
parseConstructorArgElements方法
public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
NodeList nl = beanEle.getChildNodes();
for(int i = 0; i < nl.getLength(); ++i) {
Node node = nl.item(i);
if (this.isCandidateElement(node) && this.nodeNameEquals(node, "constructor-arg")) {
this.parseConstructorArgElement((Element)node, bd);
}
}
}
parseConstructorArgElement方法
public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
String indexAttr = ele.getAttribute("index");
String typeAttr = ele.getAttribute("type");
String nameAttr = ele.getAttribute("name");
// 有指定index属性的情况下
if (StringUtils.hasLength(indexAttr)) {
try {
int index = Integer.parseInt(indexAttr);
if (index < 0) {
this.error("'index' cannot be lower than 0", ele);
} else {
try {
this.parseState.push(new ConstructorArgumentEntry(index));
// 解析constructor-arg的子元素
Object value = this.parsePropertyValue(ele, bd, (String)null);
// 使用ValueHolder类型来封装解析出来的元素
ValueHolder valueHolder = new ValueHolder(value);
if (StringUtils.hasLength(typeAttr)) {
valueHolder.setType(typeAttr);
}
if (StringUtils.hasLength(nameAttr)) {
valueHolder.setName(nameAttr);
}
valueHolder.setSource(this.extractSource(ele));
// 判断该index值是否有设置过，不允许指定相同的index值
if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {
this.error("Ambiguous constructor-arg entries for index " + index, ele);
} else {
// 将ValueHolder添加到当前BeanDefinition的constructorArgumentValues的indexedArgumentvalues属性中
bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
}
} finally {
this.parseState.pop();
}
}
} catch (NumberFormatException var19) {
this.error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
}
// 没有指定index属性的情况下
} else {
try {
this.parseState.push(new ConstructorArgumentEntry());
// 解析constructor-arg的子元素
Object value = this.parsePropertyValue(ele, bd, (String)null);
// 使用ValueHolder类型来封装解析出来的元素
ValueHolder valueHolder = new ValueHolder(value);
if (StringUtils.hasLength(typeAttr)) {
valueHolder.setType(typeAttr);
}
if (StringUtils.hasLength(nameAttr)) {
valueHolder.setName(nameAttr);
}
valueHolder.setSource(this.extractSource(ele));
// 将ValueHolder添加到当前BeanDefinition的constructorArgumentValues的genericArgumentValue属性中
bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
} finally {
this.parseState.pop();
}
}
}
parsePropertyValue方法
public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
String elementName = propertyName != null ? "<property> element for property '" + propertyName + "'" : "<constructor-arg> element";
NodeList nl = ele.getChildNodes();
Element subElement = null;
// constructor-arg里面，一次只能有一种类型:如ref 、 value、 list等
for(int i = 0; i < nl.getLength(); ++i) {
Node node = nl.item(i);
// 不处理 description和meta元素
if (node instanceof Element && !this.nodeNameEquals(node, "description") && !this.nodeNameEquals(node, "meta")) {
if (subElement != null) {
this.error(elementName + " must not contain more than one sub-element", ele);
} else {
subElement = (Element)node;
}
}
}
boolean hasRefAttribute = ele.hasAttribute("ref");
boolean hasValueAttribute = ele.hasAttribute("value");
// 不允许同时配置ref和value两种
if (hasRefAttribute && hasValueAttribute || (hasRefAttribute || hasValueAttribute) && subElement != null) {
this.error(elementName + " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
}
if (hasRefAttribute) {
String refName = ele.getAttribute("ref");
if (!StringUtils.hasText(refName)) {
this.error(elementName + " contains empty 'ref' attribute", ele);
}
// 配置的是ref，使用RuntimeBeanReference封装对应的ref名称
// <constructor-arg ref="xxx" />
RuntimeBeanReference ref = new RuntimeBeanReference(refName);
ref.setSource(this.extractSource(ele));
return ref;
} else if (hasValueAttribute) {
// 配置的是value，使用TypeStringValue封装
// <constructor-arg value="xxx" />
TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute("value"));
valueHolder.setSource(this.extractSource(ele));
return valueHolder;
} else if (subElement != null) {
// 解析子元素
/*
<constructor-arg>
<map>
<entry key="key" value="value" />
</map>
</constructor-arg>
*/
return this.parsePropertySubElement(subElement, bd);
} else {
// 啥都没配，不知道怎么操作，直接抛异常
this.error(elementName + " must specify a ref or value", ele);
return null;
}
}
1.7 解析子元素property
<bean id="test" class="test.TestClass">
<property name=testStr" value="aaa" />
</bean>
--------------
<bean id="a">
<property name="p">
<list>
<value>aa</value>
<value>bb</value>
</list>
</property>
</bean>
public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
NodeList nl = beanEle.getChildNodes();
for(int i = 0; i < nl.getLength(); ++i) {
Node node = nl.item(i);
if (this.isCandidateElement(node) && this.nodeNameEquals(node, "property")) {
this.parsePropertyElement((Element)node, bd);
}
}
}
public void parsePropertyElement(Element ele, BeanDefinition bd) {
String propertyName = ele.getAttribute("name");
if (!StringUtils.hasLength(propertyName)) {
this.error("Tag 'property' must have a 'name' attribute", ele);
} else {
this.parseState.push(new PropertyEntry(propertyName));
try {
// 不允许多次配置同一属性
if (bd.getPropertyValues().contains(propertyName)) {
this.error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
return;
}
// 解析元素，并使用PropertyValue进行封装，然后放入到BeanDefinition中
Object val = this.parsePropertyValue(ele, bd, propertyName);
PropertyValue pv = new PropertyValue(propertyName, val);
this.parseMetaElements(ele, pv);
pv.setSource(this.extractSource(ele));
bd.getPropertyValues().addPropertyValue(pv);
} finally {
this.parseState.pop();
}
}
}
2.解析import标签
3.解析alias标签
4.解析beans标签
解析自定义标签
1.获取配置文件中，自定义标签的namespace 的命名空间，如
http://www.springframework.org/schema/context
2.根据命名空间获取NamespaceHandler对象
NamespaceUri和NamespaceHandler之前会建立一个映射，spring会从所有的spring jar包中扫描spring.handlers文件，建立映射关系，文件地址在 src/resources/META-INF 目录下面
3.反射获取NamespaceHandler实例
4.调用init方法
5.调用parse方法
parseCustomElement()
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
String namespaceUri = getNamespaceURI(ele);
if (namespaceUri == null) {
return null;
}
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler == null) {
error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
return null;
}
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}
resolve()
public NamespaceHandler resolve(String namespaceUri) {
//获取spring中所有jar包里面的 "META-INF/spring.handlers"文件，并且建立映射关系
Map<String, Object> handlerMappings = getHandlerMappings();
//根据namespaceUri：http://www.springframework.org/schema/p，获取到这个命名空间的处理类
Object handlerOrClassName = handlerMappings.get(namespaceUri);
if (handlerOrClassName == null) {
return null;
}
else if (handlerOrClassName instanceof NamespaceHandler) {
return (NamespaceHandler) handlerOrClassName;
}
else {
String className = (String) handlerOrClassName;
try {
Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
}
NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
//调用处理类的init方法，在init方法中完成标签元素解析类的注册
namespaceHandler.init();
handlerMappings.put(namespaceUri, namespaceHandler);
return namespaceHandler;
}
catch (ClassNotFoundException ex) {
throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
"] for namespace [" + namespaceUri + "]", ex);
}
catch (LinkageError err) {
throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
className + "] for namespace [" + namespaceUri + "]", err);
}
}
}
init()方法
ContextNamespaceHandler
public class ContextNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init() {
registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
}
}
进入到 ComponentScanBeanDefinitionParser 这个类，找到parse方法
parse()
public BeanDefinition parse(Element element, ParserContext parserContext) {
// 获取basePackage属性
String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
// 可以用逗号分开
String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
// 创建注解扫描器
// Actually scan for bean definitions and register them.
ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
// 扫描并把扫描的类封装成beanDefinition对象
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
// 在这里，注册了很多有用的BeanPostProcessor类
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
return null;
}
doScan ()
1.循环扫描basePackages，获取每一个basePackage
2.递归寻找basePackage中的每一个bean，封装成BeanDefination，存放到Set中
3.判断是否有@Lazy、@DependOn注解
4.将BeanDefinition封装成BeanDefinitionHolder
5.将BeanDefinitionHolder注册进spring容器，步骤跟xml解析一样
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
for (String basePackage : basePackages) {
//扫描到有注解的类并封装成BeanDefinition对象
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
//支持了@Lazy @DependOn注解
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//BeanDefinition注册
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
registerComponents ()
这个方法，主要就是注解几个重要的BeanPostProcessor类
ConfigurationClassPostProcessor
AutowiredAnnotationBeanPostProcessor
CommonAnnotationBeanPostProcessor
这几个类就在这里注册的
protected void registerComponents(
XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {
Object source = readerContext.extractSource(element);
CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);
for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
}
// Register annotation config processors, if necessary.
boolean annotationConfig = true;
if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
}
if (annotationConfig) {
//这里稍微看一下，注册了几个比较重要的BeanPostProcessor类
//AutowiredAnnotationBeanPostProcessor,ConfigurationClassPostProcessor,CommonAnnotationBeanPostProcessor
Set<BeanDefinitionHolder> processorDefinitions =
AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
}
}
readerContext.fireComponentRegistered(compositeDef);
}
261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
