4.Spring 学习 Bean生命周期 源码学习记录

1：当Bean 注入进 IOC 容器中后 会调用到父类的(AbstractApplicationContext) refresh()方法 此处用到一个 模板设计方法

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		this();
		register(componentClasses);
		refresh();
}

2：该方法中定义了一系列方法 先看 finishBeanFactoryInitialization(beanFactory); 方法 ；实例化所有未被延迟加载的单列类

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			try {
				// 实例化所有未被延迟加载的单列类
				finishBeanFactoryInitialization(beanFactory);
			}
			catch (BeansException ex) {
				throw ex;
			}
		}
	}

3：执行该方法 beanFactory.preInstantiateSingletons(); 初始化BeanFactory类 为下一步做准备，并执行 下一步方法 beanFactory.preInstantiateSingletons();

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Instantiate all remaining (non-lazy-init) singletons.
		// 此处进行 实例化所有未被延迟加载的单列类  beanFactory 为 DefaultListableBeanFactory
		beanFactory.preInstantiateSingletons();
	}

4：在 BeanFactory 中进一步进行处理，会去获取Bean

@Override
	public void preInstantiateSingletons() throws BeansException {
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			    //判断是否是FactoryBean 方式注入的
				if (isFactoryBean(beanName)) {
				}
				else {
				    //如果不是 执行该步骤 去获取Bean 此处会调用父类 AbstractBeanFactory 中的  getBean 方法
					getBean(beanName);
				}
			}
		}
	}

5：进入 AbstractBeanFactory 中的 getBean 方法

@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

此代码块中 有一步是在判断 是否是单列

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		try {
			    //获取BeanDefinition信息
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);
				// Create bean instance.
				//此处判断是否是单列 
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
						    // 如果是单列 则会在此处进行创建bean操作
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
				
						}
					});
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
	}

6：创建Bean 操作

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		RootBeanDefinition mbdToUse = mbd;
		try {
		    //在此处进行创建Bean
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			throw ex;
		}
	}

7：创建Bean时做一些额外的操作 populateBean(beanName, mbd, instanceWrapper); 该方法会进行属性值的设置 然后调用initializeBean(beanName, exposedObject, mbd); 进行初始化Bean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
		    //设置属性值
			populateBean(beanName, mbd, instanceWrapper);
			//初始化bean
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		// Register bean as disposable.
		try {
		    // 第九步时注册销毁方法
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

8：初始化Bean的具体操作

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			
		}
		else {
		    //检查Aware接口的检查 如果是 Aware 的子类 那就会执行相关的操作
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
		    //前置BeanPostProcessorsBeforeInitialization 检查并执行
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
		    // 初始化方法执行
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
		    //后置BeanPostProcessorsAfterInitialization 检查并执行
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

9：在第七步中注册销毁Bean方法

// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}

10：添加到单列缓存中

protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}