SpringBean 的生命周期

发布于: 2020 年 06 月 27 日
SpringBean的生命周期

1. 背景

有的大兄弟目前还停留在使用spring的过程,对spring的核心Bean还没有什么了解。今天就和大家就从springBean的生命周期入手。

2. 什么是生命周期

生命周期就是指一个对象的生老病死。 嗯, 解释的很生动,形象。springBean的生命周期也就是一个Bean从出生,到死亡的过程。

3. Show code

3.1 入口

入口: org.springframework.beans.factory.BeanFactory#getBean, 有时候,我们看代码并不是难事, 难的是如何找到入口。 这个当然得开动脑筋了,想想怎么用的。

3.2 入口举例

我们要找到Bean, 就得从GetBean开始,如果get不到,肯定就会去创建啦。找到了创建,那只要一条路走下去,我们就可以弄清楚Bean的生命周期了。

3.3 开始代码:

getBean点个方法进去,找到org.springframework.context.support.AbstractApplicationContext中的方法

@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
assertBeanFactoryActive();
return getBeanFactory().getBean(name, requiredType);
}

接着进入getBean方法

@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
// 具体获取bean的方法。
return doGetBean(name, requiredType, null, false);
}

进入doGetBean,部分代码删掉了,我们核心只关注创建Bean的方法,不关注中间的细节问题

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
...
// Eagerly check singleton cache for manually registered singletons.
// 获取Bean实例,设计到多级缓存解决循环依赖问题。
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
...
}
else {
...
try {
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
// 创建Bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
}
return (T) bean;
}

进入createBean方法。找到doCreateBeann的方法,这个是真正干活的。 在spring中,一般具体干活的都是doSomething方法。

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
try {
...
// 创建Bean的具体方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
}

进入doCreateBean方法。Everybody, 重点来了, 这就是今天的重点。如何创建bean,以及设计到如何解决循环依赖问题(这个就稍微提一下)。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 通过构造函数生成对象。此时仅仅是调用了构造函数。里面的字段,对象还未被赋值
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 生成的Bean对象放在beanWrapperInstance里面
final Object bean = instanceWrapper.getWrappedInstance();
...
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) { // 判断是否是单例,以及是否解决循环引用。
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// getEarlyBeanReference方法可以对实现SmartInstantiationAwareBeanPostProcessor接口的的bean进行增强。
// 这个增强也是我理解为什么要放入三级缓存。
// addSingletonFactory 将生成的对象放入到singletonFactories中。 即三级缓存中的第三级。在放入的过程中,也解决
// bean单例和原型的问题
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 填充bean, 即对bean里面的自动注入的字段进行填充
populateBean(beanName, mbd, instanceWrapper);
// 这个就是Bean在实例化后,要执行的逻辑,包含beanPostProcessor,Aware接口等。
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
}
if (earlySingletonExposure) {
...(// 先不关心这个)
}
...
return exposedObject;
}

initializeBean

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
...
// 调用aware接口
invokeAwareMethods(beanName, bean);
...
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// beanpostProcessor前置方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 调用InitializingBean#afterPropertiesSet 方法, 以及定义的 init-method。
invokeInitMethods(beanName, wrappedBean, mbd);
}
...
if (mbd == null || !mbd.isSynthetic()) {
// beanpostProcessor后置方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
...
// 调用afterPropertiesSet方法
((InitializingBean) bean).afterPropertiesSet();
}
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
// 调用 init-method方法
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}

bean销毁的代码在AbstractApplicationContext#destroyBeans中,从disposableBeans中,找到实现了DisposableBean接口的方法,执行destory()方法即可。

自此,bean创建的过程我们看完了。那么接下来就是总结bean的生命周期了。

4 总结

通过上面的代码分析,总结下来的生命周期图,如下所示。

自此,搞懂生命周期啦,接下来,就看大家自己如何操作代码了,在bean初始化过程中搞么事了。

发布于: 2020 年 06 月 27 日 阅读数: 24
用户头像

编号94530

关注

你的每一个点赞我都当成了喜欢 2020.04.29 加入

公众号: 星球x 欢迎大家关注,谢谢!

评论

发布
暂无评论
SpringBean的生命周期