Spring的BeanFactory

最新推荐文章于 2024-08-17 17:32:26 发布

向着风奔跑

最新推荐文章于 2024-08-17 17:32:26 发布

阅读量562

点赞数

分类专栏： spirng

本文链接：https://blog.youkuaiyun.com/liulong1010/article/details/104733911

版权

spirng 专栏收录该内容

5 篇文章

订阅专栏

BeanFactory是Spring的核心接口，负责管理Bean的创建、自动装配和初始化。ListableBeanFactory提供了获取Bean配置清单的能力，HierarchicalBeanFactory支持父子BeanFactory，ConfigurableBeanFactory和AutowireCapableBeanFactory则增强了配置和自动装配功能。ConfigurableListableBeanFactory结合了多种接口，提供了全面的Bean管理。此外，还涉及到了别名注册、Bean定义注册以及FactoryBean的特殊处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

BeanFactory

在这里插入图片描述

BeanFactory 定义获取Bean以及Bean的各种属性，顶层接口
ListableBeanFactory 根据各种条件获取获取Bean的配置清单
HierarchicalBeanFactory 继承关系BeanFactory，增加了对parentFactory支持
ConfigurableBeanFactory 提供配置Factory的各种方法
AutowireCapableBeanFactory 提供创建bean，自动注入，初始化以及应用Bean的后置处理器
AbstractAutowireCapableBeanFactory中综合AbstractBeanFactory并对接口AutowireCapableBeanFactory进行实现
ConfigurableListableBeanFactoryBeanFactory配置清单，指定忽略类型以及接口等
AliasRegistry 定义对alias的简单增删改等操作
SimpleAliasRegistry 主要使用map作为alias的缓存，并对接口AliasRegistry进行实现
SingletonBeanRegistry 定义对单例的注册机获取的接口
DefaultSingletonBeanRegistry 对接口SingletonBeanRegistry的实现
FactoryBeanRegistrySupport 在DefaultSingletonBeanRegistry基础上增加了对FactoryBean的特殊处理
AbstractBeanFactory 综合FactoryBeanRegistrySupport 和ConfigurableBeanFactory的功能，提供抽象实现
BeanDefinitionRegistry 定义对BeanDefinition的各种增删改操作
DefaultListableBeanFactory 综合上面所有功能，主要是对Bean注册后的处理

BeanFactory

/*
 * @see BeanNameAware#setBeanName
 * @see BeanClassLoaderAware#setBeanClassLoader
 * @see BeanFactoryAware#setBeanFactory
 * @see org.springframework.context.ResourceLoaderAware#setResourceLoader
 * @see org.springframework.context.ApplicationEventPublisherAware#setApplicationEventPublisher
 * @see org.springframework.context.MessageSourceAware#setMessageSource
 * @see org.springframework.context.ApplicationContextAware#setApplicationContext
 * @see org.springframework.web.context.ServletContextAware#setServletContext
 * @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessBeforeInitialization
 * @see InitializingBean#afterPropertiesSet
 * @see org.springframework.beans.factory.support.RootBeanDefinition#getInitMethodName
 * @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessAfterInitialization
 * @see DisposableBean#destroy
 * @see org.springframework.beans.factory.support.RootBeanDefinition#getDestroyMethodName
 */
public interface BeanFactory { 
	//对 FactoryBean 的转义定义，因为如果使用 bean 的名字检索 FactoryBean 得到的对象是工厂生成的对象，
	//  如果需要得到工厂本身，需要转义
	String FACTORY_BEAN_PREFIX = "&";
	//根据 bean 的名字，获取在 IOC 容器中得到 bean 实例
	Object getBean(String name) throws BeansException;
	//根据 bean 的名字和 Class 类型来得到 bean 实例，增加了类型安全验证机制。
	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
	Object getBean(String name, Object... args) throws BeansException;
	<T> T getBean(Class<T> requiredType) throws BeansException;
	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
	
	//  5.1  Bean实例的提供工厂
	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
	
	// 提供对 bean 的检索，看看是否在 IOC 容器有这个名字的 bean
	boolean containsBean(String name);
	// 根据bean的名称判断bean的类型，如单例，原型
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
	//得到 bean 实例的 Class 类型
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
	@Nullable
	Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
	//得到 bean 的别名，如果根据别名检索，那么其原名也会被检索出来
	String[] getAliases(String name);
}

ListableBeanFactory

根据各种条件获取获取Bean的配置清单

/**
 * 该接口是对BeanFactory的扩展，允许预加载bean定义的BeanFactory可以实现此接
 * 其目的在于使实现它的BeanFactory能够枚举所有的Bean
 * 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
 * 也即该接口只能枚举当前facotry的Bean
 * 除getBeanNamesOfType，getBeansOfType方法外，其他方法也将忽略由SingletonBeanRegistry的方法
 * 注册的Singleton Bean
 * 除getBeanDefinitionCount和containsBeanDefinition外的方法不要频繁使用，性能很慢
 */
public interface ListableBeanFactory extends BeanFactory {
   /**
     * 根据给出的BeanName判断是否包含该Bean定义
     * 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
     * 也即该接口只能枚举当前facotry的Bean 忽略由SingletonBeanRegistry的方法 注册的Singleton Bean
     */
	boolean containsBeanDefinition(String beanName);
	 /**
     * 返回Bean定义的数目 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
     * 也即该接口只能枚举当前facotry的Bean 忽略由SingletonBeanRegistry的方法 注册的Singleton Bean
     */
	int getBeanDefinitionCount();
 	/**
     * 返回所有Bean的BeanName组成的String数组
     */
	String[] getBeanDefinitionNames();
    /**
     * 根据提供的类型返回匹配的BeanName数组 只检测顶层Bean，忽略嵌套Bean
     * 对于FactoryBean，当提供的类型匹配FactoryBean.getObjectType时返回BeanName
     * 当提供的类型匹配FactoryBean时返回&BeanName
     * 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
     * 也即该接口只能枚举当前facotry的Bean 不忽略由SingletonBeanRegistry的方法时注册的Singleton Bean
     * 不检测无法实例化的Bean(如抽象Bean)
     */
	String[] getBeanNamesForType(ResolvableType type);
	/**
     * 同上 String[] getBeanNamesForType(@Nullable Class<?> type);
     * /** 作用同上 includeNonSingletons：判断是否匹配除Singleton外的其他scope allowEagerInit:
     * false只匹配FactoryBean本身，true时还匹配FactoryBean.getObjectType()
     */
	String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit);
   /**
     * 根据提供的类型返回匹配的Bean实例数组 只检测顶层Bean，忽略嵌套Bean
     * 对于FactoryBean，当提供的类型匹配FactoryBean.getObjectType时返回BeanName
     * 当提供的类型匹配FactoryBean时返回&BeanName
     * 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
     * 也即该接口只能枚举当前facotry的Bean 不忽略由SingletonBeanRegistry的方法时注册的Singleton Bean
     * 不检测无法实例化的Bean(如抽象Bean)
     */
	String[] getBeanNamesForType(@Nullable Class<?> type);

 	 /**
     * 同上 String[] getBeanNamesForType(@Nullable Class<?> type);
     * 
     * /** 作用同上 includeNonSingletons：判断是否匹配除Singleton外的其他scope allowEagerInit:
     * false只匹配FactoryBean本身，true时还匹配FactoryBean.getObjectType()
     */
	String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);
 	/**
     * 根据提供的类型返回匹配的Bean实例数组 只检测顶层Bean，忽略嵌套Bean
     * 对于FactoryBean，当提供的类型匹配FactoryBean.getObjectType时返回BeanName
     * 当提供的类型匹配FactoryBean时返回&BeanName
     * 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
     * 也即该接口只能枚举当前facotry的Bean 不忽略由SingletonBeanRegistry的方法时注册的Singleton Bean
     * 不检测无法实例化的Bean(如抽象Bean)
     */
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
  	/**
     * 作用同上 includeNonSingletons：判断是否匹配除Singleton外的其他scope allowEagerInit:
     * false只匹配FactoryBean本身，true时还匹配FactoryBean.getObjectType()
     */
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
			throws BeansException;

	/**
     * 根据提供的注解类型找到对于的BeanName数组， 不创建实例， 但FactoryBean类型将被初始化，因为该方法考虑FactoryBean创建的对象
     */
	String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
	/**
     * 根据提供的注解类型找到对于的Bean实例数组， FactoryBean类型将被初始化，因为该方法考虑FactoryBean创建的对象
     */
	Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;

 	/**
     * 根据提供的注解类型和beanNaeme找到对应的Bean，Bean的类类型本身找不到，则遍历它的 接口和超类
     * 如果不存在该Bean，则抛出NoSuchBeanDefinitionException 如果该Bean不支持该注解类型则返回null
     */
	<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
			throws NoSuchBeanDefinitionException;

HierarchicalBeanFactory

/*
 *  这个类接口比较简单 故名思义
 * @see org.springframework.beans.factory.config.ConfigurableBeanFactory#setParentBeanFactory
 */
public interface HierarchicalBeanFactory extends BeanFactory {
	@Nullable
	BeanFactory getParentBeanFactory();
	boolean containsLocalBean(String name);
}

ConfigurableBeanFactory

/* 
 * 提供配置Factory的各种方法
 * @see org.springframework.beans.factory.BeanFactory
 * @see org.springframework.beans.factory.ListableBeanFactory
 * @see ConfigurableListableBeanFactory
 */
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
	// 定义了两个作用域: 单例和原型.可以通过registerScope来添加.
	String SCOPE_SINGLETON = "singleton";
	String SCOPE_PROTOTYPE = "prototype";
	 // 父容器设置.而且一旦设置了就不让修改 搭配HierarchicalBeanFactory接口的getParentBeanFactory方法
	void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
	 // 类加载器设置与获取.默认使用当前线程中的类加载器
	void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);
	@Nullable
	ClassLoader getBeanClassLoader();
 	// 为了类型匹配,搞个临时类加载器.好在一般情况为null,使用上面定义的标准加载器
    /*
     * 设置、返回一个临时的类加载器
     */
	void setTempClassLoader(@Nullable ClassLoader tempClassLoader);

	@Nullable
	ClassLoader getTempClassLoader();

     /* 
     * 是否需要缓存bean metadata,比如bean difinition 和 解析好的classes.默认开启缓存
     * 设置、是否缓存元数据，如果false，那么每次请求实例，都会从类加载器重新加载（热加载）
     */
	void setCacheBeanMetadata(boolean cacheBeanMetadata);
	boolean isCacheBeanMetadata();
     /*
     * 定义用于解析bean definition的表达式解析器
     * Bean表达式分解器 supporting "#{...}" expressions in a Unified EL compatible style.
     */
	void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
	@Nullable
	BeanExpressionResolver getBeanExpressionResolver();
    // 类型转化器
    // 指定一个Spring3.0 ConversionService来进行属性值的转换,是JavaBean中PropertyEditor的一种替代品
	void setConversionService(@Nullable ConversionService conversionService);
	@Nullable
	ConversionService getConversionService();
	 // 属性编辑器
	void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
	// 注册自定义属性编辑器
	void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
	// 使用一个已经在BeanFactory里注册过的自定义属性编辑器来初始化给定的PropertyEditorRegistry.
	void copyRegisteredEditorsTo(PropertyEditorRegistry registry); 
    /*
    * BeanFactory用来转换bean属性值或者参数值的自定义转换器
     * 设置、得到一个类型转换器
     */
	void setTypeConverter(TypeConverter typeConverter);
	TypeConverter getTypeConverter();
    /* 
     * 为嵌入的值(如注释属性)添加字符串解析器
     * string值解析器(如mvc中的ArgumentResolver了)
     * 增加一个嵌入式的StringValueResolver
     */
	void addEmbeddedValueResolver(StringValueResolver valueResolver);
	boolean hasEmbeddedValueResolver();
	@Nullable
	String resolveEmbeddedValue(String value);
	/**
	* 后置处理器，BeanPostProcessor
	**/
	void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
	int getBeanPostProcessorCount();
	/*--------------注册作用域---------------------*/
	void registerScope(String scopeName, Scope scope);
	String[] getRegisteredScopeNames();
	@Nullable
	Scope getRegisteredScope(String scopeName);
	// 安全作用域 访问权限控制
	AccessControlContext getAccessControlContext();
	// 合并其他ConfigurableBeanFactory的配置,包括上面说到的BeanPostProcessor,作用域等
    //从其他的工厂复制相关的所有配置
	void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
    /**---------------------------------注册别名*******************/
    // 给指定的Bean注册别名
	void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
	void resolveAliases(StringValueResolver valueResolver); 
	/*------------------bean定义处理----------------------*/
     // 返回指定Bean合并后的Bean定义，,包括父容器的
	BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
 	// 是否是FactoryBean类型
	boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;
	/*--------- 处理bean依赖问题 ----------------------*/
	// 设置一个Bean是否正在创建 bean创建状态控制.在解决循环依赖时有使用 
	void setCurrentlyInCreation(String beanName, boolean inCreation);
	// bean创建状态控制.在解决循环依赖时有使用
    // 返回指定Bean是否已经成功创建
	boolean isCurrentlyInCreation(String beanName);
    //注册一个依赖于指定bean的Bean
	void registerDependentBean(String beanName, String dependentBeanName);
    //返回依赖于指定Bean的所欲Bean名
	String[] getDependentBeans(String beanName);
    // 返回指定Bean依赖的所有Bean名
	String[] getDependenciesForBean(String beanName);
 	// bean生命周期管理-- ------------------
    // 销毁指定的Bean
	void destroyBean(String beanName, Object beanInstance);
	//销毁指定的范围Bean
	void destroyScopedBean(String beanName);
	// 销毁所有的单例类
	void destroySingletons();
}

AutowireCapableBeanFactory

对于想要拥有自动装配能力，并且想把这种能力暴露给外部应用的BeanFactory类需要实现此接口。
正常情况下，不要使用此接口，应该更倾向于使用BeanFactory或者ListableBeanFactory接口。此接口主要是针对框架之外，没有向Spring托管Bean的应用。通过暴露此功能，Spring框架之外的程序，具有自动装配等Spring的功能。
需要注意的是，ApplicationContext接口并没有实现此接口，因为应用代码很少用到此功能，如果确实需要的话，可以调用ApplicationContext的getAutowireCapableBeanFactory方法，来获取此接口的实例。
如果一个类实现了此接口，那么很大程度上它还需要实现BeanFactoryAware接口。它可以在应用上下文中返回BeanFactory。

/* 
 * @see org.springframework.beans.factory.BeanFactoryAware
 * @see org.springframework.beans.factory.config.ConfigurableListableBeanFactory
 * @see org.springframework.context.ApplicationContext#getAutowireCapableBeanFactory()
 */
public interface AutowireCapableBeanFactory extends BeanFactory {
	// 常量，用于标识外部自动装配功能是否可用。但是此标识不影响正常的（基于注解的等）自动装配功能的使用
	int AUTOWIRE_NO = 0;
	//  标识按名装配的常量
	int AUTOWIRE_BY_NAME = 1;
    //  标识按类型自动装配的常量
	int AUTOWIRE_BY_TYPE = 2;
	// 标识按照贪婪策略匹配出的最符合的构造方法来自动装配的常量
	int AUTOWIRE_CONSTRUCTOR = 3;
	// 标识自动识别一种装配策略来实现自动装配的常量
	@Deprecated
	int AUTOWIRE_AUTODETECT = 4;

	/**
	 * Suffix for the "original instance" convention when initializing an existing
	 * bean instance: to be appended to the fully-qualified bean class name,
	 * e.g. "com.mypackage.MyClass.ORIGINAL", in order to enforce the given instance
	 * to be returned, i.e. no proxies etc.
	 * @since 5.1
	 * @see #initializeBean(Object, String)
	 * @see #applyBeanPostProcessorsBeforeInitialization(Object, String)
	 * @see #applyBeanPostProcessorsAfterInitialization(Object, String)
	 */
	String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";


	//-------------------------------------------------------------------------
	// Typical methods for creating and populating external bean instances
	//-------------------------------------------------------------------------
	/**
     * 创建一个给定Class的实例。
     * 执行此Bean所有的关于Bean生命周期的接口方法如BeanPostProcessor
     * 此方法用于创建一个新实例，它会处理各种带有注解的域和方法，并且会调用所有Bean初始化时所需要调用的回调函数
     * 此方法并不意味着by-name或者by-type方式的自动装配，如果需要使用这写功能，可以使用其重载方法
     */
	<T> T createBean(Class<T> beanClass) throws BeansException;
	/**
    * Populate the given bean instance through applying after-instantiation callbacks
    * 通过调用给定Bean的after-instantiation及post-processing接口，对bean进行配置。
    * 此方法主要是用于处理Bean中带有注解的域和方法。
    * 此方法并不意味着by-name或者by-type方式的自动装配，如果需要使用这写功能，可以使用其重载方法autowireBeanProperties
    */
	void autowireBean(Object existingBean) throws BeansException;
	/**
     * Configure the given raw bean: autowiring bean properties, applying
     * 配置参数中指定的bean，包括自动装配其域，对其应用如setBeanName功能的回调函数。
     * 并且会调用其所有注册的post processor.
     * 此方法提供的功能是initializeBean方法的超集，会应用所有注册在bean definenition中的操作。
     * 不过需要BeanFactory 中有参数中指定名字的BeanDefinition。
	 */
	Object configureBean(Object existingBean, String beanName) throws BeansException;

	//-------------------------------------------------------------------------
	// Specialized methods for fine-grained control over the bean lifecycle
	/// 细粒度的控制bean的生命周期的方法
	//-------------------------------------------------------------------------
	/**
	 * 创建一个指定class的实例，通过参数可以指定其自动装配模式（by-name or by-type）.
     * 会执行所有注册在此class上用以初始化bean的方法，如BeanPostProcessors等
	 * @throws BeansException if instantiation or wiring failed
	 * @see #AUTOWIRE_NO
	 * @see #AUTOWIRE_BY_NAME
	 * @see #AUTOWIRE_BY_TYPE
	 * @see #AUTOWIRE_CONSTRUCTOR
	 */
	Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

	/**
	 * 通过指定的自动装配策略来初始化一个Bean。
     * 此方法不会调用Bean上注册的诸如BeanPostProcessors的回调方法
	 * @see #applyBeanPostProcessorsBeforeInitialization
	 * @see #applyBeanPostProcessorsAfterInitialization
	 */
	Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

	 /**
     * 通过指定的自动装配方式来对给定的Bean进行自动装配。
     * 会调用指定Bean注册的BeanPostProcessors等回调函数来初始化Bean。
     * 如果指定装配方式为AUTOWIRE_NO的话，不会自动装配属性，但是依然会调用BeanPiostProcesser等回调方法。
     */
	void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
			throws BeansException;

  	/**
     * 将参数中指定了name的Bean，注入给定实例当中
     * 此方法不会自动注入Bean的属性，它仅仅会应用在显式定义的属性之上。如果需要自动注入Bean属性，使用
     * autowireBeanProperties方法。
     * 此方法需要BeanFactory中存在指定名字的Bean。除了InstantiationAwareBeanPostProcessor的回调方法外，
     * 此方法不会在Bean上应用其它的例如BeanPostProcessors
     * 等回调方法。不过可以调用其他诸如initializeBean等方法来达到目的。
     */
	void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

	/**
	 * 初始化Bean到factory中
	 * 回调
	 * @see BeanNameAware
	 * @see BeanClassLoaderAware
	 * @see BeanFactoryAware
	 * @see #applyBeanPostProcessorsBeforeInitialization
	 * @see #invokeInitMethods
	 * @see #applyBeanPostProcessorsAfterInitialization
	 */
	Object initializeBean(Object existingBean, String beanName) throws BeansException;

	/**
	 *  bean的初始化的前置回调
	 * @see BeanPostProcessor#postProcessBeforeInitialization
	 */
	Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException;

	/**
	 * bean的初始化后的后置处理
	 * @see BeanPostProcessor#postProcessAfterInitialization
	 */
	Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException;

	/**
	 * 销毁bean实例
	 * 回调：
	 * {@link org.springframework.beans.factory.DisposableBean} contract as well as
	 * {@link DestructionAwareBeanPostProcessor DestructionAwareBeanPostProcessors}.
	 */
	void destroyBean(Object existingBean);


	//-------------------------------------------------------------------------
	// Delegate methods for resolving injection points
	//-------------------------------------------------------------------------

	/**
	 * 根据Class类获取bean实例，bean名称
	 * @since 4.3.3
	 * @see #getBean(Class)
	 */
	<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

	/**
	 * 解析出在Factory中与指定Bean有指定依赖关系的Bean
	 */
	Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;

	/**
	 * 解析 
	 * @see #resolveDependency(DependencyDescriptor, String, Set, TypeConverter)
	 */
	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;

	/**
	 * 解析指定Bean在Factory中的依赖关系
     * @param descriptor 依赖描述 (field/method/constructor)
     * @param requestingBeanName 依赖描述所属的Bean
     * @param autowiredBeanNames 与指定Bean有依赖关系的Bean
     * @param typeConverter 用以转换数组和连表的转换器
     * @return the 解析结果，可能为null
	 */
	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;

}

ConfigurableListableBeanFactory

public interface ConfigurableListableBeanFactory
		extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
	/********忽略自动装配****88***/
	// 在装配的时候忽略指定的依赖类型
	void ignoreDependencyType(Class<?> type);

	// 在装配的时候忽略指定的接口
	void ignoreDependencyInterface(Class<?> ifc);

	/***************依赖***********/
	// 注册可解析的依赖
	void registerResolvableDependency(Class<?> dependencyType, Object autowiredValue);
	// 指定的bean是否可以作为 条件装配 的候选
	boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
			throws NoSuchBeanDefinitionException;

	// 根据bean名称获取bean定义 BeanDefinition
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	// 获取bean名称的Iterator
	Iterator<String> getBeanNamesIterator();

	// 清除bean的元数据缓存
	void clearMetadataCache();

	// 冻结所有bean定义，表明注册的bean定义将不再修改或后期处理。
	void freezeConfiguration();

	// bean的定义是否被冻结
	boolean isConfigurationFrozen();

	// 非延迟加载的bean都实例化 lazy-init相关
	void preInstantiateSingletons() throws BeansException;

}

AliasRegistry

public interface AliasRegistry {

	// 注册别名
	void registerAlias(String name, String alias);
	// 删除别名
	void removeAlias(String alias);
	// 判断是否别名
	boolean isAlias(String name);
	// 返回name的所有别名
	String[] getAliases(String name);
}

BeanDefinitionRegistry

/*
 *  向IOC容器中注册bean定义 这个接口的方法通过英文比较简单
 * @see org.springframework.beans.factory.config.BeanDefinition
 * @see AbstractBeanDefinition
 * @see RootBeanDefinition
 * @see ChildBeanDefinition
 * @see DefaultListableBeanFactory
 * @see org.springframework.context.support.GenericApplicationContext
 * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
 * @see PropertiesBeanDefinitionReader
 */
public interface BeanDefinitionRegistry extends AliasRegistry {

	/**
	 * Register a new bean definition with this registry.
	 * 向IOC容器中注册bean的定义
	 * Must support RootBeanDefinition and ChildBeanDefinition.
	 */
	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException;

	/**
	 * Remove the BeanDefinition for the given name.
	 * 删除IOC容器中的Bean的定义
	 * @param beanName the name of the bean instance to register
	 * @throws NoSuchBeanDefinitionException if there is no such bean definition
	 */
	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	/**
	 * Return the BeanDefinition for the given bean name.
	 */
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	/**
	 * Check if this registry contains a bean definition with the given name.
	 */
	boolean containsBeanDefinition(String beanName);

	/**
	 * Return the names of all beans defined in this registry.
	 */
	String[] getBeanDefinitionNames();

	/**
	 * Return the number of beans defined in the registry.
	 */
	int getBeanDefinitionCount();

	/**
	 * Determine whether the given bean name is already in use within this registry,
	 * i.e. whether there is a local bean or alias registered under this name.
	 */
	boolean isBeanNameInUse(String beanName);

}

SimpleAliasRegistry

SimpleAliasRegistry 实现了AliasRegistry接口

public class SimpleAliasRegistry implements AliasRegistry {

	/** chm 别名缓存 Map from alias to canonical name */
	private final Map<String, String> aliasMap = new ConcurrentHashMap<String, String>(16);
	
	// 这个类的方法比较简单
	// 获取name的真实bean的名称
	public String canonicalName(String name){...}
}

DefaultSingletonBeanRegistry

DefaultSingletonBeanRegistry 注册单例bean

/* 
 * 共享bean实例的通用注册表
 * @see #registerSingleton
 * @see #registerDisposableBean
 * @see org.springframework.beans.factory.DisposableBean
 * @see org.springframework.beans.factory.config.ConfigurableBeanFactory
 */
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	/** 
	 * 由于Map不能存放null，用一个特殊的对象表示null
	 * Internal marker for a null singleton object:
	 * used as marker value for concurrent Maps (which don't support null values).
	 */
	protected static final Object NULL_OBJECT = new Object();

	/** Logger available to subclasses */
	protected final Log logger = LogFactory.getLog(getClass());

	/** Cache of singleton objects: bean name --> bean instance */
	// 单例Bean的缓存,bean name 对应 bean 实例
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

	/** Cache of singleton factories: bean name --> ObjectFactory */
	// 单例的 ObjectFacotry 缓存, 
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

	/** Cache of early singleton objects: bean name --> bean instance */
	// 早期单例实例的缓存, bean name 对应 eary bean instance
	// 是存放singletonFactory制造出来的 singleton的缓存 
	private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

	/** Set of registered singletons, containing the bean names in registration order */
	// 单例注册表,  单例的bean name
	private final Set<String> registeredSingletons = new LinkedHashSet<String>(256);
	/** Names of beans that are currently in creation */
	// 正在创建中的单例bean的名称集合
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
	/** Names of beans currently excluded from in creation checks */
	// 检查正在创建bean时,排除该集合中的bean
	private final Set<String> inCreationCheckExclusions =
			Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
	/** List of suppressed Exceptions, available for associating related causes */
	// 存储异常
	private Set<Exception> suppressedExceptions;
	/** Flag that indicates whether we're currently within destroySingletons */
	// 当前是否有singleton被销毁
	private boolean singletonsCurrentlyInDestruction = false;
	/** Disposable bean instances: bean name --> disposable instance */
	// bean对应的DisposableBean, DisposableBean接口有一个destroy()。为bean指定DisposableBean,作用类似于设置destroy-method
	private final Map<String, Object> disposableBeans = new LinkedHashMap<String, Object>();
	/** Map between containing bean names: bean name --> Set of bean names that the bean contains */
	private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>(16);
	/** Map between dependent bean names: bean name --> Set of dependent bean names */
	// bean依赖关系的缓存：bean name 对应依赖于该bean的所有bean的name 
	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<String, Set<String>>(64);
	/** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
	// bean依赖关系的缓存：bean name对应该bean依赖的所有bean的name
	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>(64);
	// 注册singletion
	@Override
	public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
		Assert.notNull(beanName, "'beanName' must not be null");
		synchronized (this.singletonObjects) {
			Object oldObject = this.singletonObjects.get(beanName);
			// 如果已经存在,抛出异常
			if (oldObject != null) {
				throw new IllegalStateException("Could not register object [" + singletonObject +
						"] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
			}
			addSingleton(beanName, singletonObject);
		}
	}
	// 真正的注册实现
	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			// 添加至单例bean的缓存中
			this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
			// 已经存在该单例bean的实例,因此对应的工厂和earlySingleton不再需要
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			// 添加注册表
			this.registeredSingletons.add(beanName);
		}
	}
	// 添加ObjectFactory 
	protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		synchronized (this.singletonObjects) {
			// 如果还不存在该bean实例,则添加对应的ObjectFactory
			if (!this.singletonObjects.containsKey(beanName)) {
				this.singletonFactories.put(beanName, singletonFactory);
				this.earlySingletonObjects.remove(beanName);
				this.registeredSingletons.add(beanName);
			}
		}
	}
	// 获取bean实例
	@Override
	public Object getSingleton(String beanName) {
		return getSingleton(beanName, true);
	}
	// 根据单例名称 或 bean实例
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// 从缓存中获取
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return (singletonObject != NULL_OBJECT ? singletonObject : null);
	}
	 // 获取 beanName的单例实例 
	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "'beanName' must not be null");
		synchronized (this.singletonObjects) {
			// 从单例缓存中获取
			Object singletonObject = this.singletonObjects.get(beanName);
			// 如果缓存中没有 根据单例工厂singletonFactory创建，并注册到单例容器中
			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 + "'");
				}
				// 创建单例前的回调
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<Exception>();
				}
				try {
					// 通过单例工厂创建实例
					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;
					}
					// 单例实例创建完的回调
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {
					// 如果成功创建单例实例，将其添加到单例容器中(chm)中
					addSingleton(beanName, singletonObject);
				}
			}
			return (singletonObject != NULL_OBJECT ? singletonObject : null);
		}
	}
	// 记录创建单例时产生的异常 
	protected void onSuppressedException(Exception ex) {
		synchronized (this.singletonObjects) {
			if (this.suppressedExceptions != null) {
				this.suppressedExceptions.add(ex);
			}
		}
	}

	// 从单例容器中删除beanName单例实例 
	protected void removeSingleton(String beanName) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.remove(beanName);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.remove(beanName);
		}
	}
	@Override
	// 判断容器中是否含有beanName的单例
	public boolean containsSingleton(String beanName) {
		return this.singletonObjects.containsKey(beanName);
	}
	@Override
	//获取容器中的所有单例名称数组
	public String[] getSingletonNames() {
		synchronized (this.singletonObjects) {
			return StringUtils.toStringArray(this.registeredSingletons);
		}
	}
	@Override
	// 获取单例容器中的实例个数
	public int getSingletonCount() {
		synchronized (this.singletonObjects) {
			return this.registeredSingletons.size();
		}
	}
	// 创建 beanName时，设置其正在创建中的状态  标记使用
	public void setCurrentlyInCreation(String beanName, boolean inCreation) {
		Assert.notNull(beanName, "Bean name must not be null");
		if (!inCreation) {
			this.inCreationCheckExclusions.add(beanName);
		}
		else {
			this.inCreationCheckExclusions.remove(beanName);
		}
	}
	// 判断 beanName 的单例实例是否正在创建中
	public boolean isCurrentlyInCreation(String beanName) {
		Assert.notNull(beanName, "Bean name must not be null");
		return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName));
	}
	// 判断beanName 是否在创建中
	protected boolean isActuallyInCreation(String beanName) {
		return isSingletonCurrentlyInCreation(beanName);
	}
	/**
	 * Return whether the specified singleton bean is currently in creation
	 * (within the entire factory).
	 * @param beanName the name of the bean
	 */
	public boolean isSingletonCurrentlyInCreation(String beanName) {
		return this.singletonsCurrentlyInCreation.contains(beanName);
	}

	/**
	 * Callback before singleton creation. 创建之前回调函数
	 */
	protected void beforeSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}

	/**
	 * Callback after singleton creation. 创建之后的回调
	 */
	protected void afterSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
			throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
		}
	}


	/**
	 *  记录 beanName 的消费， 用于 DisposableBean  的回调
	 */
	public void registerDisposableBean(String beanName, DisposableBean bean) {
		synchronized (this.disposableBeans) {
			this.disposableBeans.put(beanName, bean);
		}
	}

	/**
	 * Register a containment relationship between two beans,
	 * e.g. between an inner bean and its containing outer bean.
	 * <p>Also registers the containing bean as dependent on the contained bean
	 * in terms of destruction order.
	 * @param containedBeanName the name of the contained (inner) bean
	 * @param containingBeanName the name of the containing (outer) bean
	 * @see #registerDependentBean
	 */
	public void registerContainedBean(String containedBeanName, String containingBeanName) {
		synchronized (this.containedBeanMap) {
			Set<String> containedBeans = this.containedBeanMap.get(containingBeanName);
			if (containedBeans == null) {
				containedBeans = new LinkedHashSet<String>(8);
				this.containedBeanMap.put(containingBeanName, containedBeans);
			}
			containedBeans.add(containedBeanName);
		}
		registerDependentBean(containedBeanName, containingBeanName);
	}

	/** 
	 * 注册beanName 和 dependentBeanName 的依赖关系
	 * Register a dependent bean for the given bean,
	 * to be destroyed before the given bean is destroyed.
	 * @param beanName the name of the bean
	 * @param dependentBeanName the name of the dependent bean
	 */
	public void registerDependentBean(String beanName, String dependentBeanName) {
		String canonicalName = canonicalName(beanName);
		// beanName 被 dependentBeanName 依赖  
		synchronized (this.dependentBeanMap) {
			Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
			if (dependentBeans == null) {
				dependentBeans = new LinkedHashSet<String>(8);
				this.dependentBeanMap.put(canonicalName, dependentBeans);
			}
			dependentBeans.add(dependentBeanName);
		}
		// dependentBeanName 中有 beanName的实例 has a 
		synchronized (this.dependenciesForBeanMap) {
			Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
			if (dependenciesForBean == null) {
				dependenciesForBean = new LinkedHashSet<String>(8);
				this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
			}
			dependenciesForBean.add(canonicalName);
		}
	}

	/**
	 * Determine whether the specified dependent bean has been registered as
	 * dependent on the given bean or on any of its transitive dependencies.
	 * @param beanName the name of the bean to check
	 * @param dependentBeanName the name of the dependent bean
	 * @since 4.0
	 */
	protected boolean isDependent(String beanName, String dependentBeanName) {
		synchronized (this.dependentBeanMap) {
			return isDependent(beanName, dependentBeanName, null);
		}
	}

	private boolean isDependent(String beanName, String dependentBeanName, Set<String> alreadySeen) {
		if (alreadySeen != null && alreadySeen.contains(beanName)) {
			return false;
		}
		String canonicalName = canonicalName(beanName);
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans == null) {
			return false;
		}
		if (dependentBeans.contains(dependentBeanName)) {
			return true;
		}
		for (String transitiveDependency : dependentBeans) {
			if (alreadySeen == null) {
				alreadySeen = new HashSet<String>();
			}
			alreadySeen.add(beanName);
			if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Determine whether a dependent bean has been registered for the given name.
	 * @param beanName the name of the bean to check
	 */
	protected boolean hasDependentBean(String beanName) {
		return this.dependentBeanMap.containsKey(beanName);
	}

	/**
	 * 返回 beanName("a")依赖于所有的beans[b,c]
	 * 如: 
	 * @service("a") class A{..}
	 * 
	 * @service("b") 
	 * class B {  @Autowired private A a;}
	 * @service("c") 
	 * class C {  @Autowired private A a;} 
	 */
	public String[] getDependentBeans(String beanName) {
		Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
		if (dependentBeans == null) {
			return new String[0];
		}
		synchronized (this.dependentBeanMap) {
			return StringUtils.toStringArray(dependentBeans);
		}
	}

	/**
	 *  获取beanName(a)中所有的依赖bean [b,c] 
	 * 如 
	 *  @service("a") 
	 *  class A { 
	 *     @Autowired private B b;
	 * 	   @Autowired private C c;
	 *   }
	 */
	public String[] getDependenciesForBean(String beanName) {
		Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(beanName);
		if (dependenciesForBean == null) {
			return new String[0];
		}
		synchronized (this.dependenciesForBeanMap) {
			return StringUtils.toStringArray(dependenciesForBean);
		}
	}
	// 销毁单例容器
	public void destroySingletons() {
		if (logger.isDebugEnabled()) {
			logger.debug("Destroying singletons in " + this);
		}
		synchronized (this.singletonObjects) {
			this.singletonsCurrentlyInDestruction = true;
		}

		String[] disposableBeanNames;
		synchronized (this.disposableBeans) {
			disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
		}
		for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
			destroySingleton(disposableBeanNames[i]);
		}

		this.containedBeanMap.clear();
		this.dependentBeanMap.clear();
		this.dependenciesForBeanMap.clear();

		clearSingletonCache();
	}
	/**
	 * Clear all cached singleton instances in this registry.
	 */
	protected void clearSingletonCache() {
		synchronized (this.singletonObjects) {
			this.singletonObjects.clear();
			this.singletonFactories.clear();
			this.earlySingletonObjects.clear();
			this.registeredSingletons.clear();
			this.singletonsCurrentlyInDestruction = false;
		}
	}

	/**
	 *  销毁 单例 beanName 并回调
	 */
	public void destroySingleton(String beanName) {
		// Remove a registered singleton of the given name, if any.
		removeSingleton(beanName);
		// Destroy the corresponding DisposableBean instance.
		DisposableBean disposableBean;
		synchronized (this.disposableBeans) {
			disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
		}
		destroyBean(beanName, disposableBean);
	}

	/**
	 * Destroy the given bean. Must destroy beans that depend on the given
	 * 具体销毁 并调用 destory()方法
	 */
	protected void destroyBean(String beanName, DisposableBean bean) {
		// Trigger destruction of dependent beans first...
		Set<String> dependencies;
		synchronized (this.dependentBeanMap) {
			// Within full synchronization in order to guarantee a disconnected Set
			dependencies = this.dependentBeanMap.remove(beanName);
		}
		if (dependencies != null) {
			if (logger.isDebugEnabled()) {
				logger.debug("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
			}
			for (String dependentBeanName : dependencies) {
				destroySingleton(dependentBeanName);
			}
		}
		// Actually destroy the bean now...
		if (bean != null) {
			try {
				// bean 销毁时回调
				bean.destroy();
			}
			catch (Throwable ex) {
				logger.error("Destroy method on bean with name '" + beanName + "' threw an exception", ex);
			}
		}
		// 销毁bean, 清除 相关容器 
		// Trigger destruction of contained beans...
		Set<String> containedBeans;
		synchronized (this.containedBeanMap) {
			// Within full synchronization in order to guarantee a disconnected Set
			containedBeans = this.containedBeanMap.remove(beanName);
		}
		if (containedBeans != null) {
			for (String containedBeanName : containedBeans) {
				destroySingleton(containedBeanName);
			}
		}

		// Remove destroyed bean from other beans' dependencies.
		synchronized (this.dependentBeanMap) {
			for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
				Map.Entry<String, Set<String>> entry = it.next();
				Set<String> dependenciesToClean = entry.getValue();
				dependenciesToClean.remove(beanName);
				if (dependenciesToClean.isEmpty()) {
					it.remove();
				}
			}
		}
		// Remove destroyed bean's prepared dependency information.
		this.dependenciesForBeanMap.remove(beanName);
	}

	/**
	 * 提供给外部操作 单例容器时  同步锁
	 */
	public final Object getSingletonMutex() {
		return this.singletonObjects;
	}
}

FactoryBeanRegistrySupport

主要处理 FactoryBean 生成的Bean 如Mapper，Fegin的调用

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
	/** Cache of singleton objects created by FactoryBeans: FactoryBean name --> object */ 
	//  通过 FactoryBean 生成的bean的缓存 
	private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<String, Object>(16);
	// 返回factoryBean的创建的bean的class类型
	protected Class<?> getTypeForFactoryBean(final FactoryBean<?> factoryBean) {
		try {
			if (System.getSecurityManager() != null) {
				return AccessController.doPrivileged(new PrivilegedAction<Class<?>>() {
					@Override
					public Class<?> run() {
						return factoryBean.getObjectType();
					}
				}, getAccessControlContext());
			}
			else {
				return factoryBean.getObjectType();
			}
		}
		catch (Throwable ex) {
			// Thrown from the FactoryBean's getObjectType implementation.
			logger.warn("FactoryBean threw exception from getObjectType, despite the contract saying " +
					"that it should return null if the type of its object cannot be determined yet", ex);
			return null;
		}
	}

	/**
	 * Obtain an object to expose from the given FactoryBean, if available
	 * in cached form. Quick check for minimal synchronization.
	 * 获取 从FactoryBean 缓存中获取 bean实例
	 */
	protected Object getCachedObjectForFactoryBean(String beanName) {
		Object object = this.factoryBeanObjectCache.get(beanName);
		return (object != NULL_OBJECT ? object : null);
	}

	/**
	 * 通过 factoryBean 创建 beanName的实例
	 */
	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		if (factory.isSingleton() && containsSingleton(beanName)) {
			synchronized (getSingletonMutex()) {
				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
					object = doGetObjectFromFactoryBean(factory, beanName);
					// Only post-process and store if not put there already during getObject() call above
					// (e.g. because of circular reference processing triggered by custom getBean calls)
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
						if (object != null && shouldPostProcess) {
							try {
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
						}
						if (containsSingleton(beanName)) {
							this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
						}
					}
				}
				return (object != NULL_OBJECT ? object : null);
			}
		}
		else {
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			if (object != null && shouldPostProcess) {
				try {
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}

	/**
	 * Obtain an object to expose from the given FactoryBean.
	 * 真正通过factoryBean创建 bean的方法 
	 */
	private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
			throws BeanCreationException {

		Object object;
		try {
			if (System.getSecurityManager() != null) {
				AccessControlContext acc = getAccessControlContext();
				try {
					object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
						@Override
						public Object run() throws Exception {
								return factory.getObject();
							}
						}, acc);
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				object = factory.getObject();
			}
		}
		catch (FactoryBeanNotInitializedException ex) {
			throw new BeanCurrentlyInCreationException(beanName, ex.toString());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
		}

		// Do not accept a null value for a FactoryBean that's not fully
		// initialized yet: Many FactoryBeans just return null then.
		if (object == null && isSingletonCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(
					beanName, "FactoryBean which is currently in creation returned null from getObject");
		}
		return object;
	}

	/**
	 * Post-process the given object that has been obtained from the FactoryBean.
	 * 后置处理 的回调 
	 */
	protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
		return object;
	}

	/**
	 * Get a FactoryBean for the given bean if possible.
	 * @param beanName the name of the bean
	 * @param beanInstance the corresponding bean instance
	 * @return the bean instance as FactoryBean
	 * @throws BeansException if the given bean cannot be exposed as a FactoryBean
	 */
	protected FactoryBean<?> getFactoryBean(String beanName, Object beanInstance) throws BeansException {
		if (!(beanInstance instanceof FactoryBean)) {
			throw new BeanCreationException(beanName,
					"Bean instance of type [" + beanInstance.getClass() + "] is not a FactoryBean");
		}
		return (FactoryBean<?>) beanInstance;
	}

	/**
	 * Overridden to clear the FactoryBean object cache as well.
	 */
	@Override
	protected void removeSingleton(String beanName) {
		synchronized (getSingletonMutex()) {
			super.removeSingleton(beanName);
			this.factoryBeanObjectCache.remove(beanName);
		}
	}

	/**
	 * Overridden to clear the FactoryBean object cache as well.
	 */
	@Override
	protected void clearSingletonCache() {
		synchronized (getSingletonMutex()) {
			super.clearSingletonCache();
			this.factoryBeanObjectCache.clear();
		}
	}

	/**
	 * Return the security context for this bean factory. If a security manager
	 * is set, interaction with the user code will be executed using the privileged
	 * of the security context returned by this method.
	 * @see AccessController#getContext()
	 */
	protected AccessControlContext getAccessControlContext() {
		return AccessController.getContext();
	}

}

AbstractBeanFactory 等其他实现

AbstractBeanFactory 综合FactoryBeanRegistrySupport 和ConfigurableBeanFactory的功能，提供抽象实现
AbstractAutowireCapableBeanFactory中综合AbstractBeanFactory并对接口AutowireCapableBeanFactory进行实现
DefaultListableBeanFactory 综合上面所有功能，主要是对Bean注册后的处理