这一切都要从连跪开始,白银守门员
现在所有关于spring的文章,后面都会重新进行整理,这里只是做个记录。直到我熟悉完ioc,我会把之前的文章都串起来。
解析xml标签要从DefaultBeanDefinitionDocumentReader这个类中的 parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)方法讲起了。具体如下:
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
// import 标签
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
// alias 标签
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
// bean 标签
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
/**
* 重点看一下bean标签的解析
*/
processBeanDefinition(ele, delegate);
}
// beans 标签
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
可以看出就是对import,alias,bean,beans四个标签进行处理,我们重点看这个bean标签的解析,其它的应该就会迎刃而解。代码如下:
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
/**
* 将 <bean /> 节点中的信息提取出来,然后封装到一个 BeanDefinitionHolder 中
* Property bean中的属性定义
* class 类的全限定名
* name 可指定 id、name(用逗号、分号、空格分隔)
* scope 作用域
* constructor arguments 指定构造参数
* properties 设置属性的值
* autowiring mode no(默认值)、byName、byType、 constructor
* lazy-initialization mode 是否懒加载(如果被非懒加载的bean依赖了那么其实也就不能懒加载了)
* initialization method bean 属性设置完成后,会调用这个方法
* destruction method bean 销毁后的回调方法
*
*下面是一个bean的定义
* <bean id="exampleBean" name="name1, name2, name3" class="com.javadoop.ExampleBean"
* scope="singleton" lazy-init="true" init-method="init" destroy-method="cleanup">
*
* <!-- 可以用下面三种形式指定构造参数 -->
* <constructor-arg type="int" value="7500000"/>
* <constructor-arg name="years" value="7500000"/>
* <constructor-arg index="0" value="7500000"/>
*
* <!-- property 的几种情况 -->
* <property name="beanOne">
* <ref bean="anotherExampleBean"/>
* </property>
* <property name="beanTwo" ref="yetAnotherBean"/>
* <property name="integerProperty" value="1"/>
* </bean>
*
* bdHolder实例 已经包含class name id alias等类的属性了
*/
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
/**
* 如果有自定义属性的话,进行相应的解析
*/
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
/**
* 这一步 将解析后的bdHolder进行注册
*/
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
/**
* 注册完成以后,发送事件,这里先跳过
*/
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
逻辑如下:
- 委托BeanDefinitionParserDelegate中的parseBeanDefinitionElement()方法进行元素解析。
- 返回的bdHolder不为空的情况下若存在默认标签的子节点下再有自定义属性,还需要对自定义标签进行解析。
- 解析完后,对解析后的bdHolder进行注册。
- 发出响应事件,通知相关的监听器。
下面对parseBeanDefinitionElement()方法进行解析:
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
String id = ele.getAttribute(ID_ATTRIBUTE);
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
/**
* 将 name 属性的定义按照 ”逗号、分号、空格“ 切分,形成一个别名列表数组,
* 当然,如果你不定义的话,就是空的了
*/
List<String> aliases = new ArrayList<>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
/**
* 如果没有指定id, 那么用别名列表的第一个名字作为beanName
*/
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
beanName = aliases.remove(0);
if (logger.isTraceEnabled()) {
logger.trace("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
/**
* 这里就是解析<bean>...<bean/>中的配置信息了
*/
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
/**
* 到这里,整个 <bean /> 标签就算解析结束了,一个 BeanDefinition 就形成了
*/
if (beanDefinition != null) {
/**
* 如果都没有设置 id 和 name,那么此时的 beanName 就会为 null,进入下面这块代码产生
*/
if (!StringUtils.hasText(beanName)) {
try {
if (containingBean != null) {
/**
* bean名称生成方式
*/
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
beanName = this.readerContext.generateBeanName(beanDefinition);
// Register an alias for the plain bean class name, if still possible,
// if the generator returned the class name plus a suffix.
// This is expected for Spring 1.2/2.0 backwards compatibility.
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null &&
beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
aliases.add(beanClassName);
}
}
if (logger.isTraceEnabled()) {
logger.trace("Neither XML 'id' nor 'name' specified - " +
"using generated bean name [" + beanName + "]");
}
}
catch (Exception ex) {
error(ex.getMessage(), ele);
return null;
}
}
String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
流程如下:
- 提取元素中的id和name属性
- 进一步解析其它属性
- 如果检测到bean没有指定beanname,那么使用默认规则为此bean生成beanName
- 将获取到的信息封装到BeanDefinitionHolder的实例中
下面对这个类中的parseBeanDefinitionElement(ele, beanName, containingBean)方法进行解析:
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
/**
* 创建 BeanDefinition,然后设置类信息而已
*/
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
/**
* 设置 BeanDefinition 的一堆属性,这些属性定义在 AbstractBeanDefinition 中
*/
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
/**
* 下面的一堆是解析 <bean>......</bean> 内部的子元素,
* 解析出来以后的信息都放到 bd 的属性中
*/
/**
* 解析 <meta />
*/
parseMetaElements(ele, bd);
/**
* 解析 <lookup-method />
*/
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;
}
catch (ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch (NoClassDefFoundError err) {
error("Class that bean class [" + className + "] depends on not found", ele, err);
}
catch (Throwable ex) {
error("Unexpected failure during bean definition parsing", ele, ex);
}
finally {
this.parseState.pop();
}
return null;
}
从这个方法我们基本就能够看到bean的所有标签了。
话说至此,发现前面的beanDefinition用到的是GenericBeanDefinition,这个类是2.5版本后加入的bean文件配置属性定义类,是一站式服务类 。有兴趣的可以看一下相应的 标签都是怎么解析的,我懒得看了。至此,默认标签解析完成。下面一个方法delegate.decorateBeanDefinitionIfRequired(ele, bdHolder)方法,解析默认标签中的自定义标签元素,感觉不是我需要的,跳过,进去下面一个重要方法BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()),将解析过的bdHolder进行注册,代码如下:
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
/**
* 重点方法!
*/
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
没有什么好说的,直接进去重点方法:
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
/**
* 注册前的最后一次校验,这次校验不同于之前的xml文件校验
* 主要是对AbstractBeanDefinition属性中的methodOverrides校验
* 校验methodOverrides 是否与工厂方法并存或者methOverrides对应的方法根本不存在
*/
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
/**
*如果不允许覆盖 则直接抛异常
*/
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
/**
* 用框架的bean去覆盖用户自定义的bean
*/
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (logger.isInfoEnabled()) {
logger.info("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
/**
* 用新的bean去覆盖旧的bean
*/
else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
/**
* 用同等的bean去覆盖旧的bean
*/
if (logger.isTraceEnabled()) {
logger.trace("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
/**
* 覆盖
*/
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
/**
* 判断是否已经有其他的 Bean 开始初始化了.
* 注意,"注册Bean" 这个动作结束,Bean 依然还没有初始化.
* 在 Spring 容器启动的最后,会预初始化 所有的 singleton beans
*/
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
removeManualSingletonName(beanName);
}
}
else {
/**
* 最正常的会走到这里
* 将BanDefinition放入到一个map当中,这个map保存了所有的BeanDefinition
*/
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
/**
* 这个ArrayList会按照配置的顺序保存每一个注册bean的名字
*/
this.beanDefinitionNames.add(beanName);
/**
* 手动注入的bean,就是调用registerSingleton(String beanName, Object singletonObject)方法实现的
*/
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
流程如下:
- 对AbstractBeanDefinition的校验。这里的校验是针对AbstractBeanDefinition的methodOverrides属性的。
- 对beanName已经注册的情况的处理。如果设置了不允许bean的覆盖,则需要抛出异常,否则直接覆盖。
- 加到map缓存。
- 清除解析之前留下的对应beanName的缓存。
下面的一个别名注册,就不用看了,大概说一下:
- alias与beanName相同情况处理。若alias与beanName并名称相同则不需要处理并删除原来的alias
- alias覆盖处理。若aliasName 已经使用并已经指向了另一beanName则需要用户设置进行处理
- alias循环检查 。当A->B 存在时,若再次出现 A->C->B时候则会抛出异常。
- 注册alias。
最后一步,就是通知监听器解析及注册完成。
参考:spring(第2版) 源码深度解析