如果您想了解Springbean的生命周期的相关知识，那么本文是一篇不可错过的文章，我们将对springbean的生命周期面试回答进行全面详尽的解释，并且为您提供关于Bean在SpringBean应用

如果您想了解Spring bean 的生命周期的相关知识，那么本文是一篇不可错过的文章，我们将对springbean的生命周期面试回答进行全面详尽的解释，并且为您提供关于Bean在Spring Bean应用上下文中的生命周期 与 Bean工厂中的生命周期、spring --bean的生命周期、spring bean的生命周期、spring bean的生命周期与springmvc的生命周期的有价值的信息。

• Spring bean 的生命周期（springbean的生命周期面试回答）
• Bean在Spring Bean应用上下文中的生命周期 与 Bean工厂中的生命周期
• spring --bean的生命周期
• spring bean的生命周期
• spring bean的生命周期与springmvc的生命周期

Spring bean 的生命周期（springbean的生命周期面试回答）

学习 spring 源码主框架，从源码角度开发学习 Spring bean 的生命周期。

spring 创建 bean 方法

org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String, java.lang.Class<T>)

public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
		//doGetBean是获取bean的真实方法
		return doGetBean(name, requiredType, null, false);
	}

真正执行 spring 创建 bean 方法 doGetBean

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

protected <T> T doGetBean(
			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
        //获取的beanname可能是重命名后的，这个获取原始的beanname，这里做别名解析
		final String beanName = transformedBeanName(name);
		Object bean;

		//先从spring缓存池中获取bean，这里是解决循环依赖的根本
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean ''" + beanName +
							"'' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean ''" + beanName + "''");
				}
			}
			//如果从缓存中获取到bean，进行后续处理。
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			//判断当前创建的bean是不是原型的，如果存在循环依赖，则抛异常
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			//获取父工厂
			BeanFactory parentBeanFactory = getParentBeanFactory();
			//判断父工厂是否为空，以及当前容器中是否包含bean定义
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				//根据构造函数是否有参数，来创建不同的bean
				if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
            
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
			    //合并bean定义，存在抽象父bean定义，专门给子bean做继承的
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				//检查bean定义的是否为抽象的，如果是则抛出异常
				checkMergedBeanDefinition(mbd, beanName, args);

				//获取bean初始化的前置依赖beanname
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between ''" + beanName + "'' and ''" + dep + "''");
						}
						//解析以来的bean，并注册依赖的bean
						registerDependentBean(dep, beanName);
						try {
					        //递归调用获取依赖bean
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"''" + beanName + "'' depends on missing bean ''" + dep + "''", ex);
						}
					}
				}

				// 创建bean的实例
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							try {
							    //构建bean的实例
								return createBean(beanName, mbd, args);
							}
							catch (BeansException ex) {
								// Explicitly remove instance from singleton cache: It might have been put there
								// eagerly by the creation process, to allow for circular reference resolution.
								// Also remove any beans that received a temporary reference to the bean.
								destroySingleton(beanName);
								throw ex;
							}
						}
					});
					//如果获取的bean是factroybean，那么要处理工厂bean。
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				else if (mbd.isPrototype()) {
					//创建原型bean
					Object prototypeInstance = null;
					try {
					    //在原型bena创建之前回调底层spring函数，开放性方法
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
					    //开放性方法
						afterPrototypeCreation(beanName);
					}
					//如果获取的bean是factroybean，那么要处理工厂bean。
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name ''" + scopeName + "''");
					}
					try {
					    //根据bean定义的scope来创建bean
						Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
							@Override
							public Object getObject() throws BeansException {
								beforePrototypeCreation(beanName);
								try {
									return createBean(beanName, mbd, args);
								}
								finally {
									afterPrototypeCreation(beanName);
								}
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope ''" + scopeName + "'' is not active for the current thread; consider " +
								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// 判断获取的类型是否匹配实际的bean实例
		if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
			try {
				return getTypeConverter().convertIfNecessary(bean, requiredType);
			}
			catch (TypeMismatchException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to convert bean ''" + name + "'' to required type ''" +
							ClassUtils.getQualifiedName(requiredType) + "''", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton (java.lang.String, boolean) 这个方法是解决 spring 循环依赖问题

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        //从一级缓存中获取实例bean，如果有直接返回对象
		Object singletonObject = this.singletonObjects.get(beanName);
		//singletonObject为空并且 beanname是否正在创建中的标识
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		    //防止并发获取bean
			synchronized (this.singletonObjects) {
			    //从earlySingletonObjects早期缓冲池中获取bean
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
				    //从singletonFactories中获取bean的objectfactory
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
					    //调用objectfactory的getObject方法获取singletonObject
						singletonObject = singletonFactory.getObject();
						//同时放到earlySingletonObjects提前暴露出来
						this.earlySingletonObjects.put(beanName, singletonObject);
						//并从singletonFactories移除
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return (singletonObject != NULL_OBJECT ? singletonObject : null);
	}

获取实例 bean

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory<?>)

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "''beanName'' must not be null");
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Creating shared instance of singleton bean ''" + beanName + "''");
				}
				//标识当前正在创建的对象，放到singletonsCurrentlyInCreation缓存中
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<Exception>();
				}
				try {
				    //调用接口objectfacotry的getObject方法， 这个方法被重写
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
					// Has the singleton object implicitly appeared in the meantime ->
					// if yes, proceed with it since the exception indicates that state.
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						throw ex;
					}
				}
				catch (BeanCreationException ex) {
					if (recordSuppressedExceptions) {
						for (Exception suppressedException : this.suppressedExceptions) {
							ex.addRelatedCause(suppressedException);
						}
					}
					throw ex;
				}
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
					//当前bean已经创建好了，到singletonsCurrentlyInCreation中bean移除掉
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {
				    //把创建好的bean加载到缓存池中，并移除二三级缓存
					addSingleton(beanName, singletonObject);
				}
			}
			//对bean判空
			return (singletonObject != NULL_OBJECT ? singletonObject : null);
		}
	}

创建 bean 实例

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean ''" + beanName + "''");
		}
		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// 这里给后置处理器一个机会去创建代理对象，第一次创建bean到这里还没有创建好bean， 仅仅把切面信息解析出来放入缓存中
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}

        //真正执行创建bean实例的方法doCreateBean
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isDebugEnabled()) {
			logger.debug("Finished creating instance of bean ''" + beanName + "''");
		}
		return beanInstance;
	}

真正执行创建 Bean

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
		    //根据@bean， @autowire来创建有参构造函数， 或者无参数构造函数
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
		mbd.resolvedTargetType = beanType;
        
        //允许后置处理器去修改merge后的bean定义
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// 判断earlySingletonObjects是否提前暴露bean对象
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean ''" + beanName +
						"'' to allow for resolving potential circular references");
			}
			//将已经创建好但是属性还没有赋值的bean对象，通过objectfacotry的形式来加载到缓存中用来解决循环依赖的问题
			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
		    //为刚刚创建的bean对象进行赋值
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
			    //初始化bean，并且通过开放性方法为bean赋值
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name ''" + beanName + "'' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"''getBeanNamesOfType'' with the ''allowEagerInit'' flag turned off, for example.");
					}
				}
			}
		}

		try {
		    //注册自定义销毁bean的方法
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

初始化已经创建好的 bean 实例

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        //权限校验是否判断是否可以回调底层组件方法
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged(new PrivilegedAction<Object>() {
				@Override
				public Object run() {
					invokeAwareMethods(beanName, bean);
					return null;
				}
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
		  //实现自定义的bean的后置处理器的前置方法
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
		    //调用自定义的init方法或InitializingBean
			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()) {
		    //实现自定义的bean的后置处理器的后置方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}

以上，就是 spring ioc 模块 bean 生命周期的源代码解析。

还没关注我的公众号？

• 扫文末二维码关注公众号【小强的进阶之路】可领取如下:
• 学习资料： 1T 视频教程：涵盖 Javaweb 前后端教学视频、机器学习 / 人工智能教学视频、Linux 系统教程视频、雅思考试视频教程；
• 100 多本书：包含 C/C++、Java、Python 三门编程语言的经典必看图书、LeetCode 题解大全；
• 软件工具：几乎包括你在编程道路上的可能会用到的大部分软件；
• 项目源码：20 个 JavaWeb 项目源码。

Bean在Spring Bean应用上下文中的生命周期 与 Bean工厂中的生命周期

Bean在Spring Bean应用上下文中的生命周期：

第1步、实例化

第2步、设置属性值

第3步、调用BeanNameAware的setBeanName()方法

第4步、调用BeanFactoryAware的setBeanFactory()方法

第5步、调用ApplicationContextAware方法setApplicationContext()方法

第6步、调用BeanPostProcessor的预初始化方法(before>

第7步、调用InitializingBean的afterPropertiesSet()方法

第8步、调用调用定制的初始化方法

第9步、调用BeanPostProcessor的后初始化方法(after)

第10步、Bean可以使用了

第11步、容器关闭

第12步、调用DisposableBean的destory()方法

第13步、调用定制的销毁方法

Bean在Spring Bean工厂中的生命周期：

第1步、实例化

第2步、设置属性值

第3步、调用BeanNameAware的setBeanName()方法

第4步、调用BeanFactoryAware的setBeanFactory()方法

第5步、调用InitializingBean的afterPropertiesSet()方法

第6步、调用调用定制的初始化方法

第7步、Bean可以使用了

第8步、容器关闭

第9步、调用DisposableBean的destory()方法

第10步、调用定制的销毁方法

spring --bean的生命周期

bean生命周期 概述

protected <T> T doGetBean(
            String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)

bean的生命周期从调用beanfactory的doGetBean开始，到这个bean被销毁，可以总结为以下七个阶段

1. 处理名称，检查缓存
2. 处理父子容器
3. 处理dependsOn
4. 选择Scope策略
5. 创建bean
6. 类型转换处理
7. 销毁bean

1.处理名称，检查缓存

public class Student implements BeanNameAware, InitializingBean, DisposableBean {
    private String age;

    public Student(String age) {
        this.age = age;
        System.out.println(this.toString());
    }

    public void setAge(String age) {
        System.out.println("start setAge");
        this.age = age;
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("start BeanNameAware.setBeanName");
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=''" + age + ''\'''' +
                ''}'';
    }

    @PostConstruct
    public void init() {
        System.out.println("PostConstruct init");
    }

    @PreDestroy
    public void destroy1() {
        System.out.println("PreDestroy destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean.afterPropertiesSet");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean.destroy");
    }

    public void selfInit() {
        System.out.println("selfInit");
    }
}

public class OneProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("start BeanPostProcessor.postProcessBeforeInitialization name=" + s);
        Student student = null;
        if (o instanceof Student) {
            student = (Student) o;
            student.setAge("before");
        }
        return student;
    }

    @Override
    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("start BeanPostProcessor.postProcessAfterInitialization name=" + s);
        Student student = null;
        if (o instanceof Student) {
            student = (Student) o;
            student.setAge("after");
        }
        return student;
    }
}

@Configuration
public class MyConfig {
    @Bean(initMethod = "selfInit")
    public Student student(){
        Student s = new Student("first");
        s.setAge("second");
        return s;
    }

    @Bean
    public OneProcessor myProcessor(){
        return new OneProcessor();
    }
}

package com.lara.springbootconfig.springlife;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author lara
 * @date 2020/9/11 11:29
 */
public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
    }
}

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        //1.调用aware接口方法
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		invokeAwareMethods(beanName, bean);
	}
	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
    //2.调用BeanPostProcessor的before方法
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}
	try {
    //3.调用init方法
		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()) {
    //4.调用BeanPostProcessor的after方法
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}
	return wrappedBean;
}

private void invokeAwareMethods(final String beanName, final Object bean) {
	if (bean instanceof Aware) {
		if (bean instanceof BeanNameAware) {
        //1.调用BeanNameAware接口的setBeanName
			((BeanNameAware) bean).setBeanName(beanName);
		}
		if (bean instanceof BeanClassLoaderAware) {
			ClassLoader bcl = getBeanClassLoader();
			if (bcl != null) {
            //2.调用BeanClassLoaderAware接口的setBeanClassLoader
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		if (bean instanceof BeanFactoryAware) {
        //3.调用BeanFactoryAware接口的setBeanFactory
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
		throws BeansException {
	Object result = existingBean;
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}