spring 启动主要流程_spring的启动流程简书-优快云博客

本文链接：https://blog.youkuaiyun.com/wanghaichaonihao/article/details/83661792

public void refresh() throws BeansException, IllegalStateException {

synchronized (this.startupShutdownMonitor) {

// Prepare this context for refreshing.

//spring没用实现任何东西，主要是进行扩展，在加载前做一些其他事情

prepareRefresh();

// Tell the subclass to refresh the internal bean factory.

//初始化BeanFactory，并解析xml

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// Prepare the bean factory for use in this context.

//对BeanFactory进行功能填充

prepareBeanFactory(beanFactory);

try {

// Allows post-processing of the bean factory in context subclasses.

//子类覆盖方法做额外的处理

postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.

//激活各种BeanFactory处理器。

invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.

//注册拦截Bean创建Bean处理器，这里进行注册，真正的调用在getObject中

registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.

//为上下文初始化Message源，国际化处理

initMessageSource();

// Initialize event multicaster for this context.

//初始化消息广播器，

initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.

//留给子类初始化其他的Bean

onRefresh();

// Check for listener beans and register them.

//在所有的bean中查找Listenerbean 注册到消息广播器中

registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.

//初始化剩下的单实例，非懒惰式

finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.

//完成刷新过程，通知生命周期器处理器，lifeprocessor刷新过程，同时发出contextRefreshEvent通知别人

finishRefresh();

}

catch (BeansException ex) {

// Destroy already created singletons to avoid dangling resources.

destroyBeans();

// Reset 'active' flag.

cancelRefresh(ex);

// Propagate exception to caller.

throw ex;

}

最核心的在finishBeanFactoryInitialization(beanFactory);加载bean就是在此处完成。

这个方法循环遍历所有已知的bean进行加载注入。

1.获取由前面解析好的xml封装成的RootBeanDefinition=getMergedLocalBeanDefinition(beanName);

2.判断方法是否为抽象类&&是否为单例&&是否配置懒加载，如果不通过再次循环!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()

3.判断bean是否为工厂类，为工厂类则进行一下安全检查。

4.然后调用AbstractBeanFactory的getBean方法进行bean的初始化。getBean有三个重载方法。实际的加载在doGetBean

1.获取beannanme

2.检查检查缓存中或者实例工厂中是否有对应的实例。为什么首先会使用这段代码呢，因为在创建单例 bean 的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，Spring 创建 bean 的原则是不等 bean 创建完成就会将创建的 bean 的 ObjectFactory 提前曝光，也就是将 ObjectFactory 加入缓存中，一旦下个 bean 创建时候需要依赖上个 bean 则直接使用 ObjectFactory

3.如果为不为空，则直接生成bean的实例（getObjectForBeanInstance 后面讲）

4.如果为空，判断是否是原型，如果是原型，直接抛异常。只有在单例情况才会尝试解决依赖循环，set模式进行尝试，构造器模式不行。原型模型情况，如果存在A 中有 B 的属性，B 中有 A 的属性，那么当依赖注入的时候，就会产生当 A 还未创建完的时候因为对于 B 的创建再次返回创建，造成依赖循环。

5.获取父类Beanfactory并查询是否存在beanname。如果存在返回父类beanfactory中的bean。

6.如果不是仅仅做类型检查而是创建 bean，要进行记录。防止重复创建

7.将BeanDefinition转换为RootBeanDefinition

8.若存在依赖则需要递归实例化依赖的 bean

9.判断bean实例是什么类型（单例、原型和自定义。默认单例）

10.检查需要的类型是否符合 bean 的实际类型

以单例模式进行查看

调用DefaultSingletonBeanRegistry的getSingleton方法。

1.检查缓存中是否存在，存在直接返回

2.如果不存在

2.1 如果此 bean 正在被销毁，如果正在处理直接抛出异常

2.2 调用beforeSingletonCreation进行bean创建前处理检查bean正在被创建。如果正在被创建直接抛出异常

2.3 调用入参传入bean的实际beanfactory获取object

2.4 调用afterSingletonCreation进行bean创建后处理检查bean是否还在被创建。如果还在被创建的map中直接抛异常

2.4.调用addSingleton将实例bean放到缓存中，删除beanfactory中的bean、注册的bean、earlySingletonObjects

singletonObjects: 用于保存 BeanName 和创建 bean 实例之间的关系，beanName -> beanInstance

singletonFactories：用于保存 BeanName 和创建 bean 的工厂之间的关系，beanName -> ObjectFactory

earlySingletonObjects：也是保存 BeanName 和创建 bean 实例之间的关系，与singletonObjects的不同之处在于，当一个单例bean被放到这里面后，那么当bean还在创建过程中，就可以通过getBean方法获取到了，其目的是用来检测循环引用。

registeredSingletons：用来保存当前所有已注册的bean。

然后调用AbstractAutowireCapableBeanFactory的createBean

1.锁定 class，根据设置的 class 属性或者根据 className 来解析 Class

2.验证及准备覆盖的方法

3.给 BeanPostProcessors 一个机会来返回代理来替代真正的实例

最后调用AbstractAutowireCapableBeanFactory的doCreateBean

1. 如果是单例则需要首先清楚缓存

2. 实例化bean，将BeanDefinition转换为BeanWrapper。

转换是一个复杂的过程，但是我们可以尝试概括大致的功能：

如果存在工厂方法，则使用工厂方法进行初始化。

一个类有多个构造函数，每个构造函数都有不同的参数，所以需要根据参数锁定构造函数并进行初始化。

如果既不存在工厂方法也不存在带有参数的构造函数，则使用默认的构造函数进行bean的实例化。

3. MergedBeanDefinitionPostProcessor的应用。

bean合并后的处理，Autowired注解正是通过此方法实现诸如类型的预解析。

4. 依赖处理

在Spring中会有循环依赖的情况，例如A->B&B->A。如果此时A与B都是单例的，那么在Spring中的处理方式就是当创建B的时候，涉及自动注入A步骤时，并不是直接去再次创建A，而是通过放入缓存的ObjectFactory来创建实例，这样就解决了循环依赖的问题。

5. 属性填充

将所有属性填充至bean的实例中。

6. 循环依赖检查

之前提到过，在Spring中解决循环依赖只对单例有效，而对于prototype的bean，Spring没有好的解决办法，唯一要做的就是抛出异常。在这个步骤中会检测已经加载的Bean是否已经出现了依赖循环，并判断是否需要抛出异常。

7. 注册DisposableBean。

如果配置了destory-method，这里需要注册以便在销毁的时候调用。

8. 完成创建并返回

可以看到上面的步骤非常繁琐，每一步骤都使用了大量的代码来完成其功能，最复杂也是最难以理解的当属循环依赖的处理，在真正进入doCreateBean前我们是有必要先了解这个循环依赖的。

通过initializeBean方法看一下初始化bean都干了什么

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {

// 首先执行Aware接口的方法

// 这里涉及的Aware接口有BeanFactoryAware、BeanClassLoaderAware和BeanNameAware

if (System.getSecurityManager() != null) {

AccessController.doPrivileged(new PrivilegedAction<Object>() {

@Override

public Object run() {

invokeAwareMethods(beanName, bean);

return null;

}

}, getAccessControlContext());

} else {

invokeAwareMethods(beanName, bean);

}

Object wrappedBean = bean;

if (mbd == null || !mbd.isSynthetic()) {

// 执行bean后处理器的postProcessBeforeInitialization方法

wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

}

try {

// 执行实现自InitializingBean接口的afterPropertiesSet()方法

// 执行bean的init-method方法

invokeInitMethods(beanName, wrappedBean, mbd);

} catch (Throwable ex) {

throw new BeanCreationException(

(mbd != null ? mbd.getResourceDescription() : null),

beanName, "Invocation of init method failed", ex);

}

if (mbd == null || !mbd.isSynthetic()) {

// 执行bean后处理器的postProcessAfterInitialization方法此处获取aop拦截器

wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

}

return wrappedBean;

}

这个方法比较重要，特别是前处理和后处理。是面向切面生成调用动态代理。

以mybatis的MapperScannerConfigurer为例

MapperScannerConfigurer主要是将所有mapper进行扫描并放到Configuration中。

AbstractApplicationContext.refresh().finishBeanFactoryInitialization -> AbstractApplicationContext.finishBeanFactoryInitialization().beanFactory.preInstantiateSingletons();->AbstractBeanFactory.getBean()->DefaultSingletonBeanRegistry.getSingleton()->AbstractBeanFactory.doGetBean()->AbstractAutowireCapableBeanFactory.createBean()->

->AbstractAutowireCapableBeanFactory.doCreateBean()

->AbstractAutowireCapableBeanFactory.initializeBean()

AbstractAutowireCapableBeanFactory.invokeInitMethods()

由于MapperFactoryBean<-SqlSessionDaoSupport<-DaoSupport<-InitializingBean，在DaoSupport中重写了InitializingBean的afterPropertiesSet并且在方法中调用了checkDaoConfig进行扩展

->MapperFactoryBean.checkDaoConfig()

>Configuration.addMapper()->MapperRegistry.addMapper()将mapper的代理类加载进去

通过分析spring的IOC和AOP。对比dubbo核心的逻辑都是通过动态代理对bean进行包装，通过相应的拦截器进行前置后置处理，拦截器都是使用责任链模式进行调用。

https://gavinzhang1.gitbooks.io/spring/content/chuang_jian_bean.html

spring aop

createAopProxy:102, ProxyCreatorSupport {org.springframework.aop.framework}
getProxy:109, ProxyFactory {org.springframework.aop.framework}
createProxy:477, AbstractAutoProxyCreator {org.springframework.aop.framework.autoproxy}
wrapIfNecessary:362, AbstractAutoProxyCreator {org.springframework.aop.framework.autoproxy}
postProcessAfterInitialization:322, AbstractAutoProxyCreator {org.springframework.aop.framework.autoproxy}
applyBeanPostProcessorsAfterInitialization:409, AbstractAutowireCapableBeanFactory {org.springframework.beans.factory.support}
initializeBean:1518, AbstractAutowireCapableBeanFactory {org.springframework.beans.factory.support}
doCreateBean:521, AbstractAutowireCapableBeanFactory {org.springframework.beans.factory.support}
createBean:458, AbstractAutowireCapableBeanFactory {org.springframework.beans.factory.support}
getObject:296, AbstractBeanFactory$1 {org.springframework.beans.factory.support}
getSingleton:223, DefaultSingletonBeanRegistry {org.springframework.beans.factory.support}
doGetBean:293, AbstractBeanFactory {org.springframework.beans.factory.support}
getBean:198, AbstractBeanFactory {org.springframework.beans.factory.support}
autowireResource:445, CommonAnnotationBeanPostProcessor {org.springframework.context.annotation}
getResource:419, CommonAnnotationBeanPostProcessor {org.springframework.context.annotation}
getResourceToInject:547, CommonAnnotationBeanPostProcessor$ResourceElement {org.springframework.context.annotation}
inject:155, InjectionMetadata$InjectedElement {org.springframework.beans.factory.annotation}
inject:87, InjectionMetadata {org.springframework.beans.factory.annotation}
postProcessPropertyValues:304, CommonAnnotationBeanPostProcessor {org.springframework.context.annotation}
populateBean:1146, AbstractAutowireCapableBeanFactory {org.springframework.beans.factory.support}
doCreateBean:519, AbstractAutowireCapableBeanFactory {org.springframework.beans.factory.support}
createBean:458, AbstractAutowireCapableBeanFactory {org.springframework.beans.factory.support}
getObject:296, AbstractBeanFactory$1 {org.springframework.beans.factory.support}
getSingleton:223, DefaultSingletonBeanRegistry {org.springframework.beans.factory.support}
doGetBean:293, AbstractBeanFactory {org.springframework.beans.factory.support}
getBean:194, AbstractBeanFactory {org.springframework.beans.factory.support}
preInstantiateSingletons:633, DefaultListableBeanFactory {org.springframework.beans.factory.support}
finishBeanFactoryInitialization:932, AbstractApplicationContext {org.springframework.context.support}
refresh:479, AbstractApplicationContext {org.springframework.context.support}