解析spring加载bean流程的方法

spring作为目前我们开发的基础框架,每天的开发工作基本和他形影不离,作为管理bean的最经典、优秀的框架，它的复杂程度往往令人望而却步。不过作为朝夕相处的框架，我们必须得明白一个问题就是spring是如何加载bean的，我们常在开发中使用的注解比如@component、@autowired、@socpe等注解，spring是如何解析的，明白这些原理将有助于我们更深刻的理解spring。需要说明一点的是spring的源码非常精密、复杂，限于篇幅的关系，本篇博客不会细致的分析源码，会采取抽丝剥茧的方式，避轻就重，抓住重点来分析整个流程(不会分析具体的细节)，本次将会基于spring5.0的版本

一：spring读取配置或注解的过程

1：先通过扫描指定包路径下的spring注解，比如@component、@service、@lazy @sope等spring识别的注解或者是xml配置的属性(通过读取流,解析成document，document)然后spring会解析这些属性，将这些属性封装到beandefintaion这个接口的实现类中.

在springboot中，我们也可以采用注解配置的方式：

比如这个配置bean,spring也会将classname、scope、lazy等这些属性装配到personaction对应的beandefintaion中.具体采用的是beandefinitionparser接口中的parse(element element, parsercontext parsercontext)方法,该接口有很多不同的实现类。通过实现类去解析注解或者xml然后放到beandefination中,beandefintaion的作用是集成了我们的配置对象中的各种属性，重要的有这个bean的classname，还有是否是singleton、对象的属性和值等（如果是单例的话，后面会将这个单例对象放入到spring的单例池中）。spring后期如果需要这些属性就会直接从它中获取。然后，再注册到一个concurrenthashmap中，在spring中具体的方法就是registerbeandefinition()，这个map存的key是对象的名字，比如person这个对象，它的名字就是person,值是beandefination,它位于defaultlistablebeanfactory类下面的beandefinitionmap类属性中，同时将所有的bean的名字放入到beandefinitionnames这个list中,目的就是方便取beanname;

二：spring的bean的生命周期

spring的bean生命周期其实最核心的分为4个步骤，只要理清三个关键的步骤，其他的只是在这三个细节中添加不同的细节实现,也就是spring的bean生明周期：

实例化和初始化的区别：实例化是在jvm的堆中创建了这个对象实例，此时它只是一个空的对象，所有的属性为null。而初始化的过程就是讲对象依赖的一些属性进行赋值之后，调用某些方法来开启一些默认加载。比如spring中配置的数据库属性bean，在初始化的时候就会将这些属性填充，比如driver、jdbcurl等,然后初始化连接

2.1：实例化 instantiation

abstractautowirecapablebeanfactory.docreatebean中会调用createbeaninstance()方法,该阶段主要是从beandefinitionmap循环读取bean,获取它的属性，然后利用反射(core包下有reflectionutil会先强行将构造方法setaccessible(true))读取对象的构造方法(spring会自动判断是否是有参数还是无参数，以及构造方法中的参数是否可用),然后再去创建实例（newinstance）

2.2：初始化

初始化主要包括两个步骤,一个是属性填充，另一个就是具体的初始化过程

2.2.1：属性赋值 populatebean()会对bean的依赖属性进行填充，@autowired注解注入的属性就发生这个阶段，假如我们的bean有很多依赖的对象，那么spring会依次调用这些依赖的对象进行实例化，注意这里可能会有循环依赖的问题。后面我们会讲到spring是如何解决循环依赖的问题

2.2.2：初始化 initialization

初始化的过程包括将初始化好的bean放入到spring的缓存中、填充我们预设的属性进一步做后置处理等

3: 使用和销毁 destruction

在spring将所有的bean都初始化好之后，我们的业务系统就可以调用了。而销毁主要的操作是销毁bean，主要是伴随着spring容器的关闭，此时会将spring的bean移除容器之中。此后spring的生命周期到这一步彻底结束，不再接受spring的管理和约束。

三：spring的beanpostprocessor处理器

spring的另一个强大之处就是允许开发者自定义扩展bean的初始化过程，最主要的实现思路就是通过beanpostprocessor来实现的,spring有各种前置和后置处理器，这些处理器渗透在bean创建的前前后后,穿插在spring生命周期的各个阶段，每一步都会影响着spring的bean加载过程。接下来我们就来分析具体的过程：

3.1:实例化阶段

该阶段会调用对象的空构造方法进行对象的实例化，在进行实例化之后，会调用instantiationawarebeanpostprocessor的postprocessbeforeinstantiation方法

beanpostprocessor(具体实现是instantiationawarebeanpostprocessor). postprocessbeforeinstantiation();

这个阶段允许在bena进行实例化之前，允许开发者自定义逻辑，如返回一个代理对象。不过需要注意的是假如在这个阶段返回了一个不为null的实例，spring就会中断后续的过程。
beanpostprocessor.postprocessafterinstantiation();

这个阶段是bean实例化完毕后执行的后处理操作，所有在初始化逻辑、装配逻辑之前执行

3.2:初始化阶段

3.2.1:beanpostprocessor.postprocessbeforeinitialization

该方法在bean初始化方法前被调用，spring aop的底层处理也是通过实现beanpostprocessor来执行代理逻辑的

3.2.2:initializingbean.afterpropertiesset

自定义属性值该方法允许我们进行对对象中的属性进行设置，假如在某些业务中，一个对象的某些属性为null,但是不能显示为null，比如显示0或者其他的固定数值，我们就可以在这个方法实现中将null值转换为特定的值

3.2.3:beanpostprocessor.postprocessafterinitialization(object bean, string beanname)。可以在这个方法中进行bean的实例化之后的处理，比如我们的自定义注解，对依赖对象的版本控制自动路由切换。比如有一个服务依赖了两种版本的实现，我们如何实现自动切换呢？这时候可以自定义一个路由注解,假如叫@routeannotaion，然后实现beanpostprocessor接口，在其中通过反射拿到自定义的注解@routeannotaion再进行路由规则的设定。

3.2.4:smartinitializingsingleton.aftersingletonsinstantiated

4.1：容器启动运行阶段

4.1.1:smartlifecycle.start

容器正式渲染完毕，开始启动阶段,bean已经在spring容器的管理下,程序可以随时调用

5.1：容器停止销毁

5.1.1:smartlifecycle.stop(runnable callback)

spring容器停止运行

5.1.2:disposablebean.destroy()

spring会将所有的bean销毁,实现的bean实例被销毁的时候释放资源被调用

四：一些关键性的问题

4.1:factorybean和beanfactory的区别？

beanfactory是个bean 工厂类接口，是负责生产和管理bean的工厂，是ioc容器最底层和基础的接口，spring用它来管理和装配普通bean的ioc容器,它有多种实现，比如annotationconfigapplicationcontext、xmlwebapplicationcontext等。

factorybean是factorybean属于spring的一个bean，在ioc容器的基础上给bean的实现加上了一个简单工厂模式和装饰模式，是一个可以生产对象和装饰对象的工厂bean，由spring管理，生产的对象是由getobject()方法决定的。注意：它是泛型的，只能固定生产某一类对象，而不像beanfactory那样可以生产多种类型的bean。在对于某些特殊的bean的处理中，比如bean本身就是一个工厂，那么在其进行单独的实例化操作逻辑中，可能我们并不想走spring的那一套逻辑，此时就可以实现factorybean接口自己控制逻辑。

4.2：spring如何解决循环依赖问题

循环依赖问题就是a->b->a，spring在创建a的时候,发现需要依赖b,因为去创建b实例,发现b又依赖于a,又去创建a,因为形成一个闭环，无法停止下来就可能会导致cpu计算飙升

如何解决这个问题呢？spring解决这个问题主要靠巧妙的三层缓存，所谓的缓存主要是指这三个map,singletonobjects主要存放的是单例对象，属于第一级缓存；singletonfactories属于单例工厂对象，属于第三级缓存；earlysingletonobjects属于第二级缓存，如何理解early这个标识呢？它表示只是经过了实例化尚未初始化的对象。spring首先从singletonobjects（一级缓存）中尝试获取，如果获取不到并且对象在创建中，则尝试从earlysingletonobjects(二级缓存)中获取，如果还是获取不到并且允许从singletonfactories通过getobject获取，则通过singletonfactory.getobject()(三级缓存)获取。如果获取到了则移除对应的singletonfactory,将singletonobject放入到earlysingletonobjects，其实就是将三级缓存提升到二级缓存,这个就是缓存升级。spring在进行对象创建的时候，会依次从一级、二级、三级缓存中寻找对象，如果找到直接返回。由于是初次创建，只能从第三级缓存中找到(实例化阶段放入进去的)，创建完实例，然后将缓存放到第一级缓存中。下次循环依赖的再直接从一级缓存中就可以拿到实例对象了。

五：测试

我们来写一个测试类，验证一下上面的问题：

5.1:首先声明一个自定义的bean

@component
public class custombean {
    public custombean(){
        system.out.println("调用custombean空的构造方法");
    }
}

5.2:声明一个bean来实现beanpostprocessor

package com.wyq.spring.bean;

import org.springframework.beans.beansexception;
import org.springframework.beans.propertyvalues;
import org.springframework.beans.factory.disposablebean;
import org.springframework.beans.factory.smartinitializingsingleton;
import org.springframework.beans.factory.config.beanpostprocessor;
import org.springframework.beans.factory.config.instantiationawarebeanpostprocessor;
import org.springframework.context.annotation.scope;
import org.springframework.stereotype.component;

import java.beans.propertydescriptor;

/**
 * @author: wyq
 * @desc:
 * @date: 2019/9/1 15:36
 **/
@component
@scope("singleton")
public class testbean implements beanpostprocessor, smartinitializingsingleton, instantiationawarebeanpostprocessor, disposablebean{

    private static final string bean_name= "custombean";

    @override
    public object postprocessbeforeinitialization(object bean, string beanname) throws beansexception {
        if (bean_name.equals(beanname)) {
            system.out.println("==>beanpostprocessor.postprocessbeforeinitialization");
        }
        return null;
    }

    @override
    public object postprocessafterinitialization(object bean, string beanname) throws beansexception {
        if (bean_name.equals(beanname)) {
            system.out.println("==>beanpostprocessor.postprocessafterinitialization");
        }
        return null;
    }


    @override
    public void aftersingletonsinstantiated() {
        system.out.println("==>smartinitializingsingleton.aftersingletonsinstantiated");

    }

    @override
    public object postprocessbeforeinstantiation(class<?> beanclass, string beanname) throws beansexception {
        if (bean_name.equals(beanname)) {
            system.out.println("==>instantiationawarebeanpostprocessor.postprocessbeforeinstantiation");
        }
        return null;
    }

    @override
    public boolean postprocessafterinstantiation(object bean, string beanname) throws beansexception {
        if (bean_name.equals(beanname)) {
            system.out.println("==>instantiationawarebeanpostprocessor.postprocessafterinstantiation");
        }
        return false;
    }

    @override
    public propertyvalues postprocesspropertyvalues(propertyvalues pvs, propertydescriptor[] pds, object bean, string beanname) throws beansexception {
        system.out.println("==>instantiationawarebeanpostprocessor.postprocesspropertyvalues");
        return null;
    }

    @override
    public void destroy() throws exception {
        system.out.println("==>disposablebean.destroy");
    }
}

5.3:启动容器：

六：总结

本篇博客主要是介绍了spring的一些实例化的过程，高屋建瓴的分析了一下spring的bean加载过程，没有详细展开某个细节分析。spring的内部源码非常复杂，每个接口的实现类都在5个以上，如果深入细节，恐怕不是一篇博客能讲清楚的。这篇博客的目的就是在阐述spring的基本脉络中心路线顺序,首先我们需要有一个总体的认识，然后再深入到细节就是轻而易举的了。这也是一种学习的方法论，通过本篇博客我希望能梳理清楚spring的基本流程，对spring有一个比较清晰的认识。并且学习到优秀开源框架的设计基本思想，还有就是进一步提升自己的阅读源码的能力。

到此这篇关于解析spring加载bean流程的方法的文章就介绍到这了,更多相关spring加载bean内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！