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

开发者社区> 小飞哥1112> 正文

Spring bean初始化原理详解

简介: 一、  闲言 使用spring已经多年,却从来没有仔细研究过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[] actResArrayactualResources.toArray(new Resource[actualResources.size()]);

getReaderContext().fireImportProcessed(locationactResArray,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;

   &nbsp;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和注解的两种形式
XML形式 package cn.xy; public class StudentServiceImpl {  private StudentDao studentDao;  public void init()  {   System.out.println("正在执行初始化的init方法");  }  public void save(Student s)  {
841 0
SharePoint 2013 初始化Ribbon选中Tab
  SharePoint使用中,经常打开页面会有默认展开的Ribbon选项,有时这又不是我们需要的,所以我们就需要默认选中的项目,下面简单介绍下如何实现。 方法一   1、Dispform.aspx页面默认Ribbon为View视图;   2、最简单的方式就是添加参数(InitialTabId=Ribbon.
700 0
阿里云服务器端口号设置
阿里云服务器初级使用者可能面临的问题之一. 使用tomcat或者其他服务器软件设置端口号后,比如 一些不是默认的, mysql的 3306, mssql的1433,有时候打不开网页, 原因是没有在ecs安全组去设置这个端口号. 解决: 点击ecs下网络和安全下的安全组 在弹出的安全组中,如果没有就新建安全组,然后点击配置规则 最后如上图点击添加...或快速创建.   have fun!  将编程看作是一门艺术,而不单单是个技术。
4488 0
Spring初始化日志
Spring启动时的日志: 2013-11-22 14:55:59:319[INFO]: FrameworkServlet 'spring3': initialization completed in 443 ms 日志中spring3的来源: web.
681 0
阿里云服务器远程登录用户名和密码的查询方法
阿里云服务器远程连接登录用户名和密码在哪查看?阿里云服务器默认密码是什么?云服务器系统不同默认用户名不同
444 0
初始化bean(二)—— 缓存部分
上一篇博客,讲了下spring如何初始化bean的 当然,当时只讨论了很简单的一种情况:初次加载bean时候,并且只考虑了单例。 这篇博客会试着理清楚spring在加载bean的时候的一部分缓存。
827 0
补习系列(21)-SpringBoot初始化之7招式
背景 在日常开发时,我们常常需要 在SpringBoot 应用启动时执行某一段逻辑,如下面的场景: 获取一些当前环境的配置或变量 向数据库写入一些初始数据 连接某些第三方系统,确认对方可以工作.. 在实现这些功能时,我们可能会遇到一些"坑"。
1247 0
+关注
小飞哥1112
java,架构相关技术专家
45
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载