Spring的BeanFactory

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