2.Spring源码之路-DefaulListableBeanFactory - BeanFactory

BeanFactory接口总结

1. BeanFactory还是一个工厂，类似于工厂设计模式中的Factory，主要
   还是创建Bean，由实现者来决定如何创建
2. FactoryBean还是一个Bean，通过FactoryBean的名称只能获取到由
   FactoryBean创建的对象，如果想获取到FactoryBean需要在名字前面
   加一个 &
3. BeanFactory的接口归类如下:
   • 获取Bean实例的方法
     • Object getBean(String name)
     • T getBean(String name, Class requiredType)
     • Object getBean(String name, Object… args)
     • T getBean(Class requiredType)
     • T getBean(Class requiredType, Object… args)
   • 获取Bean的Provider(具体什么时候会被实例化，由调用方掌控)
     • ObjectProvider getBeanProvider(Class requiredType)
     • ObjectProvider getBeanProvider(ResolvableType requiredType)
   • 会导致Bean初始化的检查方法
     • boolean containsBean(String name)
     • boolean isTypeMatch(String name, ResolvableType typeToMatch)
     • boolean isTypeMatch(String name, Class typeToMatch)
     • Class getType(String name)
     • Class getType(String name, boolean allowFactoryBeanInit)
   • 不会导致Bean初始化的检查方法
     • boolean isSingleton(String name)
     • boolean isPrototype(String name)
     • String[] getAliases(String name);

源码注释的大概翻译

/**
 * 此接口由包含多个bean定义的对象实现，每个定义均由String名称唯一标识。根
 * 据bean的定义，工厂将返回一个所包含对象的独立实例，可能是原型实例的Bean，
 * 也可能是单例实例的Bean，至于返回哪种实例的Bean，取决于Bean的配置。
 * 
 * 这种方法的重点是BeanFactory是应用程序组件的中央注册表并集中了应用程序
 * 组件的配置（例如，不再需要单个对象读取属性文件）
 * 有关此方法的好处的讨论，请参见“Expert One-on-One J2EE Design and
 * Development”的第4章和第11章。 
 * 
 * 请注意，通常最好依赖于依赖注入（“push”配置）通过设置器或构造函数配置应
 * 用程序对象，而不是使用任何形式的“pull”配置（例如BeanFactory查找）。
 * 使用此BeanFactory接口及其子接口可以实现Spring的依赖注入功能。
 * 
 * 通常，BeanFactory将加载存储在配置源（例如XML文档）中的bean定义，并使
 * 用{@code org.springframework.beans} 包来配置bean。但是，实现可以根据需
 * 要直接在Java代码中直接返回创建的Java对象。定义的存储方式没有任何限制：
 * LDAP，RDBMS，XML，属性文件等。鼓励实现在bean之间支持引用（依赖注
 * 入）。 
 * 与{@link ListableBeanFactory}中的方法相反，此接口中的所有操作还将检查父
 * 工厂，如果这是一个{@link HierarchicalBeanFactory}。如果在此工厂实例中未
 * 找到bean，则将询问直接的父工厂。该工厂实例中的Bean应该覆盖任何父工厂
 * 中同名的Bean。 
 * Bean工厂实现应尽可能支持标准Bean生命周期接口。全套初始化方法及其标
 * 准顺序为：
 * 仅在应用程序上下文中运行时起作用
 * BeanNameAware的{@code setBeanName} 
 * BeanClassLoaderAware的{@code setBeanClassLoader} 
 * BeanFactoryAware的{@code setBeanFactory} 
 * EnvironmentAware的{@code setEnvironment} 
 * EmbeddedValueResolverAware的{@code setEmbeddedValueResolver} 
 * ResourceLoaderAware的{@code setResourceLoader} 
 * ApplicationEventPublisherAware的{@code setApplicationEventPublisher} 
 * MessageSourceAware的{@code setMessageSource} 
 * ApplicationContextAware的{@code setApplicationContext} 
 * 
 * 仅适用于在Web应用程序上下文中运行
 * ServletContextAware的{@code setServletContext} 
 * 
 * 仅对Bean进行实例化的时候会触发的接口
 * BeanPostProcessors的 {@ code postProcessBeforeInitialization}
 * InitializingBean的{@code afterPropertiesSet} 
 * 自定义的初始化方法
 * BeanPostProcessors的 {@ code postProcessAfterInitialization}
 * 
 * 在关闭bean工厂时，适用以下生命周期方法：
 * DestructionAwareBeanPostProcessor的{@ code postProcessBeforeDestruction}
 * DisposableBean的{@code destroy}
 * 自定义的销毁方法
 */
public interface BeanFactory {

	/**
	* 用于引用{@link FactoryBean}实例，并将其与由FactoryBean创建的bean区别开来。
	* 例如，如果名为{@code myJndiObject}的bean是FactoryBean，则获取
	* {@code＆myJndiObject} 将返回工厂，而不是工厂返回的实例。 
	 */
	String FACTORY_BEAN_PREFIX = "&";


	/**
	 * 返回一个实例，该实例可以是指定bean的共享或独立的。
	 * 此方法允许使用Spring BeanFactory替代Singleton或Prototype设计模式。
	 * 对于Singleton Bean，调用者可以保留对返回对象的引用。 
	 * 
	 * 将别名转换回相应的规范bean名称。 
	 * 将询问父工厂是否在该工厂实例中找不到该bean。 
	 * 
	 * @param 要检索的bean的名称
	 * @return bean的实例
	 * @throws NoSuchBeanDefinitionException如果没有指定名称的bean 
	 * @throws BeansException如果无法获得bean 
	 */
	Object getBean(String name) throws BeansException;

	/**
	 * 返回一个实例，该实例可以是指定bean的共享或独立的。 
	 * 与{@link #getBean（String）}的行为相同，但是如果Bean不是requiredType类型，
	 * 则抛出BeanNotOfRequiredTypeException来提供类型安全性的度量
	 * 这意味着无法正确映射结果
	 * 如{@link #getBean（String）}可能会抛出ClassCastException。
	 * 
	 * 将别名转换回相应的规范bean名称。 
	 * 将询问父工厂是否在该工厂实例中找不到该bean。 
	 * 
	 * @param name 要检索的bean的名称
	 * @param requiredType bean必须匹配的类型；可以是接口或超类
	 * @return bean的实例
	 * @throws NoSuchBeanDefinitionException 如果没有这样的bean定义
	 * @throws BeanNotOfRequiredTypeException 如果bean不是requiredType类型
	 * @throws BeansException如果不能创建bean 
	 */
	 T getBean(String name, Class requiredType) throws BeansException;

	/**
	 * 返回一个实例，该实例可以是指定bean的共享或独立的。
	 * 允许指定显式构造函数参数/工厂方法参数，如果有参数的话覆盖Bean定义中
	 * 指定的默认参数。
	 * @param name 要检索的bean的名称
	 * @param args 使用显式参数创建bean实例时使用的args参数
	 * (仅在创建新实例而不是检索现有实例时才应用)
	 * @return bean的实例
	 * @throws NoSuchBeanDefinitionException 如果没有这样的bean定义
	 * @throws BeanDefinitionStoreException 如果已给出参数但受影响的bean不是prototype
	 * @throws BeansException 如果无法创建bean
	 * @since 2.5
	 */
	Object getBean(String name, Object... args) throws BeansException;

	/**
	 * 如果有的话，返回与给定对象类型唯一匹配的bean实例
	 * 
	 * 此方法进入{@link ListableBeanFactory}按类型查找区域但也可以根据给定类型的名称，
	 * 转换为常规的按名称查找 对于检索bean的更广泛的操作，
	 * 请使用{@link ListableBeanFactory} 或{@link BeanFactoryUtils}。 
	 * @param bean必须匹配的类型；可以是接口或超类
	 * @return 与所需类型匹配的单个bean的实例
	 * @throws NoSuchBeanDefinitionException 如果没有找到给定类型的bean 
	 * @throws NoUniqueBeanDefinitionException 如果找到了给定类型的多个bean 
	 * @throws BeansException 如果无法创建bean
	 * @since 3.0
	 * @see ListableBeanFactory
	 */
	 T getBean(Class requiredType) throws BeansException;

	/**
	 * 返回一个实例，该实例可以是指定bean的共享或独立的。 
	 * 允许指定显式构造函数参数/工厂方法参数，如果有的话，覆盖Bean定义中指定的默认
	 * 参数
	 * 
	 * 此方法进入{@link ListableBeanFactory}按类型查找区域但也可以根据给定类型的名称，
	 * 转换为常规的按名称查找 对于检索bean的更广泛的操作，
	 * 请使用{@link ListableBeanFactory} 或{@link BeanFactoryUtils}。 
	 * @param requiredType bean必须匹配的类型；可以是接口或超类
	 * @param args 使用显式参数创建bean实例时使用的参数
	 * (仅在创建新实例而不是检索现有实例时才应用)
	 * @return bean的实例
	 * @throws NoSuchBeanDefinitionException 如果没有这样的bean定义
	 * @throws BeanDefinitionStoreException 如果给出了参数，但是受影响的bean不是prototype
	 * @throws BeansException 如果无法创建bean 
	 * @since 4.1
	 */
	 T getBean(Class requiredType, Object... args) throws BeansException;

	/**
	 * 返回指定bean的提供程序，允许对实例进行延迟的按需检索，包括可用性和唯一性选项。
	 * @param bean必须匹配的类型；可以是接口或超类
	 * @return 相应的提供程序句柄
	 * @since 5.1
	 * @see #getBeanProvider(ResolvableType)
	 */
	 ObjectProvider getBeanProvider(Class requiredType);

	/**
	 * 返回指定bean的提供程序，允许对实例进行延迟的按需检索，包括可用性和唯一性选项。
	 * @param requiredType bean必须匹配的类型；可以是通用类型声明。 
	 * 请注意，与反射注入点相比，此处不支持收集类型。要以编程方式检索与特定类型匹配的
	 * bean列表，请在此处指定实际bean类型作为参数，然后使用
	 * {@link ObjectProvider＃orderedStream（）}或它的延迟流/迭代选项。 
	 * @return 相应的提供程序句柄
	 * @since 5.1
	 * @see ObjectProvider#iterator()
	 * @see ObjectProvider#stream()
	 * @see ObjectProvider#orderedStream()
	 */
	 ObjectProvider getBeanProvider(ResolvableType requiredType);

	/**
	 * 此bean工厂是否包含具有给定名称的bean定义或外部注册的singleton实例
	 * 如果给定名称是别名，它将被转换回相应的规范bean名称。
	 * 
	 * 如果该工厂是分层工厂，如果在该工厂实例中找不到bean，将询问任何父工厂。
	 * 如果找到与给定名称匹配的beanDefinition或单例实例，则无论命名的bean定义
	 * 是具体的还是抽象的，惰性加载的或直接加载的，此方法都将返回{@code true}。
	 * 因此，请注意，此方法的{@code true}返回值不一定表示{@link #getBean} 将能
	 * 够获得具有相同名称的实例。 
	 * @param name 要查询的bean的名称
	 * @return 是否存在具有给定名称的bean 
	 */
	boolean containsBean(String name);

	/**
	 * 这个bean是共享单身吗？也就是说，{@ link #getBean}是否总是返回相同的实例？ 
	 * 注意：此返回{@code false}的方法不能清楚地表明独立实例。
	 * 它表示非单个实例，也可能对应于作用域bean。使用{@link #isPrototype}操作来
	 * 显式检查独立实例。
	 * 
	 * 将别名转换回相应的规范bean名称。 
	 * 将询问父工厂是否在该工厂实例中找不到该bean。 
	 * @param name 要查询的bean的名称
	 * @return 此bean是否对应于一个单例实例
	 * @throws NoSuchBeanDefinitionException 如果没有给定名称的bean
	 * @see #getBean
	 * @see #isPrototype
	 */
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	/**
	 * 这个bean是原型吗？也就是说，{@ link #getBean}将始终返回独立实例吗？ 
	 * 注意：此返回{@code false}的方法不能清楚地表明*一个单例对象。它指示
	 * 非独立实例，也可能对应于*作用域bean。使用{@link #isSingleton}操作来
	 * 显式检查共享的单例实例。 
	 * 
	 * 将别名转换回相应的规范bean名称。 
	 * 将询问父工厂是否在该工厂实例中找不到该bean。 
	 * @param name 要查询的bean的名称
	 * @return 此bean是否将始终提供独立的实例
	 * @throws NoSuchBeanDefinitionException 如果没有给定名称的bean 
	 * @since 2.0.3
	 * @see #getBean
	 * @see #isSingleton
	 */
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	/**
	 * 检查具有给定名称的bean是否与指定的类型匹配。 更具体地说，检查对给
	 * 定名称的{@link #getBean}调用是否会返回可分配给指定目标类型的对象。
	 * 
	 * 将别名转换回相应的规范bean名称。 
	 * 将询问父工厂是否在该工厂实例中找不到该bean。 
	 * @param 要查询的bean的名称
	 * @param typeToMatch 要匹配的类型（作为{@code ResolvableType}）
	 * @return 如果bean类型匹配{@code true}，如果它不匹配或尚未确定{@code false}
	 * @throws NoSuchBeanDefinitionException 如果没有给定名称的bean
	 * @since 4.2
	 * @see #getBean
	 * @see #getType
	 */
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	/**
	 * 检查具有给定名称的bean是否与指定的类型匹配。更具体地说，检查对给定
	 * 名称的{@link #getBean}调用是否会返回可分配给指定目标类型的对象。 
	 * 
	 * 将别名转换回相应的规范bean名称。 
	 * 将询问父工厂是否在该工厂实例中找不到该bean。 
	 * @param name 要查询的bean的名称
	 * @param typeToMatch 要匹配的类型(as a {@code Class})
	 * @return 如果bean类型匹配{@code true}，如果它不匹配或尚不能确定{@code false}
	 * {@code false} if it doesn't match or cannot be determined yet
	 * @throws NoSuchBeanDefinitionException 如果没有给定名称的bean 
	 * @since 2.0.1
	 * @see #getBean
	 * @see #getType
	 */
	boolean isTypeMatch(String name, Class typeToMatch) throws NoSuchBeanDefinitionException;

	/**
	 * 确定具有给定名称的bean的类型。更具体地说，
	 * 确定给定名称的{@link #getBean}返回的对象的类型。 
	 * 对于{@link FactoryBean}，返回由{@link FactoryBean＃getObjectType（）}
	 * 公开的FactoryBean创建的对象的类型。这可能导致先前未初始化的
	 * {@code FactoryBean}的初始化（请参阅{@link #getType（String，boolean）}）。 
	 * 
	 * 将别名转换回相应的规范bean名称。 
	 * 将询问父工厂是否在该工厂实例中找不到该bean。 
	 * @param 要查询的bean的名称
	 * @return bean的类型，如果不确定，则返回{@code null} 
	 * @throws NoSuchBeanDefinitionException 如果没有给定名称的bean
	 * @since 1.1.2
	 * @see #getBean
	 * @see #isTypeMatch
	 */
	@Nullable
	Class getType(String name) throws NoSuchBeanDefinitionException;

	/**
	 * 确定具有给定名称的bean的类型。更具体地说，
	 * 确定给定名称的{@link #getBean}返回的对象的类型。 
	 * 对于{@link FactoryBean}，返回由{@link FactoryBean＃getObjectType（）}
	 * 公开的FactoryBean创建的对象的类型。如果没有早期类型信息，则取决于
	 * {@code allowFactoryBeanInit}标志，这可能导致先前未初始化的
	 * {@code FactoryBean}的初始化。 
	 * 
	 * 将别名转换回相应的规范bean名称。 
	 * 将询问父工厂是否在该工厂实例中找不到该bean。 
	 * @param name 要查询的bean的名称
	 * @param allowFactoryBeanInit 是否可以初始化{@code FactoryBean} 仅用于确定其对象类型
	 * just for the purpose of determining its object type
	 * @return 如果不是可确定的{@code null}，否则返回bean的类型
	 * @throws NoSuchBeanDefinitionException 如果没有给定名称的bean 
	 * @since 5.2
	 * @see #getBean
	 * @see #isTypeMatch
	 */
	@Nullable
	Class getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;

	/**
	 * 如果有别名，返回给定bean名称的别名
	 * 在{@link #getBean}调用中使用时，所有这些别名都指向同一个bean。 
	 * 如果给定名称是别名，则将返回相应的原始bean名称和其他别名，原始bean名称
	 * 是数组中的第一个元素。 
	 * 
	 * 将询问父工厂是否在该工厂实例中找不到该bean。 
	 * @param name 要检查别名的bean名称
	 * @return 如果没有别名则返回一个空数组，如果有返回别名
	 * @see #getBean
	 */
	String[] getAliases(String name);

}