转载

Spring-祖先BeanFactory

1 BeanFactory介绍

BeanFactory 是Spring中的根容器接口,所有的容器都从从它继承而来, ApplicationContext 中对于 BeanDefinition 的注册, bean 实例的获取都是基于 BeanFactory 来实现。

BeanFactory 使用工厂方法设计模式。

2 BeanFactory源码

通过读源码的 doc

  • 这个接口是 spring bean 容器的根接口,它有一些为了提供特定功能的子接口 ListableBeanFactoryConfigurableBeanFactory
  • 实现这个接口的对象持有一系列的 bean definitions ,每个 bean definition 都有一个唯一的字符串名字。返回的 Bean 可以是单例的,也可以是独立的(每次都要创建),具体返回什么类型取决于 applicationcontext 的配置。
  • BeanFactory 通过依赖注入来完成配置,通常的手段是用 setter 或者 constructor
  • 通常情况 BeanFactory 加载的 BeanDefinition 保存在一个配置资源中,比如XML文件。但是具体存储在哪儿是没有限制的,比如 LDAP , XML , properties 等等。
  • HierarchicalBeanFactory 会先从本上下文找,找不到从父 BeanFactory 找,且本工厂实例中的bean会覆盖父工厂
  • BeanFactory 的实现类应该尽可能支持 bean 的生命周期方法,比如 BeanNameAware , BeanClassLoaderAware ,等等。

    对于这些生命周期方法的支持, BeanFacoty 没有给出抽象的接口,需要实现类自己去实现

BeanFactory 的源码:

public interface BeanFactory {

    // 用来区分FactoryBean和其产生的对象
    String FACTORY_BEAN_PREFIX = "&";

    // 通过BeanName获取Bean
    Object getBean(String name) throws BeansException;

    // 通过beanName和bean 的Class类型来获取Bean
    <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;

    // 增加获取bean的参数
    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;

    // 判断是否包含某个Bean
    boolean containsBean(String name);

    // bean是否是单例
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    // bean是否是prototype
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    //查询指定了名字的Bean的Class类型是否与指定类型匹配
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

    // 同上
    boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

    //获取指定名字bean的Class类型
    @Nullable
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;

    // 获取bean的别名
    String[] getAliases(String name);

}

再看看 BeanFactory 这个大家族都有哪些成员

Spring-祖先BeanFactory

BeanFactory 有三个子类接口: ListableBeanFactoryHierarchicalBeanFactoryAutowireCapableBeanFactory ,还有一个实现类 SimpleJndiBeanFactory

接下里就看看它的这三个儿子:

3 BeanFactory家族

3.1 AutowireCapableBeanFactory

具有自动装配的能力,该类可以填充那些不受spring容器控制的bean。

源码查看:

public interface AutowireCapableBeanFactory extends BeanFactory {

    /**
     * 常量,表示内部没有定义自动装配。主要BeanFactoryAware等和注解驱动依赖注入,依然启作用。
     */
    int AUTOWIRE_NO = 0;

    /**
     * Constant that indicates autowiring bean properties by name
     * (applying to all bean property setters).
     * 表示根据name自动装配bean属性(应用与bean所有setter属性)
     * @see #createBean
     * @see #autowire
     * @see #autowireBeanProperties
     */
    int AUTOWIRE_BY_NAME = 1;

    /**
     * Constant that indicates autowiring bean properties by type
     * (applying to all bean property setters).
     * 表示依赖于类型自动装配bean属性(应用与bean所有setter属性)
     * @see #createBean
     * @see #autowire
     * @see #autowireBeanProperties
     */
    int AUTOWIRE_BY_TYPE = 2;

    /**
     * Constant that indicates autowiring the greediest constructor that
     * can be satisfied (involves resolving the appropriate constructor).
     * 表示依赖于构造自动装配(解决构造相关的属性)
     * @see #createBean
     * @see #autowire
     */
    int AUTOWIRE_CONSTRUCTOR = 3;

    /**
     * Constant that indicates determining an appropriate autowire strategy
     * through introspection of the bean class.
     * 从spring3.o已经废弃,通过bean类的内省机制,确定一个合适的自动装配策略。
     * @see #createBean
     * @see #autowire
     * @deprecated as of Spring 3.0: If you are using mixed autowiring strategies,
     * prefer annotation-based autowiring for clearer demarcation of autowiring needs.
     */
    @Deprecated
    int AUTOWIRE_AUTODETECT = 4;


    //-------------------------------------------------------------------------
    // Typical methods for creating and populating external bean instances
    //-------------------------------------------------------------------------

    /**
     * Fully create a new bean instance of the given class.
     * 完全创建一个新的给定class的bean实例。
     * <p>Performs full initialization of the bean, including all applicable
     * {@link BeanPostProcessor BeanPostProcessors}.
     * 执行所有bean的初始化操作,包括所有应用层的bean处理器BeanPostProcessors。
     * <p>Note: This is intended for creating a fresh instance, populating annotated
     * fields and methods as well as applying all standard bean initialization callbacks.
     * It does <i>not</> imply traditional by-name or by-type autowiring of properties;
     * use {@link #createBean(Class, int, boolean)} for those purposes.
     * 注意,这个方法,创建一个新的bean实例,并向所有bean初始化回调一样,处理注解fields和方法。但是,不意味着,
     * 依赖name或类型,自动装配属性,为了这个目的可以使用{@link #createBean(Class, int, boolean)}方法。
     * @param beanClass the class of the bean to create
     * 创建bean的类型
     * @return the new bean instance 返回bean的实例
     * @throws BeansException if instantiation or wiring failed
     * 如果自动装配或初始化失败,则抛出BeansException异常。
     */
    <T> T createBean(Class<T> beanClass) throws BeansException;

    /**
     * 在初始化回调处理完后,装配给定的bean实例,比如注解自动装配。
     * 注意,方法用于处理注解驱动的fields的方法,比如新的实例,或反序列化实例。但是,不意味着,
     * 依赖name或类型,自动装配属性,为了这个目的可以使用 {@link #autowireBeanProperties}方法
     * @param existingBean the existing bean instance
     * 已经完成标准初始化回调的bean实例
     * @throws BeansException if wiring failed
     * 如果自动装配失败,则抛出BeansException异常。
     */
    void autowireBean(Object existingBean) throws BeansException;

    /**
     * 配置给定原始bean:自动装配bean属性,bean属性值,应用工厂回调,比如{@code setBeanName},{@code setBeanFactory},
     * 同时,应用所有bean后处理器,(包括,bean实例包装的原始bean)
     * 此方法相当与{@link #initializeBean}与依赖bean定义全配置bean。
     * 注意:此方法需要一个的bean定义的name。
     * @param existingBean the existing bean instance
     * 已经存在的bean实例
     * @param beanName the name of the bean, to be passed to it if necessary
     * (a bean definition of that name has to be available)
     * 如果需要,则传入一个bean定义的name
     * @return the bean instance to use, either the original or a wrapped one
     *返回bean实例,或是原始实例,或包装后的实例。
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     * if there is no bean definition with the given name
     * 如果没有给定的name对应的bean定义,则抛出NoSuchBeanDefinitionException异常。
     * @throws BeansException if the initialization failed
     * 如果初始化,则抛出BeansException异常。
     * @see #initializeBean
     */
    Object configureBean(Object existingBean, String beanName) throws BeansException;

    /**
     * 此方法与上述createBean(Class<T> beanClass)方法,不同的是,控制自动装配的策略,是依赖name还是类型,还是构造。
     * Fully create a new bean instance of the given class with the specified
     * autowire strategy. All constants defined in this interface are supported here.
     * <p>Performs full initialization of the bean, including all applicable
     * {@link BeanPostProcessor BeanPostProcessors}. This is effectively a superset
     * of what {@link #autowire} provides, adding {@link #initializeBean} behavior.
     * @param beanClass the class of the bean to create
     * @param autowireMode by name or type, using the constants in this interface
     * 依赖于类型还是name,还是构造进行自动装配
     * @param dependencyCheck whether to perform a dependency check for objects
     * (not applicable to autowiring a constructor, thus ignored there)
     * 是否执行依赖检查
     * @return the new bean instance
     * @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;

    /**
     * 此方法与上述autowireBean(Object existingBean)方法,不同的是,控制自动装配的策略,是依赖name还是类型,还是构造。
     * Instantiate a new bean instance of the given class with the specified autowire
     * strategy. All constants defined in this interface are supported here.
     * Can also be invoked with {@code AUTOWIRE_NO} in order to just apply
     * before-instantiation callbacks (e.g. for annotation-driven injection).
     * 在初始化回调以前,比如注解驱动注入,为了调整应用,可以传入{@code AUTOWIRE_NO}。
     * <p>Does <i>not</i> apply standard {@link BeanPostProcessor BeanPostProcessors}
     * callbacks or perform any further initialization of the bean.
     * 需要注意的是,此方法不应用bean后处理器回调和进一步的bean初始化。
     * This interface offers distinct, fine-grained operations for those purposes, for example
     * {@link #initializeBean}. However, {@link InstantiationAwareBeanPostProcessor}
     * callbacks are applied, if applicable to the construction of the instance.
     * 此方法与#initializeBean方法不同。然而如果使用是构造实例模式,将会调用{@link InstantiationAwareBeanPostProcessor}回调。
     * @param beanClass the class of the bean to instantiate
     * @param autowireMode by name or type, using the constants in this interface
     * @param dependencyCheck whether to perform a dependency check for object
     * references in the bean instance (not applicable to autowiring a constructor,
     * thus ignored there)
     * @return the new bean instance
     * @throws BeansException if instantiation or wiring failed
     * @see #AUTOWIRE_NO
     * @see #AUTOWIRE_BY_NAME
     * @see #AUTOWIRE_BY_TYPE
     * @see #AUTOWIRE_CONSTRUCTOR
     * @see #AUTOWIRE_AUTODETECT
     * @see #initializeBean
     * @see #applyBeanPostProcessorsBeforeInitialization
     * @see #applyBeanPostProcessorsAfterInitialization
     */
    Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    /**
     * 此方主要是自动装配bean的属性。
     * Autowire the bean properties of the given bean instance by name or type.
     * Can also be invoked with {@code AUTOWIRE_NO} in order to just apply
     * after-instantiation callbacks (e.g. for annotation-driven injection).
     * 依赖于name和类型自动装配给定bean的属性。 在初始化回调以前,比如注解驱动注入,为了调整应用,可以传入{@code AUTOWIRE_NO}。
     * <p>Does <i>not</i> apply standard {@link BeanPostProcessor BeanPostProcessors}
     * callbacks or perform any further initialization of the bean. This interface
     * offers distinct, fine-grained operations for those purposes, for example
     * {@link #initializeBean}. However, {@link InstantiationAwareBeanPostProcessor}
     * callbacks are applied, if applicable to the configuration of the instance.
     * @param existingBean the existing bean instance
     * @param autowireMode by name or type, using the constants in this interface
     * @param dependencyCheck whether to perform a dependency check for object
     * references in the bean instance
     * @throws BeansException if wiring failed
     * @see #AUTOWIRE_BY_NAME
     * @see #AUTOWIRE_BY_TYPE
     * @see #AUTOWIRE_NO
     */
    void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
            throws BeansException;

    /**
     * Apply the property values of the bean definition with the given name to
     * the given bean instance. The bean definition can either define a fully
     * self-contained bean, reusing its property values, or just property values
     * meant to be used for existing bean instances.
     * 应用给定name的bean的定义的属性给指定bean实例。bean定义可以是一个完全自包含的bean,重用他的属性,或
     * 调整属性,意味着用于已经存在的bean实例。
     * <p>This method does <i>not</i> autowire bean properties; it just applies
     * explicitly defined property values. Use the {@link #autowireBeanProperties}
     * method to autowire an existing bean instance.
     * 此方法不会自动装配bean属性,仅仅使用显示定义的bean的属性值。使用 {@link #autowireBeanProperties}方法自动注入
     * 已经存在的bean实例。
     * <b>Note: This method requires a bean definition for the given name!</b>
     * 注意:此方法需要bean定义的给定name。
     * <p>Does <i>not</i> apply standard {@link BeanPostProcessor BeanPostProcessors}
     * callbacks or perform any further initialization of the bean. This interface
     * offers distinct, fine-grained operations for those purposes, for example
     * {@link #initializeBean}. However, {@link InstantiationAwareBeanPostProcessor}
     * callbacks are applied, if applicable to the configuration of the instance.
     * 需要注意的是,此方法不应用bean后处理器回调和进一步的bean初始化。此方法与#initializeBean方法不同。
     * 然而如果应用到配置实例,将会调用{@link InstantiationAwareBeanPostProcessor}回调。
     * @param existingBean the existing bean instance
     * @param beanName the name of the bean definition in the bean factory
     * (a bean definition of that name has to be available)
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     * if there is no bean definition with the given name
     * @throws BeansException if applying the property values failed
     * @see #autowireBeanProperties
     */
    void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

    /**
     * Initialize the given raw bean, applying factory callbacks
     * such as {@code setBeanName} and {@code setBeanFactory},
     * also applying all bean post processors (including ones which
     * might wrap the given raw bean).
     * 初始化给定的原始bean,应用工厂调用,比如{@code setBeanName} 和 {@code setBeanFactory},
     * 同时应有所有bean后处理器,包括包装的指定原始bean。
     * <p>Note that no bean definition of the given name has to exist
     * in the bean factory. The passed-in bean name will simply be used
     * for callbacks but not checked against the registered bean definitions.
     * 注意:如果在bean工厂中,必须有给定的name的bean的定义。bean的name仅仅用于回调,并不检查注册bean的定义。
     * @param existingBean the existing bean instance
     * @param beanName the name of the bean, to be passed to it if necessary
     * (only passed to {@link BeanPostProcessor BeanPostProcessors})
     * @return the bean instance to use, either the original or a wrapped one
     * @throws BeansException if the initialization failed
     */
    Object initializeBean(Object existingBean, String beanName) throws BeansException;

    /**
     * Apply {@link BeanPostProcessor BeanPostProcessors} to the given existing bean
     * instance, invoking their {@code postProcessBeforeInitialization} methods.
     * The returned bean instance may be a wrapper around the original.
     * 应用{@link BeanPostProcessor BeanPostProcessors}到给定存在的bean实例,并调用{@code postProcessBeforeInitialization}
     * 方法,返回的bean实例,也许是一个原始的包装bean。
     * @param existingBean the new bean instance
     * @param beanName the name of the bean
     * @return the bean instance to use, either the original or a wrapped one
     * @throws BeansException if any post-processing failed
     * @see BeanPostProcessor#postProcessBeforeInitialization
     */
    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException;

    /**
     * Apply {@link BeanPostProcessor BeanPostProcessors} to the given existing bean
     * instance, invoking their {@code postProcessAfterInitialization} methods.
     * The returned bean instance may be a wrapper around the original.
     * 此方法与上面方法不同是调用bean后处理的{@code postProcessAfterInitialization}。
     * @param existingBean the new bean instance
     * @param beanName the name of the bean
     * @return the bean instance to use, either the original or a wrapped one
     * @throws BeansException if any post-processing failed
     * @see BeanPostProcessor#postProcessAfterInitialization
     */
    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException;

    /**
     * Destroy the given bean instance (typically coming from {@link #createBean}),
     * applying the {@link org.springframework.beans.factory.DisposableBean} contract as well as
     * registered {@link DestructionAwareBeanPostProcessor DestructionAwareBeanPostProcessors}.
     * <p>Any exception that arises during destruction should be caught
     * and logged instead of propagated to the caller of this method.
     * 销毁给定bean的实例,比如来自于{@link #createBean})方法创建的bean实例,
     * 同时调用{@link org.springframework.beans.factory.DisposableBean},以及注册的
     * {@link DestructionAwareBeanPostProcessor DestructionAwareBeanPostProcessors}.
     * 在析构的构成中国,任何异常的抛出,将会传播到方法的调用者。
     * @param existingBean the bean instance to destroy
     */
    void destroyBean(Object existingBean);


    /**
     * Resolve the bean instance that uniquely matches the given object type, if any,
     * including its bean name.
     * 若果存在,返回唯一匹配自定类型的bean实例,包括bean的name。
     * <p>This is effectively a variant of {@link #getBean(Class)} which preserves the
     * bean name of the matching instance.
     * 此方法等同于{@link #getBean(Class)}方法,并保存bean的name。
     * @param requiredType type the bean must match; can be an interface or superclass.
     * {@code null} is disallowed.
     * 需要匹配的类型,可以是接口或类,但不能为null。
     * @return the bean name plus bean instance
     * @throws NoSuchBeanDefinitionException if no matching bean was found
     * @throws NoUniqueBeanDefinitionException if more than one matching bean was found
     * 如果存在多个匹配的bean,则抛出NoUniqueBeanDefinitionException异常
     * @throws BeansException if the bean could not be created
     * @since 4.3.3
     * @see #getBean(Class)
     */
    <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

    /**
     * Resolve the specified dependency against the beans defined in this factory.
     * 在工厂根据bean的定义,解决特殊的依赖。
     * @param descriptor the descriptor for the dependency (field/method/constructor)
     * @param requestingBeanName the name of the bean which declares the given dependency
     * @return the resolved object, or {@code null} if none found
     * @throws NoSuchBeanDefinitionException if no matching bean was found
     * @throws NoUniqueBeanDefinitionException if more than one matching bean was found
     * @throws BeansException if dependency resolution failed for any other reason
     * @since 2.5
     * @see #resolveDependency(DependencyDescriptor, String, Set, TypeConverter)
     */
    Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName) throws BeansException;

    /**
     * Resolve the specified dependency against the beans defined in this factory.
     * 此方法与上面方法的不同是,多了一个类型转换器
     * @param descriptor the descriptor for the dependency (field/method/constructor)
     * @param requestingBeanName the name of the bean which declares the given dependency
     * @param autowiredBeanNames a Set that all names of autowired beans (used for
     * resolving the given dependency) are supposed to be added to
     * @param typeConverter the TypeConverter to use for populating arrays and collections
     * 用于数组与集合类的转换。
     * @return the resolved object, or {@code null} if none found
     * @throws NoSuchBeanDefinitionException if no matching bean was found
     * @throws NoUniqueBeanDefinitionException if more than one matching bean was found
     * @throws BeansException if dependency resolution failed for any other reason
     * @since 2.5
     * @see DependencyDescriptor
     */
    Object resolveDependency(DependencyDescriptor descriptor, String requestingBeanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException;

}

AutowireCapableBeanFactory 接口,主要提供的创建bean实例,自动装配bean属性,应用bean配置属性,初始化bean,应用bean后处理器 BeanPostProcessor ,解决bean依赖和销毁bean操作。对于自动装配,主要提供了根据bean的name,类型和构造自动装配方式。一般不建议在 在代码中直接使用 AutowireCapableBeanFactory 接口,我们可以通过应用上下文的 ApplicationContext#getAutowireCapableBeanFactory() 方法或者通过实现 BeanFactoryAware ,获取暴露的 bean 工厂,然后转换为 AutowireCapableBeanFactory

3.2 HierarchicalBeanFactory

该类具有层次划分功能,提供了父子容器。

public interface HierarchicalBeanFactory extends BeanFactory {

    /**
     * 返回父容器
     */
    @Nullable
    BeanFactory getParentBeanFactory();

    /**
      * 本容器是否包含某个bean,不管父容器
     */
    boolean containsLocalBean(String name);

}

3.2 ListableBeanFactory

这个BeanFactory可以列举所有的bean实例,而不是通过bean的名字一个一个地查找,预先加载所有的BeanDefinition的实现类应该实现这个接口。

实现类如果也实现了HierarchicalBeanFactory,应该只列出本实例的bean,而不要管祖先的factory 中的bean.

public interface ListableBeanFactory extends BeanFactory {

    /**
     * 检查本容器是否包含给定beanName的BeanDefinition
     */
    boolean containsBeanDefinition(String beanName);

    /**
     * 返回包含BeanDefinition的数量
     */
    int getBeanDefinitionCount();

    /**
     * 返回BeanDifinition的名字
     */
    String[] getBeanDefinitionNames();

    /**
     * Return the names of beans matching the given type (including subclasses),
     * judging from either bean definitions or the value of {@code getObjectType}
     * in the case of FactoryBeans.
     * <p><b>NOTE: This method introspects top-level beans only.</b> It does <i>not</i>
     * check nested beans which might match the specified type as well.
     * <p>Does consider objects created by FactoryBeans, which means that FactoryBeans
     * will get initialized. If the object created by the FactoryBean doesn't match,
     * the raw FactoryBean itself will be matched against the type.
     * <p>Does not consider any hierarchy this factory may participate in.
     * Use BeanFactoryUtils' {@code beanNamesForTypeIncludingAncestors}
     * to include beans in ancestor factories too.
     * <p>Note: Does <i>not</i> ignore singleton beans that have been registered
     * by other means than bean definitions.
     * <p>This version of {@code getBeanNamesForType} matches all kinds of beans,
     * be it singletons, prototypes, or FactoryBeans. In most implementations, the
     * result will be the same as for {@code getBeanNamesForType(type, true, true)}.
     * <p>Bean names returned by this method should always return bean names <i>in the
     * order of definition</i> in the backend configuration, as far as possible.
     * @param type the generically typed class or interface to match
     * @return the names of beans (or objects created by FactoryBeans) matching
     * the given object type (including subclasses), or an empty array if none
     * @since 4.2
     * @see #isTypeMatch(String, ResolvableType)
     * @see FactoryBean#getObjectType
     * @see BeanFactoryUtils#beanNamesForTypeIncludingAncestors(ListableBeanFactory, ResolvableType)
     */
    String[] getBeanNamesForType(ResolvableType type);

    /**
     * 根据类型来返回Bean名称,包含该层的所有Bean,包括FactoryBean
     * Return the names of beans matching the given type (including subclasses),
     * judging from either bean definitions or the value of {@code getObjectType}
     * in the case of FactoryBeans.
     * <p><b>NOTE: This method introspects top-level beans only.</b> It does <i>not</i>
     * check nested beans which might match the specified type as well.
     * <p>Does consider objects created by FactoryBeans, which means that FactoryBeans
     * will get initialized. If the object created by the FactoryBean doesn't match,
     * the raw FactoryBean itself will be matched against the type.
     * <p>Does not consider any hierarchy this factory may participate in.
     * Use BeanFactoryUtils' {@code beanNamesForTypeIncludingAncestors}
     * to include beans in ancestor factories too.
     * <p>Note: Does <i>not</i> ignore singleton beans that have been registered
     * by other means than bean definitions.
     * <p>This version of {@code getBeanNamesForType} matches all kinds of beans,
     * be it singletons, prototypes, or FactoryBeans. In most implementations, the
     * result will be the same as for {@code getBeanNamesForType(type, true, true)}.
     * <p>Bean names returned by this method should always return bean names <i>in the
     * order of definition</i> in the backend configuration, as far as possible.
     * @param type the class or interface to match, or {@code null} for all bean names
     * @return the names of beans (or objects created by FactoryBeans) matching
     * the given object type (including subclasses), or an empty array if none
     * @see FactoryBean#getObjectType
     * @see BeanFactoryUtils#beanNamesForTypeIncludingAncestors(ListableBeanFactory, Class)
     */
    String[] getBeanNamesForType(@Nullable Class<?> type);

    /**
     * 返回指定类型的名字 includeNonSingletons为false表示只取单例Bean,true则不是
     * allowEagerInit为true表示立刻加载,false表示延迟加载
     */
    String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

    /**
     * Return the bean instances that match the given object type (including
     * subclasses), judging from either bean definitions or the value of
     * {@code getObjectType} in the case of FactoryBeans.
     * <p><b>NOTE: This method introspects top-level beans only.</b> It does <i>not</i>
     * check nested beans which might match the specified type as well.
     * <p>Does consider objects created by FactoryBeans, which means that FactoryBeans
     * will get initialized. If the object created by the FactoryBean doesn't match,
     * the raw FactoryBean itself will be matched against the type.
     * <p>Does not consider any hierarchy this factory may participate in.
     * Use BeanFactoryUtils' {@code beansOfTypeIncludingAncestors}
     * to include beans in ancestor factories too.
     * <p>Note: Does <i>not</i> ignore singleton beans that have been registered
     * by other means than bean definitions.
     * <p>This version of getBeansOfType matches all kinds of beans, be it
     * singletons, prototypes, or FactoryBeans. In most implementations, the
     * result will be the same as for {@code getBeansOfType(type, true, true)}.
     * <p>The Map returned by this method should always return bean names and
     * corresponding bean instances <i>in the order of definition</i> in the
     * backend configuration, as far as possible.
     * @param type the class or interface to match, or {@code null} for all concrete beans
     * @return a Map with the matching beans, containing the bean names as
     * keys and the corresponding bean instances as values
     * @throws BeansException if a bean could not be created
     * @since 1.1.2
     * @see FactoryBean#getObjectType
     * @see BeanFactoryUtils#beansOfTypeIncludingAncestors(ListableBeanFactory, Class)
     */
    <T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;

    /**
     * Return the bean instances that match the given object type (including
     * subclasses), judging from either bean definitions or the value of
     * {@code getObjectType} in the case of FactoryBeans.
     * <p><b>NOTE: This method introspects top-level beans only.</b> It does <i>not</i>
     * check nested beans which might match the specified type as well.
     * <p>Does consider objects created by FactoryBeans if the "allowEagerInit" flag is set,
     * which means that FactoryBeans will get initialized. If the object created by the
     * FactoryBean doesn't match, the raw FactoryBean itself will be matched against the
     * type. If "allowEagerInit" is not set, only raw FactoryBeans will be checked
     * (which doesn't require initialization of each FactoryBean).
     * <p>Does not consider any hierarchy this factory may participate in.
     * Use BeanFactoryUtils' {@code beansOfTypeIncludingAncestors}
     * to include beans in ancestor factories too.
     * <p>Note: Does <i>not</i> ignore singleton beans that have been registered
     * by other means than bean definitions.
     * <p>The Map returned by this method should always return bean names and
     * corresponding bean instances <i>in the order of definition</i> in the
     * backend configuration, as far as possible.
     * @param type the class or interface to match, or {@code null} for all concrete beans
     * @param includeNonSingletons whether to include prototype or scoped beans too
     * or just singletons (also applies to FactoryBeans)
     * @param allowEagerInit whether to initialize <i>lazy-init singletons</i> and
     * <i>objects created by FactoryBeans</i> (or by factory methods with a
     * "factory-bean" reference) for the type check. Note that FactoryBeans need to be
     * eagerly initialized to determine their type: So be aware that passing in "true"
     * for this flag will initialize FactoryBeans and "factory-bean" references.
     * @return a Map with the matching beans, containing the bean names as
     * keys and the corresponding bean instances as values
     * @throws BeansException if a bean could not be created
     * @see FactoryBean#getObjectType
     * @see BeanFactoryUtils#beansOfTypeIncludingAncestors(ListableBeanFactory, Class, boolean, boolean)
     */
    <T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
            throws BeansException;

    /**
     * Find all names of beans whose {@code Class} has the supplied {@link Annotation}
     * type, without creating any bean instances yet.
     * @param annotationType the type of annotation to look for
     * @return the names of all matching beans
     * @since 4.0
     */
    String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);

    /**
     * Find all beans whose {@code Class} has the supplied {@link Annotation} type,
     * returning a Map of bean names with corresponding bean instances.
     * @param annotationType the type of annotation to look for
     * @return a Map with the matching beans, containing the bean names as
     * keys and the corresponding bean instances as values
     * @throws BeansException if a bean could not be created
     * @since 3.0
     */
    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;

    /**
     * Find an {@link Annotation} of {@code annotationType} on the specified
     * bean, traversing its interfaces and super classes if no annotation can be
     * found on the given class itself.
     * @param beanName the name of the bean to look for annotations on
     * @param annotationType the annotation class to look for
     * @return the annotation of the given type if found, or {@code null} otherwise
     * @throws NoSuchBeanDefinitionException if there is no bean with the given name
     * @since 3.0
     */
    @Nullable
    <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
            throws NoSuchBeanDefinitionException;

}
原文  https://segmentfault.com/a/1190000022478625
正文到此结束
Loading...