SpringBean 的生命周期

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

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

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;
	}

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;
		}
	}

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;
	}

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);
			}
		}
	}