码迷,mamicode.com
首页 > 编程语言 > 详细

springBean的生命周期

时间:2020-06-27 13:15:01      阅读:66      评论:0      收藏:0      [点我收藏+]

标签: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> 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初始化过程中搞么事了。

springBean的生命周期

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

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

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!