org.springframework.beans.factory.support

## 类 StaticListableBeanFactory

- java.lang.Object
- - org.springframework.beans.factory.support.StaticListableBeanFactory

- 所有已实现的接口:
    BeanFactory, ListableBeanFactory

      public class StaticListableBeanFactory
      extends Object
      implements ListableBeanFactory

  Static `BeanFactory` implementation which allows to register existing singleton instances programmatically. Does not have support for prototype beans or aliases.

  Serves as example for a simple implementation of the `ListableBeanFactory` interface, managing existing bean instances rather than creating new ones based on bean definitions, and not implementing any extended SPI interfaces (such as `ConfigurableBeanFactory`).

  For a full-fledged factory based on bean definitions, have a look at `DefaultListableBeanFactory`.

  从以下版本开始:
    06.01.2003
  作者:
    Rod Johnson, Juergen Hoeller
  另请参阅:
    `DefaultListableBeanFactory`

- - ### 字段概要

    - ### 从接口继承的字段 org.springframework.beans.factory.BeanFactory

      `FACTORY_BEAN_PREFIX`

  - ### 构造器概要

    构造器
    构造器和说明
    `StaticListableBeanFactory()` Create a regular `StaticListableBeanFactory`, to be populated with singleton bean instances through `addBean(java.lang.String, java.lang.Object)` calls.
    `StaticListableBeanFactory(Map<String,Object> beans)` Create a `StaticListableBeanFactory` wrapping the given `Map`.

  - ### 方法概要

    所有方法 实例方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `void` | `addBean(String name, Object bean)` Add a new singleton bean.
    `boolean` | `containsBean(String name)` 判断我们的容器中是否包含了当前的bean对象
    `boolean` | `containsBeanDefinition(String name)` 查看是否包含指定名字的Bean 不支持向上或向下查找 不支持查找非配置文件定义的单例Bean
    `<A extends Annotation> A` | `findAnnotationOnBean(String beanName, Class<A> annotationType)` 在指定name对应的Bean上找指定的注解，如果没有找到的话，去指定Bean的父类或者父接口上查找
    `String[]` | `getAliases(String name)` 获取bean的所有的别名 Will ask the parent factory if the bean cannot be found in this factory instance.
    `<T> T` | `getBean(Class<T> requiredType)` 通过指定的bean的类型去容器中获取对象 若容器中有多个想同类型的bean 我们通过ctx.getBean(beanType.class) 就会抛出异常
    `<T> T` | `getBean(Class<T> requiredType, Object... args)` 获取bean实例
    `Object` | `getBean(String name)` 通过bean 去容器中获取一个bean对象
    `<T> T` | `getBean(String name, Class<T> requiredType)` 通过bean 去容器中获取一个bean对象
    `Object` | `getBean(String name, Object... args)` 通过bean 去容器中获取一个bean对象
    `int` | `getBeanDefinitionCount()` 获取容器中的所有bean定义
    `String[]` | `getBeanDefinitionNames()` 查看此BeanFactory中包含的Bean数量 不支持向上或向下查找 不支持查找非配置文件定义的单例Bean
    `String[]` | `getBeanNamesForAnnotation(Class<? extends Annotation> annotationType)` 找到所有带有指定注解类型的Bean
    `String[]` | `getBeanNamesForType(Class<?> type)` 返回此BeanFactory中所有指定类型的Bean的名字。
    `String[]` | `getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit)` 返回此BeanFactory中所有指定类型（或指定类型的子类型）的Bean的名字。
    `String[]` | `getBeanNamesForType(org.springframework.core.ResolvableType type)` 返回此BeanFactory中所包含的所有Bean定义的名称 不支持向上或向下查找 不支持查找非配置文件定义的单例Bean
    `<T> Map<String,T>` | `getBeansOfType(Class<T> type)` 返回此BeanFactory中所有指定类型（或指定类型的子类型）的Bean的名字。
    `<T> Map<String,T>` | `getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)` 返回此BeanFactory中所有指定类型（或指定类型的子类型）的Bean的名字。
    `Map<String,Object>` | `getBeansWithAnnotation(Class<? extends Annotation> annotationType)` 找到所有带有指定注解的Bean，返回一个以Bean的name为键，其对应的Bean实例为值的Map
    `Class<?>` | `getType(String name)` 通过beanName获取对应bean的class类型
    `boolean` | `isPrototype(String name)` 是不是原型的
    `boolean` | `isSingleton(String name)` 判断当前的bean是不是单例的
    `boolean` | `isTypeMatch(String name, Class<?> typeToMatch)` 是不是匹配的类型
    `boolean` | `isTypeMatch(String name, org.springframework.core.ResolvableType typeToMatch)` 是不是匹配的类型 Will ask the parent factory if the bean cannot be found in this factory instance.

    - ### 从类继承的方法 java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### 构造器详细资料

    - #### StaticListableBeanFactory

          public StaticListableBeanFactory()

      Create a regular `StaticListableBeanFactory`, to be populated with singleton bean instances through `addBean(java.lang.String, java.lang.Object)` calls.

    - #### StaticListableBeanFactory

          public StaticListableBeanFactory(Map<String,Object> beans)

      Create a `StaticListableBeanFactory` wrapping the given `Map`.

      Note that the given `Map` may be pre-populated with beans; or new, still allowing for beans to be registered via `addBean(java.lang.String, java.lang.Object)`; or `Collections.emptyMap()` for a dummy factory which enforces operating against an empty set of beans.

      参数:
        `beans` - a `Map` for holding this factory's beans, with the bean name String as key and the corresponding singleton object as value
      从以下版本开始:
        4.3

  - ### 方法详细资料

    - #### addBean

          public void addBean(String name,
                              Object bean)

      Add a new singleton bean. Will overwrite any existing instance for the given name.
      参数:
        `name` - the name of the bean
        `bean` - the bean instance

    - #### getBean

          public Object getBean(String name)
                         throws BeansException

      从接口复制的说明: `BeanFactory`
      通过bean 去容器中获取一个bean对象
      指定者:
        `getBean` 在接口中 `BeanFactory`
      参数:
        `name` - 名称(有可能是bean的真正的名称 也有可能是工厂bean的名称 也有可能是bean的别名)
      返回:
        返回bean实例
      抛出:
        `NoSuchBeanDefinitionException` - 抛出的异常，容器中没有该bean的定义
        `BeansException` - if the bean could not be obtained

    - #### getBean

          public <T> T getBean(String name,
                               @Nullable
                               Class<T> requiredType)
                        throws BeansException

      从接口复制的说明: `BeanFactory`
      通过bean 去容器中获取一个bean对象
      指定者:
        `getBean` 在接口中 `BeanFactory`
      参数:
        `name` - 名称(有可能是bean的真正的名称 也有可能是工厂bean的名称 也有可能是bean的别名)
        `requiredType` - 去容器中获取Bean的class类型 可以是实现的接口和父类
      返回:
        返回Bean对应的实例
      抛出:
        `NoSuchBeanDefinitionException` - 抛出的异常，容器中没有该bean的定义
        `BeanNotOfRequiredTypeException` - 容器中没有指定class类型的bean
        `BeansException` - bean还没有被创建

    - #### getBean

          public Object getBean(String name,
                                Object... args)
                         throws BeansException

      从接口复制的说明: `BeanFactory`
      通过bean 去容器中获取一个bean对象
      指定者:
        `getBean` 在接口中 `BeanFactory`
      参数:
        `name` - 名称(有可能是bean的真正的名称 也有可能是工厂bean的名称 也有可能是bean的别名)
        `args` - 这个是用于指定传入获取bean的构造函数的参数,通过传入该参数，那么就可以明确的知道去调用哪个构造函数是实例化对象
      返回:
        返回Bean对应的实例
      抛出:
        `NoSuchBeanDefinitionException` - 抛出的异常，容器中没有该bean的定义
        `BeanDefinitionStoreException` - 主要用于多例模式下的构造器创建？？？？暂时没理解
        `BeansException` - bean还没有被创建

    - #### getBean

          public <T> T getBean(Class<T> requiredType)
                        throws BeansException

      从接口复制的说明: `BeanFactory`
      通过指定的bean的类型去容器中获取对象 若容器中有多个想同类型的bean 我们通过ctx.getBean(beanType.class) 就会抛出异常
      指定者:
        `getBean` 在接口中 `BeanFactory`
      参数:
        `requiredType` - class对象需要的类型
      返回:
        返回的bean对象
      抛出:
        `NoSuchBeanDefinitionException` - 没有对应class的bean定义
        `NoUniqueBeanDefinitionException` - 找到多个匹配的
        `BeansException` - 创建bean的实例
      另请参阅:
        `ListableBeanFactory`

    - #### getBean

          public <T> T getBean(Class<T> requiredType,
                               Object... args)
                        throws BeansException

      从接口复制的说明: `BeanFactory`
      获取bean实例
      指定者:
        `getBean` 在接口中 `BeanFactory`
      参数:
        `requiredType` - bean的类型
        `args` - 构造函数的参数的类型，在实例化的过程中不需要去推断构造函数了
      返回:
        bean实例
      抛出:
        `NoSuchBeanDefinitionException` - if there is no such bean definition
        `BeanDefinitionStoreException` - if arguments have been given but the affected bean isn't a prototype
        `BeansException` - if the bean could not be created

    - #### containsBean

          public boolean containsBean(String name)

      从接口复制的说明: `BeanFactory`
      判断我们的容器中是否包含了当前的bean对象
      指定者:
        `containsBean` 在接口中 `BeanFactory`
      参数:
        `name` - the name of the bean to query
      返回:
        whether a bean with the given name is present

    - #### isSingleton

          public boolean isSingleton(String name)
                              throws NoSuchBeanDefinitionException

      从接口复制的说明: `BeanFactory`
      判断当前的bean是不是单例的
      指定者:
        `isSingleton` 在接口中 `BeanFactory`
      参数:
        `name` - the name of the bean to query
      返回:
        whether this bean corresponds to a singleton instance
      抛出:
        `NoSuchBeanDefinitionException` - if there is no bean with the given name
      另请参阅:
        `BeanFactory.getBean(java.lang.String)`, `BeanFactory.isPrototype(java.lang.String)`

    - #### isPrototype

          public boolean isPrototype(String name)
                              throws NoSuchBeanDefinitionException

      从接口复制的说明: `BeanFactory`
      是不是原型的
      指定者:
        `isPrototype` 在接口中 `BeanFactory`
      参数:
        `name` - the name of the bean to query
      返回:
        whether this bean will always deliver independent instances
      抛出:
        `NoSuchBeanDefinitionException` - if there is no bean with the given name
      另请参阅:
        `BeanFactory.getBean(java.lang.String)`, `BeanFactory.isSingleton(java.lang.String)`

    - #### isTypeMatch

          public boolean isTypeMatch(String name,
                                     org.springframework.core.ResolvableType typeToMatch)
                              throws NoSuchBeanDefinitionException

      从接口复制的说明: `BeanFactory`
      是不是匹配的类型 Will ask the parent factory if the bean cannot be found in this factory instance.
      指定者:
        `isTypeMatch` 在接口中 `BeanFactory`
      参数:
        `name` - the name of the bean to query
        `typeToMatch` - the type to match against (as a `ResolvableType`)
      返回:
        `true` if the bean type matches, `false` if it doesn't match or cannot be determined yet
      抛出:
        `NoSuchBeanDefinitionException` - if there is no bean with the given name
      另请参阅:
        `BeanFactory.getBean(java.lang.String)`, `BeanFactory.getType(java.lang.String)`

    - #### isTypeMatch

          public boolean isTypeMatch(String name,
                                     @Nullable
                                     Class<?> typeToMatch)
                              throws NoSuchBeanDefinitionException

      从接口复制的说明: `BeanFactory`
      是不是匹配的类型
      指定者:
        `isTypeMatch` 在接口中 `BeanFactory`
      参数:
        `name` - the name of the bean to query
        `typeToMatch` - the type to match against (as a `Class`)
      返回:
        `true` if the bean type matches, `false` if it doesn't match or cannot be determined yet
      抛出:
        `NoSuchBeanDefinitionException` - if there is no bean with the given name
      另请参阅:
        `BeanFactory.getBean(java.lang.String)`, `BeanFactory.getType(java.lang.String)`

    - #### getType

          public Class<?> getType(String name)
                           throws NoSuchBeanDefinitionException

      从接口复制的说明: `BeanFactory`
      通过beanName获取对应bean的class类型
      指定者:
        `getType` 在接口中 `BeanFactory`
      参数:
        `name` - the name of the bean to query
      返回:
        the type of the bean, or `null` if not determinable
      抛出:
        `NoSuchBeanDefinitionException` - if there is no bean with the given name
      另请参阅:
        `BeanFactory.getBean(java.lang.String)`, `BeanFactory.isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)`

    - #### getAliases

          public String[] getAliases(String name)

      从接口复制的说明: `BeanFactory`
      获取bean的所有的别名

      Will ask the parent factory if the bean cannot be found in this factory instance.

      指定者:
        `getAliases` 在接口中 `BeanFactory`
      参数:
        `name` - the bean name to check for aliases
      返回:
        the aliases, or an empty array if none
      另请参阅:
        `BeanFactory.getBean(java.lang.String)`

    - #### containsBeanDefinition

          public boolean containsBeanDefinition(String name)

      从接口复制的说明: `ListableBeanFactory`
      查看是否包含指定名字的Bean 不支持向上或向下查找 不支持查找非配置文件定义的单例Bean
      指定者:
        `containsBeanDefinition` 在接口中 `ListableBeanFactory`

    - #### getBeanDefinitionCount

          public int getBeanDefinitionCount()

      从接口复制的说明: `ListableBeanFactory`
      获取容器中的所有bean定义
      指定者:
        `getBeanDefinitionCount` 在接口中 `ListableBeanFactory`
      返回:
        the number of beans defined in the factory

    - #### getBeanDefinitionNames

          public String[] getBeanDefinitionNames()

      从接口复制的说明: `ListableBeanFactory`
      查看此BeanFactory中包含的Bean数量 不支持向上或向下查找 不支持查找非配置文件定义的单例Bean
      指定者:
        `getBeanDefinitionNames` 在接口中 `ListableBeanFactory`

    - #### getBeanNamesForType

          public String[] getBeanNamesForType(@Nullable
                                              org.springframework.core.ResolvableType type)

      从接口复制的说明: `ListableBeanFactory`
      返回此BeanFactory中所包含的所有Bean定义的名称 不支持向上或向下查找 不支持查找非配置文件定义的单例Bean
      指定者:
        `getBeanNamesForType` 在接口中 `ListableBeanFactory`

    - #### getBeanNamesForType

          public String[] getBeanNamesForType(@Nullable
                                              Class<?> type)

      从接口复制的说明: `ListableBeanFactory`
      返回此BeanFactory中所有指定类型的Bean的名字。判断是否是指定类型的标准有两个：a Bean定义。 b FactoryBean的getObjectType方法。 只考虑最顶层的Bean，对于嵌套的Bean，即使符合类型也不予考虑 会考虑FactoryBean创建出的Bean 不支持向上或向下查找 不支持查找非配置文件定义的单例Bean 此签名的getBeanNamesForType方法会返回所有Scope类型的Bean，在大多数的实现中，其返回结果和 其重载方法getBeanNamesForType(type, true, true)返回结果一致。 返回结果中，Bean名字的顺序应该和其定义时一样
      指定者:
        `getBeanNamesForType` 在接口中 `ListableBeanFactory`

    - #### getBeanNamesForType

          public String[] getBeanNamesForType(@Nullable
                                              Class<?> type,
                                              boolean includeNonSingletons,
                                              boolean allowEagerInit)

      从接口复制的说明: `ListableBeanFactory`
      返回此BeanFactory中所有指定类型（或指定类型的子类型）的Bean的名字。判断是否是指定类型的标准有 两个：a Bean定义，b FactoryBean的getObjectType方法。 只考虑最顶层的Bean，对于嵌套的Bean，即使符合类型也不予考虑 会考虑FactoryBean创建出的Bean 不支持向上或向下查找 不支持查找非配置文件定义的单例Bean 此签名的getBeanNamesForType方法会返回所有Scope类型的Bean，在大多数的实现中，其返回结果和 其重载方法getBeanNamesForType(type, true, true)返回结果一致。 返回结果中，Bean名字的顺序应该和其定义时一样
      指定者:
        `getBeanNamesForType` 在接口中 `ListableBeanFactory`

    - #### getBeansOfType

          public <T> Map<String,T> getBeansOfType(@Nullable
                                                  Class<T> type)
                                           throws BeansException

      从接口复制的说明: `ListableBeanFactory`
      返回此BeanFactory中所有指定类型（或指定类型的子类型）的Bean的名字。判断是否是指定类型的标准有 两个：a Bean定义，b FactoryBean的getObjectType方法。 只考虑最顶层的Bean，对于嵌套的Bean，即使符合类型也不予考虑 会考虑FactoryBean创建出的Bean 不支持向上或向下查找 不支持查找非配置文件定义的单例Bean 此签名的getBeanNamesForType方法会返回所有Scope类型的Bean，在大多数的实现中，其返回结果和 其重载方法getBeanNamesForType(type, true, true)返回结果一致。 返回结果中，Bean名字的顺序应该和其定义时一样 如果Bean是通过FactoryBean创建的，那么只考虑设置了allowEagerInit标志位的Bean。如果 没有设置allowEagerInit标志位，则只考虑FactoryBean的类型
      指定者:
        `getBeansOfType` 在接口中 `ListableBeanFactory`
      抛出:
        `BeansException`

    - #### getBeansOfType

          public <T> Map<String,T> getBeansOfType(@Nullable
                                                  Class<T> type,
                                                  boolean includeNonSingletons,
                                                  boolean allowEagerInit)
                                           throws BeansException

      从接口复制的说明: `ListableBeanFactory`
      返回此BeanFactory中所有指定类型（或指定类型的子类型）的Bean的名字。判断是否是指定类型的标准有 两个：a Bean定义，b FactoryBean的getObjectType方法。 只考虑最顶层的Bean，对于嵌套的Bean，即使符合类型也不予考虑 会考虑FactoryBean创建出的Bean 不支持向上或向下查找 不支持查找非配置文件定义的单例Bean 此签名的getBeanNamesForType方法会返回所有Scope类型的Bean，在大多数的实现中，其返回结果和 其重载方法getBeanNamesForType(type, true, true)返回结果一致。 返回结果中，Bean名字的顺序应该和其定义时一样
      指定者:
        `getBeansOfType` 在接口中 `ListableBeanFactory`
      抛出:
        `BeansException`

    - #### getBeanNamesForAnnotation

          public String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType)

      从接口复制的说明: `ListableBeanFactory`
      找到所有带有指定注解类型的Bean
      指定者:
        `getBeanNamesForAnnotation` 在接口中 `ListableBeanFactory`

    - #### getBeansWithAnnotation

          public Map<String,Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType)
                                                    throws BeansException

      从接口复制的说明: `ListableBeanFactory`
      找到所有带有指定注解的Bean，返回一个以Bean的name为键，其对应的Bean实例为值的Map
      指定者:
        `getBeansWithAnnotation` 在接口中 `ListableBeanFactory`
      抛出:
        `BeansException`

    - #### findAnnotationOnBean

          @Nullable
          public <A extends Annotation> A findAnnotationOnBean(String beanName,
                                                                          Class<A> annotationType)
                                                                   throws NoSuchBeanDefinitionException

      从接口复制的说明: `ListableBeanFactory`
      在指定name对应的Bean上找指定的注解，如果没有找到的话，去指定Bean的父类或者父接口上查找
      指定者:
        `findAnnotationOnBean` 在接口中 `ListableBeanFactory`
      抛出:
        `NoSuchBeanDefinitionException`