标签：only rcu 判断 实例化 create 缓存 prot lse abstract
有的大兄弟目前还停留在使用spring的过程，对spring的核心Bean还没有什么了解。今天就和大家就从springBean的生命周期入手。
生命周期就是指一个对象的生老病死。 嗯， 解释的很生动，形象。springBean的生命周期也就是一个Bean从出生，到死亡的过程。
入口： org.springframework.beans.factory.BeanFactory#getBean， 有时候，我们看代码并不是难事， 难的是如何找到入口。 这个当然得开动脑筋了，想想怎么用的。
我们要找到Bean， 就得从GetBean开始，如果get不到，肯定就会去创建啦。找到了创建，那只要一条路走下去，我们就可以弄清楚Bean的生命周期了。
从
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的生命周期了。
通过上面的代码分析，总结下来的生命周期图，如下所示。
自此，搞懂生命周期啦，接下来，就看大家自己如何操作代码了，在bean初始化过程中搞么事了。
标签：only rcu 判断 实例化 create 缓存 prot lse abstract
原文地址：https://www.cnblogs.com/lifacheng/p/13197937.html
