spring加载机制

爱被打了一巴掌 2022-09-12 08:48 173阅读 0赞

// 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
    prepareRefresh();
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，
    //手动注册几个特殊的 bean, 类加载器,Aware 接口初始化处理类, 事件监听器等等
    prepareBeanFactory(beanFactory);
    
    // 这步比较关键，解析注解和xml配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
    // 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
    // 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)
    postProcessBeanFactory(beanFactory);
    
    // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 回调方法
    // 还有BeanDefinitionRegistryPostProcessor这个实现类，可以进行bean配置的注册
    invokeBeanFactoryPostProcessors(beanFactory);  
    
    // 注册 BeanPostProcessor 的实现类
    // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
    // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。这里仅仅是注册，之后会看到回调这两方法的时机
    registerBeanPostProcessors(beanFactory);
    
    // 初始化当前 ApplicationContext 的 MessageSource，国际化
    initMessageSource();
    
    // 初始化当前 ApplicationContext 的事件广播器
    initApplicationEventMulticaster();
    
    // (钩子方法)具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
    onRefresh();
    	
    // 注册事件监听器，监听器需要实现 ApplicationListener 接口
    registerListeners();
    
    // 重点，重点，重点 初始化所有的 singleton beans（lazy-init 的除外）
    finishBeanFactoryInitialization(beanFactory);
    {
    	//创建bean,并返回,如果是普通bean直接返回,如果是factorybean,返回创建的实例对象
        //prototype原型bean,则抛异常
        getBean()->getSingleton()->获取单例缓存，判断
            -------------
            	有则直接，getObjectForBeanInstance
            -------------
            	没有则，判断是否已创建这个实例了，有了则抛异常，防止循环依赖
            	然后bean获取进行了父类委托和缓存优化
            	获取BeanDefinition的dependsOn依赖关系，首先加载所有依赖getBean()，
            	然后判断bean是Singleton还是Prototype，
            	--------------
            		Singleton， 
            			1.先锁定singletonObjects，如果里面有对象直接返回，
            			2.否则先把当前bean加入到已创建的单例集合里，再createBean()，释放集合里的记录，
            			3.最后添加进singletonObjects，从singletonFactories和earlySingletonObjects里删除
            	--------------
            		Prototype，先把当前bean加入到已创建的多例集合里，再createBean()，释放集合里的记录
            	
        最后都需要调用getObjectForBeanInstance()获取实例
            
        getSingleton()：
            1.取singletonObjects里的记录，有则直接返回，
            2.取earlySingletonObjects里的记录，有则直接返回
            3.如果是空的，则取singletonFactories里的FactoryBean对象，并从singletonFactories删除，加入earlySingletonObjects
            
        createBean()：
            1.执行InstantiationAwareBeanPostProcessor(Class<?> beanClass, String beanName)生命周期
            	如果上一步返回的bean不为空，则调用BeanPostProcessor的after回调，并直接返回bean实例
        	2.否则继续执行doCreateBean方法，调用createBeanInstance()生成BeanWrapper对象（提供javabean对象的属性填充接口等），
        执行MergedBeanDefinitionPostProcessor(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)的回调，
            3.执行SmartInstantiationAwareBeanPostProcessor(Object bean, String beanName)回调
            4.如果不存在singletonObjects中，则把当前bean存入singletonFactories，从earlySingletonObjects删除
            5.执行populateBean()
            	autowireByName和autowireByType注入所有依赖getBean()
            	执行InstantiationAwareBeanPostProcessor(PropertyValues pvs, Object bean, String beanName)和
            		(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)回调
            6.执行initializeBean()
            	执行BeanPostProcessor的before(Object bean, String beanName)回调
            	执行afterPropertiesSet()回调
            	执行BeanPostProcessor的after(Object bean, String beanName)回调
            7.注册bean关闭的生命周期回调
            
        getObjectForBeanInstance()：
            1.factoryBeanObjectCache里有记录则直接返回
            2.没有则从factorybean里获取object并存入factoryBeanObjectCache，然后返回
        
    }
    
    
    // 最后，广播事件，ApplicationContext 初始化完成，不展开
    finishRefresh();

**循环依赖问题**  
Spring为了解决单例的循环依赖问题，addSingletonFactory方法使用了三级缓存,这三级缓存分别指：  
singletonFactories ： 单例对象工厂的cache  一级缓存：用于存放完全初始化好的 bean  
earlySingletonObjects ：提前暴光的单例对象的Cache 二级缓存：存放半成品的Bean，半成品的Bean是已创建对象，但是未注入属性和初始化。用于解决循环依赖  
singletonObjects：单例对象的cache 三级级缓存：存的是Bean工厂对象，用来生成半成品的Bean并放入到二级缓存中。用于解决循环依赖

A 创建过程中需要 B，于是 A 将自己放到三级缓里面 ，去实例化 B  
B 实例化的时候发现需要 A，于是 B 先查一级缓存，没有，再查二级缓存，还是没有，再查三级缓存，找到了！  
然后把三级缓存里面的这个 A 放到二级缓存里面，并删除三级缓存里面的 A  
B 顺利初始化完毕，将自己放到一级缓存里面（此时B里面的A依然是创建中状态）  
然后回来接着创建 A，此时 B 已经创建结束，直接从一级缓存里面拿到 B ，然后完成创建，并将自己放到一级缓存里面

我们可以知道，Spring解决循环依赖的诀窍就在于singletonFactories这个三级cache。这个cache的类型是ObjectFactory。这里就是解决循环依赖的关键，发生在createBeanInstance之后，也就是说单例对象此时已经被创建出来(调用了构造器)。这个对象已经被生产出来了，虽然还不完美（还没有进行初始化的第二步和第三步），但是已经能被人认出来了（根据对象引用能定位到堆中的对象），所以Spring此时将这个对象提前曝光出来让大家认识，让大家使用。

所以spring不支持构造器循环依赖和prototype field属性注入循环依赖  
非单例Bean默认不会初始化

**为什么采用三级缓存而不是二级?**  
包装一层ObjectFactory对象不提前创建好代理对象，在出现循环依赖被其他对象注入时，才实时生成代理对象。这样在没有循环依赖的情况下，Bean就可以按着Spring设计原则的步骤来创建。执行一些生命周期方法回调。  
Spring容器会将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中，Bean标识符在创建过程中将一直保持在这个池中，因此如果在创建Bean过程中发现自己已经在“当前创建Bean池”里时将抛出BeanCurrentlyInCreationException异常表示循环依赖；而对于创建完毕的Bean将从“当前创建Bean池”中清除掉。