FactoryBean|-- T getObject(); // |-- Class<?> getObjectType();|-- boolean isSingleton();
CarFactoryBean implements FactoryBean<Car> {Car getObject() {Car car = new Car();String[] infos = carInfo.split(",");car.setBrand(infos[0]);car.setMaxSpeed(Integer.valueOf(infos[1]));car.setPrice(Double.valueOf(infos[2]));return car;}String carInfo;// setter、getter方法
    isSingleton() {return false;}
}
<!-- srping-bean.xml -->
<bean id="car" class="com.test.CarFactoryBean" carInfo="跑车,400,2000"/>
代码实现：getBean("car") -> spring发现CarFactoryBean implements FactoryBean接口，容器调用接口方法CarFactoryBean#getObject()返回getBean("&car") -> CarFactoryBean

Object getSingleton(String beanName) {return getSingleton(beanName, true);
}
Object getSingleton(beanName, allowEarlyReference) {// 检查缓存是否存在Object singletonObject = this.singletonObjects.get(beanName);if (null == getSingleton) {synchronized(this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {// 当某些方法需要提前初始化的时候会调用addSingletonFactory方法将对应的ObjectFactory初始化策略存储在singletongFactoriesObjectFactory singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {// 调用预先设定的getObject方法singletonObject = singletonFactory.getObject();// 记录在缓存中，earlySingletonObjects与singletonFactories互斥this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject != NULL_OBJECT ? singletonObject : null;
}

(1) 对FactoryBean做正确性的验证
(2) 对非FactoryBean不做任务处理
(3) 对bean进行转换
(4) 将从Factory中解析bean的工作委托给getObjectFromFactoryBeangetObjectForBeanInstance(beanInstance, name, beanName, mbd) {// &testBeanFactoryif (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {throw e;}// &testBeanFactoryif (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {return beanInstance;}// 加载factoryBeanObject object = null;if (mbd == null) {// 尝试从缓存中加载beanobject = getCachedObjectForFactoryBean(beanName);}if (object == null) {FactoryBean<?> factory = (FactoryBean<?>) beanInstance;if (mbd == null && containsBeanDefinition(beanName)) {mbd = getMergedLocalBeanDefinition(beanName);}// 是否是用户定义的而不是应用程序本身定义的boolean synthetic = (mbd != null && mbd.isSynthetic());object = getObjectFromFactoryBean(factory, beanName, !synthetic);}
}
getObjectFromFactoryBean(factory, beanName, shouldPostProcess) {// 如果是单例if (factory.isSingleton() && containsSingleton(beanName)) {synchronized(getSingletonMutex()) {Object object = this.factoryBeanObjectCache.get(beanName);if (object == null) {object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);this.factoryBeanObjectCache.put(beanName, object);}return object;}} else {return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);}
}
doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess) {Object object = null;try {if (System.getSecurityManager() != null) { // 权限验证try {Object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>(){run() {return factory.getObject();}});} catch (e) {throw e;}} else {object = factory.getObject();}} catch (e) {throw e;}if (object != null && shouldPostProcess) {try {object = postProcessObjectFromFactoryBean(object, beanName);} catch (e) {throw e;}}return object;
}
postProcessObjectFromFactoryBean(object, beanName) {return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {Object result = existingBean;for (BeanPostProcessor beanPostProcessor : getBeanPostProcessors()) {result = beanPostProcessor.postProcessorsAfterInitialization(result, beanName);return result;}return result;
}

(1) 检查缓存是否已经加载过
(2) 若没有加载，则记录beanName的正在加载状态
(3) 加载单例前记录加载状态
(4) 通过调用参数传入的ObjectFactory的个体Object实例化bean
(5) 加载单例后的处理方法调用
(6) 将结果记录到缴存并删除加载bean过程中所记录的各种辅助状态
(7) 返回处理结果
getSingleton(beanName, new ObjectFactory) {synchronized (this.singletonObjects) {Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {beforeSingletonCreation(beanName);try {singletonObject = singletonFactory.getObject();} catch (e) {throw e;} finally {afterSingletonCreation(beanName);}// 加入缓存
            addSingleton(beanName, singletonObject);}}return (singletonObject != NULL_OBJECT ? singletonObject : null)
}
beforeSingletonCreation(beanName) {if (!this.singletonsCurrentlyCreation.add(beanName)) { // 将当前正要创建的bean记录在缓存中，这样便可以对循环依赖进行检测throw e;}
}
afterSingletonCreation(beanName) {if (!this.singletonsCurrentlyCreation.remove(beanName)) { // 加载结束后，移除缓存中对该bean正在加载状态的记录throw e;}
}
addSingleton(beanName, singletonObject) {synchronized (this.singletonObjects) {// 将结果记录到缓存，并删除加载bean过程中所记录的辅助状态this.singletonObjects.put(beanName, singletonObject);this.singletonFatories.remove(beanName);this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}
}
getSingleton(beanName, new ObjectFactory<Object>(){public Object getObject() {try {return createBean(beanName, mbd, args);} catch (e) {throw e;}}
});

(1) 根据设置的class属性，或者根据className来解析class
(2) 对override属性进行标记及验证
(3) 应用初始化前的后处理器，解析指定bean是否存在初始化前的短路操作
(4) 创建bean
createBean(beanName, mbd, args) {// 根据设置的class属性，或者根据className来解析class
    resolveBeanClass(mbd, beanName);// 对override属性进行标记及验证try {mbd.prepareMethodOverrides();} catch (e) {throw e;}// 给BeanPostProcessors一个机会返回代理来替代真正的实例Object bean = resolveBeforeInstantiation(beanName, mbd);if (bean != null) {return bean;}// 创建beanObject beanInstance = doCreateBean(beanName, mbd, args);return beanInstance;
}prepareMethodOverrides() {MethodOverrides methodOverrides = getMethodOverrides();for (MethodOverride mo : MethodOverrides) {prepareMethodOverride(mo);}
}
// lookup-method、replace-method属性
prepareMethodOverride(mo) {// 获取对应类中对应方法名的个数int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());if (count == 0) {throw e;} else if (count == 1) {// 标记未被覆盖，避免参数类型检查的开销mo.setOverloaded(false);}
}
|-- 实例化前置处理
resolveBeforeInstantiation(beanName, mbd) {Object bean = null;try {bean = applyBeanPostProcessorsBeforeInitialization(mbd.getBeanClass(), beanName);if (bean != null) {bean = applyBeanPostProcessorsAfterInitialization(mbd.getBeanClass(), beanName);}mbd.beforeInstantiationResolved = (bean != null);} catch (e) {throw e;}return bean;
}
|-- 实例化前的处理器应用
applyBeanPostProcessorsBeforeInitialization(beanClass, beanName) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;Object result = ibp.postProcessorsBeforeInitialization(beanClass, beanName);if (result != null) {return result;}}}return null;
}
|-- 实例化后的处理器应用
applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {Object result = existingBean;for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {Object result = beanProcessor.postProcessorsAfterInitialization(result, beanName);if (result != null) {return result;}}return result;
}

(1) 循环依赖定义：循环依赖就是循环引用，就是存在2个或多个bean相互之间的持有对方，如：A->B->C->A，A->B->A
(2) 循环依赖的类型：构造器循环依赖、setter循环依赖
5.6.1 构造器循环依赖处理TestA、TestB、TestCTestA -> 查找“当前创建bean池”，如果没发现则继续准备构造器参数“testB”，并将“testA”标识符放到“当前创建bean池”TestB -> 查找“当前创建bean池”，如果没发现则继续准备构造器参数“testC”，并将“testB”标识符放到“当前创建bean池”TestC -> 查找“当前创建bean池”，如果没发现则继续准备构造器参数“testA”，并将“testC”标识符放到“当前创建bean池”准备构造器参数“testA”时，发现该 bean的标识符在“当前创建bean池”存在，抛出BeanCurrentlyInCreationException。5.6.2 setter循环依赖处理TestA、TestB、TestCTestA -> 暴露ObjectFactory工厂，并将“testA”标识符放到“当前创建bean池”，然后进行setter注入“testB”TestB -> 暴露ObjectFactory工厂，并将“testB”标识符放到“当前创建bean池”，然后进行setter注入“testC”TestC -> 暴露ObjectFactory工厂，并将“testC”标识符放到“当前创建bean池”，然后进行setter注入“testA”，进入注入“TestA”时由于提前暴露了“ObjectFactory”工厂，从而使用它返回提前暴露一个创建中的bean。最后依赖注入"TestB"、"TestA"，完成setter注入。5.6.3 prototype范围的依赖处理scope="prototpye" -> 由于prototpye作用域无法完成依赖注入，spring容器不进行缓存prototype作用域的bean，因此无法提前暴露一个创建中的bean。scope="singleton" -> setAllowCircularReferences(false); // 禁用循环引用

(1) 如果是单例则需要首先清除缓存
(2) 实例化bean，将BeanDefinition转换为BeanWrapper
(3) MergedBeanDefinitionPostProccessor的应用
(4) 依赖处理
(5) 属性填充
(6) 循环依赖检查
(7) 注册DisposableBean
(8) 完成创建并返回
protected Object doCreateBean(final String beanName, final RooBeanDefinition mbd, final Object[] args) {BeanWrapper instanceWrapper = null;// 如果是单例则需要首先清除缓存if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanObjectCache.remove(beanName);}// 实例化bean，将BeanDefinition转换为BeanWrapperif (instanceWrapper == null) {instanceWrapper = createBeanInstance(beanName, mbd, args);}final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);// MergedBeanDefinitionPostProccessor的应用
    synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {applyMergedBeanDefinitionPostProccessor(mbd, beanType, beanName);}}// 依赖处理// 是否需要提前暴露（单例&循环引用&当前bean正在创建中）boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletongCurrentlyInCreation(beanName));if (earlySingletonExposure) {// 为避免循环依赖，在bean初始化完成前将创建实例的ObjectFactory加入工厂addSingletonFactory(beanName, new ObjectFactory(){public Object getObject() throw e {// 对bean的再一次依赖引用return getEarlyBeanReferences(beanName, mbd, bean);}});}Object exposedObject = bean;// 属性填充try {populateBean(beanName, mbd, instanceWrapper);if (exposedObject != null) {// 调用初始化方法，init-methodexposedObject = initializeBean(beanName, exposedObject, mbd);}} catch (e) {throw e;}// 循环依赖检查if (earlySingletonExposure) {Object earlySingletonReference = getSingleton(beanName, false);if (earlySingletonReference != null) {// exposedObject没有在初始化方法改变，说明没有被增强if (exposedObject == null) {exposedObject = earlySingletonReference;} else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {String[] dependentBeans = getDependentBeans(beanName);Set<String> actualDependentBeans = new LinkedHashSet<String>();for (String dependentBean : dependentBean) {// 检测依赖if (!removeSingletonIfCreateForTypeCheckOnly(dependentBean)) {actualDependentBeans.add(dependentBean);}}if (!actualDependentBeans.isEmpty()) {throw e; }}}}// 注册DisposableBeantry {registerDisposableBeanIfNecessary(beanName, bean, mbd);} catch (e) {throw e;}return exposedObject;
}

(1) InstantiationAwareBeanPostProcessor处理器的postProcessAfterInstantiation函数的应用，此函数可以控制程序是否继续进行属性填充
(2) 根据类型，提取依赖bean，并统一存入PropertyValues中。
(3) 应用InstantiationAwareBeanPostProcessor处理器的postProcessPropertyValues方法，对属性获取完毕填充前对属性的再次处理，RequiredAnnotationBeanPostProcessor对属性的验证
(4) 将所有PropertyValues中的属性填充至BeanWrapper中
populateBean(beanName, mbd, bw) {PropertyValues pvs = mbd.getPropertyValues();if (bw == null) {if (!pvs.isEmpty()) {throw e;} else {// 没有属性填充return ;}}boolean continueWithPropertyPopulation = true;for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;// 返回值是否继续填充beanif (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {continueWithPropertyPopulation = false;break;}}}// 如果后处理器发出停止填充命令则终止后续的执行if (!continueWithPropertyPopulation) {return;}if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_TYPE) {MutablePropertyValues newPvs = new MutablePropertyValues(pvs);if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_NAME) {autowireByName(beanName, mbd, bw, newPvs);}if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_TYPE) {autowireByType(beanName, mbd, bw, newPvs);}pvs = newPvs;}// 后处理器已经初始化boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();// 需要检查依赖boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);if (hasInstAwareBpps || needsDepCheck) {PropertyDescriptor[] filteredPds = filterPropertyDescriptionsForDependencyCheck(bw);if (hasInstAwareBpps) {for (BeanPostProcessor bp : getBeanPostProcessors()) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;// 对所有需要依赖检查的属性进行后处理pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);if (pvs == null) {return;}}} if (needsDepCheck) {checkDependences(beanName, mbd, filteredPds, pvs);}}// 将属性应用到bean中
    applyPropertyValues(beanName, mbd, bw, pvs);
}
// 根据name注入属性
autowireByName(beanName, mbd, bw, newPvs) {String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);for (String propertyName : propertyNames) {if (containsBean(propertyName)) {// 递归初始化相关的beanObject bean = getBean(propertyName);pvs.add(propertyName, bean);// 注册依赖
            registerDependentBean(propertyName, beanName);} else {if (logger.isTraceEnabled()) {logger.trace(...);}}}
}
// 根据type注入属性
autowireByType(beanName, mbd, BeanWrapper bw, newPvs) {try {TypeConverter converter = getCustomTypeConverter();if (converter == null) {converter = bw;}Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);// 寻找bw中需要依赖注入的属性String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);for (String propertyName : propertyNames) {PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);if (!Object.calss.equals(pd.getProperType())) {// 探测指定的set方法MethodParamter methodParam = BeanUtils.getWriteMethodParamter(pd);boolean eager = PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());PropertyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);// 解析指定的属性所匹配的值，并把解析到的属性的名称存储在autowiredBeanNames中，当属性存在多个封装bean时：// @Autowired private List<A> aList; 将会找到所有匹配A类型的bean将其注入Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);if (autowiredArgument != null) {pvs.add(propertyName, autowiredArgument);}for (String autowiredBeanName : autowiredBeanNames) {// 注册依赖
                    registerBeanDefinition(autowiredBeanName, beanName);}autowiredBeanNames.clear();}}} catch (e) {throw e;}
}
resolveDependency(descriptor, beanName, Set<String> autowiredBeanNames, typeConverter) {descriptor.initParamterNameDisconvery(getParamterNameDisconverer());// ObjectFactory类注入的特殊处理if (descriptor.getDependencyType().equals(ObjectFactory.class)) {return new DependencyObjectFactory(descriptor, beanName);}else if (... eq javaxInjectProviderClass) {return new DependencyObjectFactory().createDependencyProvider(descriptor, beanName);}else {// 通用逻辑处理return doResolvedDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter);}
}
doResolvedDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter) {// 用于支持spring中新增的注解@valueObject value = getAutowireCandidateResolver().getSuggestedValue(descriptor);if (value != null) {if (value instanceof String) {value = evaluateBeanDefinitionString(strVal, bd);}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());return converter.convertIfNecessary(value, type);}// 属性是数组类型if (type.isArray()) { // 数组类型Class<?> componentType = type.getComponentType();Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);if (matchingBeans.isEmpty()) {if (descriptor.isRequired()) {raiseNoSuchBeanDefinitionException(componentType, componentType.getName(), descriptor);}return null;}if (autowiredBeanNames != null) {autowiredBeanNames.addAll(matchingBeans.keySet());}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());return converter.convertIfNecessary(matchingBeans.values(), type);}else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {// 集合类型Class<?> elementType = descriptor.getCollectionType();if (elementType == null) {if (descriptor.isRequired()) {throw e;}return null;}Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);if (matchingBeans.isEmpty()) {throw e;}if (autowiredBeanNames != null) {autowiredBeanNames.addAll(matchingBeans.keySet());}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());return converter.convertIfNecessary(matchingBeans.values(), type);} else if (Map.class.isAssignableFrom(type) && type.isInterface()) {// Map类型Class<?> keyType = descriptor.getMapKeyType();if (keyType == null) {if (descriptor.isRequired()) {throw e;}return null;}Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);if (matchingBeans.isEmpty()) {throw e;}if (autowiredBeanNames != null) {autowiredBeanNames.addAll(matchingBeans.keySet());}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());return converter.convertIfNecessary(matchingBeans.values(), type);}else {Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);if (matchingBeans.isEmpty()) {throw e;}if (matchingBeans.size() > 1) {String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor);if (primaryBeanName == null) {throw e;}if (autowiredBeanNames != null) {autowiredBeanNames.add(primaryBeanName);}return matchingBeans.get(primaryBeanName);}// 已经可以确定只有一个匹配项Map.Entry<String,Object> entry = matchingBeans.entrySet().iterator().next();if (autowiredBeanNames != null) {autowiredBeanNames.add(entry.getKey());}return entry.getValue();}
}
// 将属性应用到bean中
applyPropertyValues(beanName, mbd, bw, pvs) {if (pvs == null || pvs.isEmpty()) {return;}MutablePropertyValues mpvs = null;List<PropertyValue> original;if (bw instancof BeanWrapperImpl) {((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());}if (pvs instanceof MutablePropertyValues) {mpvs = (MutablePropertyValues) pvs;// 如果mpvs中的值已经被转换为对应的类型那么可以直接设置到beanWrapper中try {if (mpvs.isConverted()) {bw.setPropertyValues(mpvs);return;}} catch (e) {throw e;}original = mpvs.getPropertyValueList();} else {// 非MutablePropertyValues封装的类型，那么直接使用原始的属性获取方法original = Arrays.asList(pvs.getPropertyValues());}TypeConverter converter = getCustomTypeConverter();if (converter == null) {converter = bw;}// 获取对应的解析器BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);// Create a deep copy, resolving any references for values.List<PropertyValue> deepCopy = new ArrayList<String>(original.size());boolean resolveNecessary = false;for (PropertyValue pv : original) {if (pv.isConverted()) {deepCopy.add(pv);} else {String propertyName = pd.getName();Object originalValue = pd.getValue();Object resolvedValue = valueResolver.resolveValueIfNecessay(pv, originalValue);Object convertedValue = resolvedValue;boolean convertible = (bw.isWritableProperty(propertyName) && !PropertyUtils.isNestedIndexedProperty(propertyName));if (convertible) {convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);}if (convertedValue == originalValue) {if (convertible) {pv.setConvertedValue(convertedValue);}deepCopy.add(pv);}else if (convertible && originalValue instanceof TypedStringValue && !((TypedStringValue) originalValue).isDynamic() &&!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))){pv.setConvertedValue(convertedValue);deepCopy.add(pv);}else {resolveNecessary = true;deepCopy.add(new PropertyValue(pv, convertedValue));}}}if (mpvs != null && !resolveNecessary) {mpvs.setConverted();}try {bw.setPropertyValues(new MutablePropertyValues(deepCopy));} catch (e) {throw e;}
}

// spring容器已经执行过bean的实例化，并且进行了属性填充，而就是这时将会调用用户设定的初始化方法
initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {if (System.getSecurityMananger() != null) {AccessController.doPrivileged(new PrivilegedAction<Object>(){Object run() {invokeAwareMethods(beanName, bean);return null;}});} else {// 对特殊的bean处理：Aware、BeanClassLoaderAware、BeanFactoryAware
        invokeAwareMethods(beanName, bean);}Object wrappedBean = bean;if (mbd != null || !mbd.isSynthetic()) {// 应用前处理器wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);}try {// 激活用户自定义的init方法
        invokeInitMethod(beanName, wrappedBean, mbd);} catch (e) {throw e;}if (mbd != null || !mbd.isSynthetic()) {// 后处理器应用wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);}return wrappedBean;
}
invokeAwareMethods(final String beanName, final Object bean) {if (bean instanceof Aware) {if (bean instanceof BeanNameAware) {((BeanNameAware) bean).setBeanName(beanName);}if (bean instanceof BeanClassLoaderAware) {((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());}if (bean instanceof BeanFactoryAware) {((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);}}
}
// 处理器应用
applyBeanPostProcessorsBeforeInitialization(existingBean, beanName) {Object result = existingBean;for ( BeanPostProcessor beanProcessor : getBeanPostProcessors()) {result = beanProcessor.postProcessBeforeInitialization(result, beanName);if (result == null) {return result;}}return result;
}
applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {Object result = existingBean;for ( BeanPostProcessor beanProcessor : getBeanPostProcessors()) {result = beanProcessor.postProcessAfterInitialization(result, beanName);if (result == null) {return result;}}return result;
}
// 激活用户自定义的init方法
invokeInitMethod(beanName, bean, mbd) {// 检查是否是InitializingBean，如果是则调用afterPropertiesSet方法boolean isInitializingBean = (bean istanceof InitializingBean);if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {if (System.getSecurityManager() != null) {try {AccessController.doPrivileged(new PrivilegedExceptionAction<Object>(){Object run() {((InitializingBean) bean).afterPropertiesSet();return null;}});} catch (e) {throw e;}} else {((InitializingBean) bean).afterPropertiesSet();}}if (mbd != null) {String initMethodName = mbd.getInitMethodName();if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName))&& !mbd.isExternallyManagedInitMethod(initMethodName)) {// 调用自定义初始化方法
            invokeCustomInitMethod(beanName, bean, mbd);}}
}

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);if (!mbd.isPrototype() && requiredDestruction(bean, mbd)) {if (mbd.isSingleton()) {// 单例模式下需要注册需要销毁的bean，此方法中会处理实现DisposableBean的bean，// 并且对所有的bean使用DestrunctionAwareBeanPostProccessors处理// DisposableBean DestrunctionAwareBeanPostProccessorsregisterDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));} else {scope scope = this.scopes.get(mgd.getScope());if (scope == null) {throw e;}scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));}}
}