从Run方法开始定位bean生命周期的实现方法
从run方法开始，逐步解析定位到bean生命周期逻辑：
首先这是我们的主启动类入口：
SpringApplicationRunListeners listeners = this.getRunListeners(args);
listeners.starting();这里主要用于启动spring的事件监听器，用于监听容器各个生命周期的各个事件
context = this.createApplicationContext();创建spring容器类
this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
加载各种BeanDefinitionLoader，BeanDefinitionLoader中包括AnnotatedBeanDefinitionReader、XmlBeanDefinitionReader、ClassPathBeanDefinitionScanner、BeanDefinitionReader等基于通过不同方式引入bean的读取器
然后prepareContext方法基本就走完了，后面会执行refreshContext方法
this.refreshContext(context);我们直接往里定位到最里层的refresh()方法，它的三个实现类都会走AbstractApplicationContext中同步代码块的逻辑，这里面就包括了bean的生命周期
在bean的生命周期之前，有几步准备工作：
- 监听器
- 创建beanFactory
- 初始化beanFacotry
其中在创建beanFacotry时会将加载beanDefinition为后面bean的生命周期做准备：
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
继续在refreshBeanFactory中定位beanDefinitions的处理逻辑：
loadBeanDefinitions()函数会基于对应的reader加载所有的beanDefinition，这里我们看loadBeanDefinitions的其中一个实现类AbstractXmlApplicationContext中的loadBeanDefinitions
向继续看更深的实现逻辑
这里看PropertiesBeanDefinitionReader的loadBeanDefinitions(Resource resource)的方法实现
继续往下，主要看看BeanDefinition的生成逻辑，这里props是一个bean name与类全限定名的map
最后定位到registerBeanDefinition方法
看到createBeanDefinition方法的处理逻辑
如果classLoader不为空，会给beanDefinition的BeanClass赋值对应的class，其实就是拿到beanDefinition的Class；如果为空则给BeanClassName赋值
而这里注册器的作用就是存放一个map，用于存放beanDefinition的map
看其中一个实现类的代码
registerBeanDefinition本身也只是在map中存储一个BeanName-BeanDefinition的键值对
beanDefinition处理完成后，就进入bean生命周期逻辑中了
然后继续向下定位bean的生命周期代码逻辑：
doGetBean中会调用createBean方法
createBean中又会调用doCreateBean，doCreateBean方法中包含了bean生命周期的几乎所有阶段
bean生命周期解析
前言
首先spring容器在获取bean时会调用getBean(beanName)方法（或同名重载方法），getBean()所有重载都是基于doGetBean()方法实现的。
// AbstractBeanFactory.class
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
String beanName = this.transformedBeanName(name);
Object sharedInstance = this.getSingleton(beanName);
Object bean;
if (sharedInstance != null && args == null) {
...
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
...
try {
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
...
// 判断是否是单例
if (mbd.isSingleton()) {
// 获取单例
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
...
} else {
...
}
} catch (BeansException var26) {
this.cleanupAfterBeanCreationFailure(beanName);
throw var26;
}
}
if (requiredType != null && !requiredType.isInstance(bean)) {
...
} else {
return bean;
}
}在这个方法中会根据三级缓存机制拿到缓存的bean，如果都没有则会执行bean的创建流程，即执行createBean()方法，createBean()的核心逻辑都在doCreateBean()方法中，所以我们想要了解bean的生命周期需要集中学习这个代码的执行逻辑。
// AbstractAutowireCapableBeanFactory.class
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
// 实例化
if (instanceWrapper == null) {
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
...
// 判断是否是正在创建的单例Bean
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
...
// 添加到三级缓存
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
try {
// 属性赋值
this.populateBean(beanName, mbd, instanceWrapper);
// 初始化
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
...
}bean的生命周期中的前三个阶段在doCreateBean()中都能定位到对应的方法：
- 实例化（this.createBeanInstance(beanName, mbd, args)）
- 属性赋值（this.populateBean(beanName, mbd, instanceWrapper)）
- 初始化（this.initializeBean(beanName, exposedObject, mbd)）
实例化
传入的参数有三个，第一个beanName没什么好说的，第二个是beanDefinition，第三个是其他参数，这里我们往回追一下beanDefinition是从哪里取的
这里首先会从AbstractBeanFactory类的mergedBeanDefinitons这个map中取
如果去不到则会返回this.getMergedBeanDefinition(beanName, this.getBeanDefinition(beanName))的返回值，其中this.getBeanDefinition(beanName)获取到的beanDefinition对象其实是从beanDefinitionMap中取的，这就跟之前beanDefinition的创建和注册对上了
当前类也的确是BeanDefinitionRegistry的实现类之一
然后getMergedBeanDefinition方法实现中返回的方法实例也是基于getBeanDefinition返回对象进行重载的
属性赋值
属性赋值的参数有三：beanName、beanDefinition和instanceWrapper（刚创建的bean实例对象）
初始化
// AbstractAutowireCapableBeanFactory.class
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
this.invokeAwareMethods(beanName, bean);
return null;
}, this.getAccessControlContext());
} else {
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
// 初始化前扩展
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
// 初始化
try {
this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable var6) {
throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
}
// 初始化后扩展
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}这里有四个扩展点：
- xxxAware。
- 初始化前。this.applyBeanPostProcessorsBeforeInitialization(bean, beanName)。
- 初始化。afterPropertiesSet()。
- 初始化后。this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)。会执行AOP动态代理操作并返回动态代理对象。
发表回复