springBean的生命周期

标签：only   rcu   判断   实例化   create   缓存   prot   lse   abstract   

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 getBean(String name, Class requiredType) throws BeansException {
		assertBeanFactoryActive();
		return getBeanFactory().getBean(name, requiredType);
	}

接着进入getBean方法

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

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

protected  T doGetBean(final String name, @Nullable final Class 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初始化过程中搞么事了。

springBean的生命周期

标签：only   rcu   判断   实例化   create   缓存   prot   lse   abstract   

原文地址：https://www.cnblogs.com/lifacheng/p/13197937.html