Spring bean初始化原理详解-阿里云开发者社区

一、闲言

使用spring已经多年，却从来没有仔细研究过spring bean的初始化过程以及原理。知其然而不知其所以然，当面遇到比较深度的问题的时候，就无法解决或者需要花费大量问题方可解决。

二、目的

本文主要想解决以下几个问题，希望大家看完本文以后，能得出答案。

l Bean的解析化过程是怎样的？

l BeanFactory的原理是怎样的？

l 为什么有的时候存在相同id的bean，spring启动报错，有的时候可以正常启动；此时通过id或者类型获取bean的时候使用的是哪一个bean？

l 自定义注解的实现原理是怎样的？

l bean的属性是在什么阶段注入的？

三、示例代码

本文涉及的内容由以下代码加载过程整理而来。

ClassPathResource resource = new ClassPathResource("application.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions(resource);
SpringTestService springTestService = (SpringTestService) factory.getBean(SpringTestService.class);
springTestService.doTest();

说明： spring版本：4.1.6.release

四、 Xml解析

1. 解析XML的核心类

1) XmlBeanDefinitionReader

Xml资源的阅读器，将xml解析成Document

2) DefaultBeanDefinitionDocumentReader

Document阅读器，将document解析成Element、Node、Attribute，以便于后续解析。

3) BeanDefinitionParserDelegate

解析xml生成BeanDefinition的委派类。所有解析过程由此类完成

4) DefaultListableBeanFactory

xml解析完以后，都注册到BeanFactory。后续通过BeanFactory可以源源不断的创建实例。

2. 流程图

3. Xml文件解析详解

这部分内容时对流程图的详述，如果看懂流程图，可以忽略此部分。

1) XmlBeanDefinitionReader：Xml资源阅读器

l 包装Resource，生成EncodedResource

 new EncodedResource(resource)

l 判断当前是否正在加载此资源文件。

从ThreadLocal对象resourcesCurrentlyBeingLoaded中检查次Resource是否正在加载中，如果正在加载抛出异常，否则加载Resource文件。避免因为循环引用导致问题。

l 通过Resource创建InputSource

     InputStream inputStream = encodedResource.getResource().getInputStream();
     InputSource inputSource = new InputSource(inputStream);

l 加载文档生成Document对象

     Document doc = doLoadDocument(inputSource, resource);

l 创建BeanDefinitionDocumentReader，调用registerBeanDefinitions进行解析并注册到BeanFactory中

     BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
     documentReader.setEnvironment(getEnvironment());
     documentReader.registerBeanDefinitions(doc,createReaderContext(resource));

2) BeanDefinitionDocumentReader：文档阅读器

l doRegisterBeanDefinitions

a) 创建BeanDelinitionParserDelegate

b) 调用parseBeanDefinitions(root,this.delegate)方法进行解析

    this.delegate= createDelegate(getReaderContext(), root, parent);
    preProcessXml(root);
    parseBeanDefinitions(root,this.delegate);
    postProcessXml(root);

l parseBeanDefinitions：解析Element生成BeanDefinition；

如果是默认Namespace使用parseDefaultElement解析element；如果不是，通过delegate.parseCustomElement解析element。其中DefaultNamespace指的是http://www.springframework.org/schema/beans这个namespace。Delegate为上一步创建的BeanDefinitionParserDelegate

protected void parseBeanDefinitions(Element root,BeanDefinitionParserDelegate delegate) {
           if (delegate.isDefaultNamespace(root)) {
                NodeListnl = root.getChildNodes();
                for (int i = 0; i < nl.getLength(); i++){
                     Nodenode = nl.item(i);
                     if (node instanceof Element) {
                          Elementele = (Element) node;
                          if (delegate.isDefaultNamespace(ele)) {
                                parseDefaultElement(ele, delegate);
                          }else {
                                delegate.parseCustomElement(ele);
                          }
                     }
                }
           } else {
                delegate.parseCustomElement(root);
           }
}

l 根据element的不同，分别解析

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
           if(delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
                importBeanDefinitionResource(ele);
           }else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
                processAliasRegistration(ele);
           }else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
                processBeanDefinition(ele,delegate);
           }else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
                //重新走一次资源加载过程
                doRegisterBeanDefinitions(ele);
           }
     }

说明：

IMPORT_ELEMENT对应于<importresource=""/>标签

ALIAS_ELEMENT对应于<aliasname=""alias=""/>标签

BEAN_ELEMENT对应于<beanclass=""/>标签

NESTED_BEANS_ELEMENT对应于<beans/>标签

l processBeanDefinition – 单个Bean解析的完整过程

a) 解析Element生成BeanDefinition，并封装在BeanDefinitionHolder中。

这是真正将Xml转换成Bean的地方。

b) 根据需要装饰BeanDefinitionHolder。

主要针对非默认命名空间的element、node进行一些额外的解析操作。

c) 注册BeanDefinitionHolder到DefaultListableBeanFactory。

protected void processBeanDefinition(Element ele,BeanDefinitionParserDelegate delegate) {
     BeanDefinitionHolderbdHolder = delegate.parseBeanDefinitionElement(ele);
     if (bdHolder !=null) {
         bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
         try {
             BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
         }catch (BeanDefinitionStoreException ex) {
             getReaderContext().error("Failed to register bean definition withname '" +bdHolder.getBeanName() + "'", ele, ex);
         }
                getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
     }
}

l importBeanDefinitionResource – 解析import xml

a) 判断location是否为绝对路径。

b) 如果是绝对路径，直接加载此绝对路径只想的xml，具体逻辑和示例代码中加载xml一样。

c) 如果是相对路径，通过location创建Resource，判断Resource是否存在，存在则读取，不存在则加上baseLocation，然后读取xml文件。

boolean absoluteLocation = ResourcePatternUtils.isUrl(location) ||ResourceUtils.toURI(location).isAbsolute();
if (absoluteLocation) {
     int importCount= getReaderContext().getReader().loadBeanDefinitions(location,actualResources);
} else {
     int importCount;
     Resource relativeResource =getReaderContext().getResource().createRelative(location);
     if (relativeResource.exists()){
          importCount= getReaderContext().getReader().loadBeanDefinitions(relativeResource);
     } else {
          String baseLocation= getReaderContext().getResource().getURL().toString();
           importCount =getReaderContext().getReader().loadBeanDefinitions( StringUtils.applyRelativePath(baseLocation, location),actualResources);
     }
}

Resource[] actResArray= actualResources.toArray(new Resource[actualResources.size()]);

getReaderContext().fireImportProcessed(location, actResArray,extractSource(ele));

3) BeanDefinitionParserDelegate：bean解析的委派类

l 解析xml生成BeanDefinition。

a) 检查bean id是否重复，如果重复则抛出异常。

checkNameUniqueness(beanName,aliases,ele);

b) 解析Bean的干活。

AbstractBeanDefinitionbeanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

c) 如果bean没有定义id，那么生成一个id

if (!StringUtils.hasText(beanName)) {
     try{
           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);
                }
           }
     } catch(Exception ex) {
           error(ex.getMessage(), ele);
           return null;
     }
}

l checkNameUniqueness

检查bean id是否重复，如果重复则抛出异常。

foundName = CollectionUtils.findFirstMatch(this.usedNames, aliases);
if (foundName != null){
    error("Bean name '" + foundName + "' is already used in this <beans>element", beanElement);
}

id重复的校验是在当前Delegate进行的，不是整个BeanFactory中。

由上述代码分析可知每一个BeanDefinitionDocumentReader都会生成一个BeanDelinitionParserDelegate。当一个xml中import进来多个xml文件时，因为spring会为每一个xml文件生成一个BeanDefinitionDocumentReader对象，所以当一个id同时存在两个xml文件中的时候，是不会出现id重复的异常的。

l 解析Bean的干活 - parseBeanDefinitionElement。

// 创建BeanDefinition
AbstractBeanDefinition bd =createBeanDefinition(className, parent);
// 解析属性 - 解析Bean定义的属性
parseBeanDefinitionAttributes(ele, beanName, containingBean,bd);
// 解析child node - 描述信息
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
// 解析child node -<meta key="" value=""/>
parseMetaElements(ele, bd);
// 解析child node -<lookup-method />
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
// 解析child node -<replaced-method/>
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
// 解析child node - - 构造函数
parseConstructorArgElements(ele, bd);
// 解析child node – property
parsePropertyElements(ele, bd);
// 解析child node - qualifier
parseQualifierElements(ele, bd);
// 设置resource的引用
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));

l decorateBeanDefinitionIfRequired：对属性和子节点进行装配

a) 装饰当前element的属性。

b) 装饰当前element的child node。

public BeanDefinitionHolder decorateBeanDefinitionIfRequired( Elementele, BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {
     BeanDefinitionHolderfinalDefinition = definitionHolder;
     NamedNodeMap attributes = ele.getAttributes();
     for (int i = 0; i < attributes.getLength(); i++){
          Node node= attributes.item(i);
          finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
     }
     NodeList children = ele.getChildNodes();
     for (int i = 0; i < children.getLength(); i++){
          Node node= children.item(i);
          if (node.getNodeType() == Node.ELEMENT_NODE) {
                finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
          }
     }
     return finalDefinition;
}

l decorateIfRequired : 如果是非默认namespace，进行装饰操作

这个功能主要服务于spring提供的其他命名空间，或者开发者自定义的命名空间。需要继承NamespaceHandler实现decorate方法。

public BeanDefinitionHolder decorateIfRequired( Node node,BeanDefinitionHolder originalDef,BeanDefinition containingBd) {
    String namespaceUri= getNamespaceURI(node);
    if(!isDefaultNamespace(namespaceUri)) {
         NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
         if(handler != null){
              return handler.decorate(node, originalDef,new ParserContext(this.readerContext, this,containingBd));
         }
    }
    return originalDef;
}

l 其他命名空间：解析xml生成BeanDefinition

通过META-INF/spring.handlers中配置的namespaceURI和NamespaceHandler映射关系，返回NamespaceHandler。通过NamespaceHandler中定义的解析规则解析生成BeanDefinition对象。这就是自定义标签的实现原理。

public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd){
     String namespaceUri = getNamespaceURI(ele);
     NamespaceHandlerhandler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
     if (handler == null) {
          error("Unable to locate SpringNamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
           return null;
     }
     return handler.parse(ele, newParserContext(this.readerContext,this, containingBd));
}

如spring-context.jarMETA-INF/spring.handlers文件中

http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler

五、创建Bean实例

1. BeanFactory#getBean流程图

如上流程图所示，每一个步骤中第一行是功能描述，第二行功能所在的类，第三行是具体的方法。

当我们调用getBean方法获取Bean的时候，首先是通过getSingeleton方法从缓存中获取Instance。

如果获取到Instance，检查是否为FactoryBean，如果不是直接返回；如果是，获取FactoryBean的Object对象。其中有一步是检查缓存中是否存在Object，如果不存在，那么新建一个，缓存起来，见流程图。

如果获取不到Instance，检查是singletion还是prototype，如果是singletion，那么检查之前是否已经实例化过，如果已经实例化直接返回，如果没有实例化，则重新实例化。Prototype和singletion未实例化的场景基本一致。

2. Bean实例化流程图

此流程是AbstractAutowireCapableBeanFactory#createBeanInstance方法的详细剖析。

六、 BeanFactory与FactoryBean

1. BeanFactory是Bean的工厂。

定义了获取Bean的接口。方法如下：

Object getBean(String name) throwsBeansException;

<T> T getBean(String name,Class<T> requiredType) throws BeansException;

<T> T getBean(Class<T>requiredType) throws BeansException;

Object getBean(String name, Object... args)throws BeansException;

boolean containsBean(String name);

boolean isSingleton(String name) throwsNoSuchBeanDefinitionException;

boolean isPrototype(String name) throwsNoSuchBeanDefinitionException;

boolean isTypeMatch(String name,Class<?> targetType) throws NoSuchBeanDefinitionException;

Class<?> getType(String name) throwsNoSuchBeanDefinitionException;

 String[] getAliases(String name);

2. FactoryBean是工厂Bean，

使用getBean获取FacotryBean时，实际上获取的是FactoryBean中getObject()返回的对象，而不是FactoryBean本身，如果要获取FactoryBean对象，可以在id前面加一个&符号来获取。

某些场景中实例化Bean过程比较复杂，如果按照传统的方式，则需要在<bean>中提供大量的配置信息。FactoryBean提供了一种非常简单的解决方案。例如，使用SchedulerFactoryBean时，我们只需要简单的配置trigger就好了，SchedulerFactoryBean负责处理复杂的线程管理工作。配置示例

<beanid="tokenRefreshSchedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

<propertyname="triggers">

<list>

<refbean="trigger1"/>

<refbean="trigger2"/>

</list>

</property>

</bean>

另一个场景就是dubbo的配置，如下代码所示。我们不需要关心网络、序列化、负载均衡等内容，只需要关注我们的业务接口就好了。

<beanid="orderPushServiceRef"class="com.alibaba.dubbo.config.spring.ReferenceBean">

<propertyname="interface"value="Service"/>

<propertyname="application"ref="dubboApplicationConfig"/>

<propertyname="registry"ref="dubboRegistryConfig"/>

<propertyname="version"value="${dubbo.consumer.version.gateway}"/>

<propertyname="timeout"value="${dubbo.consumer.timeout}"/>

<propertyname="retries"value="0"/>

<propertyname="check"value="${dubbo.consumer.check}"/>

</bean>

七、扩展：

1. spring自定义标签

以下示例均使用spring-context.jar的代码来说明。

1) 继承BeanDefinitionParser，创建自己的BeanDefinitionParser

如：PropertyPlaceholderBeanDefinitionParser

2) 创建NamespaceHandler，并注册BeanDefinitionParser

如：ContextNamespaceHandler

public void init() {

registerBeanDefinitionParser("property-placeholder",new PropertyPlaceholderBeanDefinitionParser());

}

3) 在classpath/META-INF下创建spring.handlers文件，并指定命名空间URI和NameSpaceHandler的映射关系

如：http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler

4) 定义Xsd文件

如：spring-context-4.1.xsd

5) 在classpath/META-INF下创建spring.schemas文件，并申明xsd的路径

2. spring自定义标签原理

上文的Bean初始化过程可知，在BeanDefinitionDocumentReader#parseBeanDefinitions方法中，非默认Namespace时，通过BeanDefinitionParserDelegate#parseCustomElement方法解析Bean。从流程图中可以清楚的看到，首先通过namespaceUri获取NameSapceHandler，然后获取NamespacHanlder中注册的Parser对象BeanDefinitionParser。

3. aop的一个问题

l 拦截器类：SpringMethodAnnotInterceptor

public class SpringMethodAnnotInterceptor implements MethodInterceptor{
    publicObject invoke(MethodInvocation invocation) throws Throwable {
        System.err.println("***** before method excute");
        Object result = invocation.proceed();
        System.err.println("***** after method excute");
        returnresult;
    }
}

l 目标类：SpringTestService

public classSpringTestService {
    @SpringMethodAnnot
    public boolean doTest2() {
        System.err.println("dotest ");
        returntrue;
    }
    public boolean doTest1(){
        returndoTest2() ;
    }
}

l 测试

SpringTestService springTestService2 = (SpringTestService) xmlContext.getBean("springTestService");
 springTestService2.doTest1();

上述代码的运行结果时什么？是否能够进入拦截器中？答案是否定的，不能进入拦截器，输出的结果是do test

l 分析

从spring获取的Bean是被代理的对象，不是springTestService。如下图所示。

在doTest1方法中调用的时候，是springTestService对象。

Spring bean初始化原理详解

一、闲言

二、目的

三、示例代码

四、 Xml解析

1. 解析XML的核心类

1) XmlBeanDefinitionReader

2) DefaultBeanDefinitionDocumentReader

3) BeanDefinitionParserDelegate

4) DefaultListableBeanFactory

2. 流程图

3. Xml文件解析详解

1) XmlBeanDefinitionReader：Xml资源阅读器

2) BeanDefinitionDocumentReader：文档阅读器

3) BeanDefinitionParserDelegate：bean解析的委派类

五、创建Bean实例

1. BeanFactory#getBean流程图

2. Bean实例化流程图

六、 BeanFactory与FactoryBean

1. BeanFactory是Bean的工厂。

2. FactoryBean是工厂Bean，

七、扩展：

1. spring自定义标签

1) 继承BeanDefinitionParser，创建自己的BeanDefinitionParser

2) 创建NamespaceHandler，并注册BeanDefinitionParser

3) 在classpath/META-INF下创建spring.handlers文件，并指定命名空间URI和NameSpaceHandler的映射关系

4) 定义Xsd文件

5) 在classpath/META-INF下创建spring.schemas文件，并申明xsd的路径

2. spring自定义标签原理

3. aop的一个问题

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Spring bean初始化原理详解

一、 闲言

二、 目的

三、 示例代码

四、 Xml解析

1. 解析XML的核心类

1) XmlBeanDefinitionReader

2) DefaultBeanDefinitionDocumentReader

3) BeanDefinitionParserDelegate

4) DefaultListableBeanFactory

2. 流程图

3. Xml文件解析详解

1) XmlBeanDefinitionReader：Xml资源阅读器

2) BeanDefinitionDocumentReader：文档阅读器

3) BeanDefinitionParserDelegate：bean解析的委派类

五、 创建Bean实例

1. BeanFactory#getBean流程图

2. Bean实例化流程图

六、 BeanFactory与FactoryBean

1. BeanFactory是Bean的工厂。

2. FactoryBean是工厂Bean，

七、 扩展：

1. spring自定义标签

1) 继承BeanDefinitionParser，创建自己的BeanDefinitionParser

2) 创建NamespaceHandler，并注册BeanDefinitionParser

3) 在classpath/META-INF下创建spring.handlers文件，并指定命名空间URI和NameSpaceHandler的映射关系

4) 定义Xsd文件

5) 在classpath/META-INF下创建spring.schemas文件，并申明xsd的路径

2. spring自定义标签原理

3. aop的一个问题

热门文章

最新文章

相关课程

相关电子书

相关实验场景

一、闲言

二、目的

三、示例代码

五、创建Bean实例

七、扩展：