Spring源码解析 - BeanFactory接口源码解析与相关主接口解析（一）

r囧r小猫 2022-05-10 16:46 240阅读 0赞

**目录**

概述：

1、下面是BeanFactory接口源码翻译与说明：

2、beanFactory接口主要类图：

3、简单解析BeanFactory系列接口作用

1. BeanFactory

2. AutowireCapableBeanFactory

3. HierarchicalBeanFactory

4. ListableBeanFactory

5. ConfigurableBeanFactory

6. ConfigurableListableBeanFactory

附录--ConfigureableBeanFactory中定义的api:

--------------------

# 概述： #

说到Spring框架，人们往往大谈特谈一些似乎高逼格的东西，比如依赖注入，控制反转，面向切面等等。但是却忘记了最基本的一点，Spring的本质是一个bean工厂(beanFactory)或者说bean容器，它按照我们的要求，生产我们需要的各种各样的bean，提供给我们使用。只是在生产bean的过程中，需要解决bean之间的依赖问题，才引入了依赖注入(DI)这种技术。也就是说依赖注入是beanFactory生产bean时为了解决bean之间的依赖的一种技术而已。

那么我们为什么需要Spring框架来给我们提供这个beanFactory的功能呢？原因是一般我们认为是，可以将原来硬编码的依赖，通过Spring这个beanFactory这个工长来注入依赖，也就是说原来只有依赖方和被依赖方，现在我们引入了第三方——spring这个beanFactory，由它来解决bean之间的依赖问题，达到了松耦合的效果；这个只是原因之一，还有一个更加重要的原因：在没有spring这个beanFactory之前，我们都是直接通过new来实例化各种对象，现在各种对象bean的生产都是通过beanFactory来实例化的，这样的话，spring这个beanFactory就可以在实例化bean的过程中，做一些小动作——在实例化bean的各个阶段进行一些额外的处理，也就是说beanFactory会在bean的生命周期的各个阶段中对bean进行各种管理，并且spring将这些阶段通过各种接口暴露给我们，让我们可以对bean进行各种处理，我们只要让bean实现对应的接口，那么spring就会在bean的生命周期调用我们实现的接口来处理该bean.

BeanFactory是Spring容器实现的基础，访问Spring容器的根接口。每个bean都是通过string类型bean name进行标识.这边提供了设计模式单例,原型的替代实现。如果bean name配置为单例,应用内只会获取到一个实例。如果配置为原型,那么可以实例化好后填充属性(基于用户的配置)

#    **1、下面是BeanFactory接口源码翻译与说明：** #

package org.springframework.beans.factory;
    
    import org.springframework.beans.BeansException;
    import org.springframework.core.ResolvableType;
    import org.springframework.lang.Nullable;
    
    /**
     * 此接口是访问Spring bean容器的根接口,
     * 它是一个bean容器基本的客户端视图
     * 进一步的接口如:ListableBeanFactory和ConfigurableBeanFactory是用于指定目标的
     *
     *
     *这个接口被那些持有大量bean定义并且这些bean定义每个都被一个字符串名称惟一标识的对象实现。
     * 根据bean定义,此接口工厂要么返回一个所包含对象的独立实例(原型设计模式),要么返回所包含的一个惟一的共离的实例(
     * 替代单例设计模式,一个更优越的模式,它可以保证在此接口作用范围内的该实例是惟一的)。
     * 此接口返回什么样的类型是由此工厂的配置决定的:API没有改变。
     * 从Spring2.0开始,依据ApplicationContext容器,Web环境中的request,session等进一步的作用域开始可用
     *
     *
     * BeanFactory是程序组件的注册中心和集中配置中心,其通过此方法管理所包含对象(例如:不用再为个别对象读取配置文件)
     * 可以查看Expert One-on-One J2EE Design and Development这本书的第4章和11章,讨论此方面的益处
     *
     *<p> 注意:通常通过setter方法注入或者构造函数注入的方式来配置程序对象是优于程序本身控制其依赖对象初始化的,
     * Spring的依赖注入功能由使用这个接口的对象和它的子类实现
     *
     *
     *<p>通常一个BeanFactory会加载存储在配置资源文件(如XML文档)中的bean定义,然后使用org.springframework.beans
     * 包来配置对象。然而,一些简单的实现可以直接返回直接在JAVA 代码中返回的对象。
     * 此接口没有bean定义存储的约束,可以是:LDAP, RDBMS, XML,properties file等。
     * 鼓励实现此接口支持依赖注入。
     *
     
     *<p>与{@link ListableBeanFactory}中的方法相比，所有的方法都是如此
     *相比于ListableBeanFactory中的方法,如果这个接口真实类型为HierarchicalBeanFactory
     * ,这个接口中的所有方法会检查他的父接口
     * 如果一个bean没有在当前工厂实例中没有找到,将会直接请求其直接父工厂。
     * 这个工厂实例中的所有bean被假定为配置其所有父工厂实例中与其同名的bean。
     *
     */
    public interface BeanFactory {
    
    	/*
    	 * 用于区别FactoryBean,和FactoryBean创建的beans。
    	 * 例如:如果一个名字为myJndiObject的FactoryBean,BeanFactory调用getBean("myJndiObject")方法时返回的不是该FactoryBean
    	 * 实例,而是该FactoryBean调用其自身getObject方法返回的对象,要想返回该FactoryBean实例,则需要BeanFactory实例
    	 * 这样调用getBean("&;myJndiObject")
    	 *
    	 * 注:Bean和FactoryBean为Spring中的两种bean,bean为普通bean,FactoryBean为工厂bean,都规BeanFactory管理
    	 */
    	String FACTORY_BEAN_PREFIX = "&";
    
    
    	/**
    	 * 返回指定的bean实例,可以是共享的,可以是独立的。
    	 * 这个方法允许spring BeanFactory作为单例设计模式和原型设计模式的替代。
    	 * 在单例bean的情型下,调用者可以保留对返回对象的引用。
    	 * 将别名转换回正常的对应的beanName.
    	 * 如果在本实例中找不到bean,将会其父工厂中查找 。
    	 * @param name需要检索的bean的名字
    	 * @return 返回指定名字的bean实例
    	 * @throws BeansException如果检索不到对应的bean实例,抛出此异常
    	 *
    	 * 注:如果传入的名字为FactoryBean的名字,则如上面“注”。
    	 */
    	Object getBean(String name) throws BeansException;
    
    	/**
    	 * 返回指定的bean实例,可以是共享的,可以是独立的。
    	 * 与上面的getBean方法行为一样,但是提供了一个类型检测,如果找到的bean不是要求的类型,则抛出BeanNotOfRequiredTypeException
    	 * 异常。
    	 * 其他同上。
    	 * @param name
    	 * @param requiredType 返回bean实例的类型,可以是其实现的接口,也可以是其父类,也可以是null任意匹配
    	 * @return
    	 * @throws BeansException
    	 * (1)NoSuchBeanDefinitionException在该实例和其所有父类实例下均找不到指定的bean实例时抛出
    	 * (2)BeanNotOfRequiredTypeException 找到的实例与请求的类型不一样时抛出
    	 * (3)BeansException 指定的实例无法被创建时抛出
    	 */
    	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
    
    	/**
    	 * 返回指定名字的bean,可以是独立的,也可以是共享的
    	 * 允许清楚的指定普通bean的构造函数的参数列表或者是FactoryBean的工厂方法参数列表,这将会覆盖bean原定义中的默认参数。
    	 * @param name指定的需要返回的Bean的名字
    	 * @param args普通Bean的构造函数参数,或者是FactoryBean的工厂方法参数列表
    	 *(仅在创建一个新的实例的时候使用,而不是检索已存在实例的时候)
    	 * @return
    	 * @throws BeansException
    	 * (1)NoSuchBeanDefinitionException在该实例和其所有父类实例下均找不到指定的bean实例时抛出
    	 * (2)BeanNotOfRequiredTypeException 找到的实例与请求的类型不一样时抛出
    	 * (3)BeansException 指定的实例无法被创建时抛出
    	 * 此方法自Spring2.5后开始有
    	 */
    	Object getBean(String name, Object... args) throws BeansException;
    
    	/**
    	 * 返回任何惟一匹配 给定类型的bean实例。
    	 * 这个方法进入ListableBeanFactory的 by-type查找区域查找 ,但也可能给定类型的名字被转换成传统的按名字查找。
    	 * 针对更多对于beans集合的检索操作,使用ListableBeanFactory,BeanFactoryUtils。
    	 * 指定类型不可以是空
    	 * @param requiredType指定必须匹配的类型
    	 * @return 返回惟一匹配给定类型的bean实例
    	 * @throws BeansException
    	 * (1)NoSuchBeanDefinitionException在该实例和其所有父类实例下均找不到指定的bean实例时抛出
    	 * (2)BeanNotOfRequiredTypeException 找到的实例与请求的类型不一样时抛出
    	 * (3)BeansException 指定的实例无法被创建时抛出
    	 * 本方法从Spring 3.0添加
    	 */
    	<T> T getBean(Class<T> requiredType) throws BeansException;
    
    	/*
    	 * 返回指定类型的bean实例,可以是共享的,也可以是独立的
    	 * 允许清楚的指定普通bean的构造函数的参数列表或者是FactoryBean的工厂方法参数列表,这将会覆盖bean原定义中的默认参数。
    	 * 这个方法进入ListableBeanFactory的 by-type查找区域查找 ,但也可能给定类型的名字被转换成传统的按名字查找。
    	 * 针对更多对于beans集合的检索操作,使用ListableBeanFactory,BeanFactoryUtils。
    	 * @param requiredType 返回实例必须匹配的类型,可以是该实例实现的接口,可以是其父类,不可以是null
    	 * @param args当依据指定的参数创创建新的实例时指定的参数
    	 *(仅在创建一个新的实例的时候使用,而不是检索已存在实例的时候)
    	 * @return
    	 * @throws BeansException
    	 * (1)NoSuchBeanDefinitionException如果没有指定类型的bean定义时抛出。
    	 * (2)BeanDefinitionStoreException 指定了参数,但是返回的的有郊bean实例不是原型的时候抛出。
    	 *我的理解:需要返回的是新创建的,而不是已存在的
    	 * (3)BeansExceptionbean实例无法创建时抛出
    	 */
    	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    
    	/**
    	 * Return an provider for the specified bean, allowing for lazy on-demand retrieval
    	 * of instances, including availability and uniqueness options.
    	 * @param requiredType type the bean must match; can be an interface or superclass
    	 * @return a corresponding provider handle
    	 * @since 5.1
    	 * @see #getBeanProvider(ResolvableType)
    	 */
    	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    
    	/**
    	 * Return an provider for the specified bean, allowing for lazy on-demand retrieval
    	 * of instances, including availability and uniqueness options.
    	 * @param requiredType type the bean must match; can be a generic type declaration.
    	 * Note that collection types are not supported here, in contrast to reflective
    	 * injection points. For programmatically retrieving a list of beans matching a
    	 * specific type, specify the actual bean type as an argument here and subsequently
    	 * use {@link ObjectProvider#orderedStream()} or its lazy streaming/iteration options.
    	 * @return a corresponding provider handle
    	 * @since 5.1
    	 * @see ObjectProvider#iterator()
    	 * @see ObjectProvider#stream()
    	 * @see ObjectProvider#orderedStream()
    	 */
    	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
    
    	/**
    	 * 判断这个BeanFactory是否包含指定名字的bean定义或者是包含指定名字的处部已注册的bean实例。
    	 * 如果所给名字为别名,将会被转换回正确的规范的bean名字。
    	 * 如果当前BeanFactory是分层的,那么当在本实例范围内找不到时会在其所有父工厂实例里查找。
    	 * 如果存在指定名字的bean定义或者是单例实例,返回true,与抽象类还是实现类,延迟加载还是马上加载,当前范围还是其父工厂范围无关。
    	 * 所以注意:这个方法返回true,但并不意味着当传入同样名字调用此工厂的getBean方法时一定会获得对象实例。
    	 * @param name
    	 * @return
    	 */
    	boolean containsBean(String name);
    
    	/**
    	 * * 判断是否是一个共享的单例对象。如果是,查看getBean方法看其是否一定会返回同一实例。
    	 * 注意:此方法返回false时,并不表示给定名字的实例一定是独立的实例。
    	 * 它表示非单例实例,也可能是对应一定范围的Bean(request,session)。
    	 * 将别名转换回对应的规范的bean名字
    	 * 当在本工厂实例中无法找到给定名字的bean时,在其父工厂中查找
    	 */
    	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    
    	/*
    	 * 判断是否是一个独立的对象,如果是true,如果是,查看getBean方法看其是否一定会返回一个独立的实例。
    	 * 注意:此方法返回false时,并不表示给定名字的实例一定是单例实例。
    	 * 它表示非独立的实例,也可能是对应一定范围的Bean(request,session)。
    	 * 将别名转换回对应的规范的bean名字
    	 * 当在本工厂实例中无法找到给定名字的bean时,在其父工厂中查找
    	 * @param name
    	 * @return
    	 * @throws NoSuchBeanDefinitionException 如果给定名字的Bean不存在,抛出此异常
    	 */
    	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    
    	/**
    	 * 检查给定名字的实例是否匹配指定类型。
    	 * 更具体的说,检查通过给定名字的一个getBean调用返回的对象是否是指定的目录类型。
    	 * 如果给定名字的bean本工厂内找不到,将到其父工厂中查找
    	 * @param name
    	 * @param typeToMatch
    	 * @return
    	 * @throws NoSuchBeanDefinitionException如果给定名字的Bean不存在,抛出此异常
    	 * 本方法从spring 4.2开始
    	 */
    	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    
    
    	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    
    	/*
    	 * 明确给定名字对应Bean的类型。
    	 * 具体说就是,确定通过给定名字调用getBean方法返回的Object的类型。
    	 * 对于FactoryBean,返回FactoryBean创建的Object的类型,就像FactoryBean的getObjectType方法
    	 * @param name
    	 * @return
    	 * @throws NoSuchBeanDefinitionException
    	 */
    	@Nullable
    	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    
    	/*
    	 * 通过给定的bean名字,获取其所有的别名。
    	 * 当getBean方法调用时,那些所有的别名都指向同一个bean。
    	 * 如果传入的是一个别名,那么这个别名所对应的bean名字,和这个bean名字所对的其他别名被返回,这个bean的名字在数组的第一位。
    	 * @param name
    	 * @return
    	 */
    	String[] getAliases(String name);
    
    }

# 2、beanFactory接口主要类图： #

![70][]

# **3、简单解析BeanFactory系列接口作用** #

**详细可参考：**[https://blog.csdn.net/shenchaohao12321/article/details/80441204][https_blog.csdn.net_shenchaohao12321_article_details_80441204]

BeanFactory 是Spring bean容器的根接口.提供获取bean,是否包含bean,是否单例与原型,获取bean类型,bean 别名的api.

\-- AutowireCapableBeanFactory 添加集成其他框架功能.如果集成WebWork则可以使用Spring对Actions等进行管理.

\-- HierarchicalBeanFactory 提供父容器的访问功能

\-- -- ConfigurableBeanFactory 如名,提供factory的配置功能,眼花缭乱好多api

\-- -- -- ConfigurableListableBeanFactory 集大成者,提供解析,修改bean定义,并与初始化单例.

\-- ListableBeanFactory 提供容器内bean实例的枚举功能.这边不会考虑父容器内的实例.

看到这边,我们是不是想起了设计模式原则里的接口隔离原则

Interface Segregation Principle(ISP)：客户端不应该依赖它不需要的接口；类间的依赖关系应该建立在最小的接口上

对这个有兴趣的话,找度娘或者看看这个*[设计模式六大原则（4）：接口隔离原则][4]*

这边清晰地定义了如下的体系:

根接口BeanFactory(基础容器)

第二层: 第三方集成,继承体系,遍历bean

第三层: 配置功能

第四层: 配置+迭代

接下来具体分析下各个接口吧(顺便做目录):

1. BeanFactory

2. AutowireCapableBeanFactory

3. HierarchicalBeanFactory

4. ListableBeanFactory

5. ConfigurableBeanFactory

6. ConfigurableListableBeanFactory

## **1. BeanFactory** ##

BeanFactory是Spring bean容器的根接口.

每个bean都是通过string类型bean name或ID进行标识.这边提供了设计模式单例,原型的替代实现.

如果bean name配置为单例,应用内只会获取到一个实例.如果配置为原型,那么可以实例化好后填充属性(基于用户的配置).

BeanFactory作为应用集中配置管理的地方,极大简便应用开发,这样开发人员可以集中与业务.

BeanFactory需要管理bean的生命周期,比如初始化时需要按顺序实现如下接口:

1. BeanNameAware's \{@code setBeanName\}  
　　2. BeanClassLoaderAware's \{@code setBeanClassLoader\}  
　　3. BeanFactoryAware's \{@code setBeanFactory\}  
　　4. ResourceLoaderAware's \{@code setResourceLoader\}仅对application context有效  
　　5. ApplicationEventPublisherAware's \{@code setApplicationEventPublisher\}仅对application context有效  
　　6. MessageSourceAware's \{@code setMessageSource\}仅对application context有效  
　　7. ApplicationContextAware's \{@code setApplicationContext\}仅对application context有效  
　　8. ServletContextAware's \{@code setServletContext\}仅对application context有效  
　　9. \{@code postProcessBeforeInitialization\} methods of BeanPostProcessors  
　　10. InitializingBean's \{@code afterPropertiesSet\}  
　　11. a custom init-method definition xml中配置的init-method  
　　12. \{@code postProcessAfterInitialization\} methods of BeanPostProcessors

还有关闭容器的接口:

1. DisposableBean's \{@code destroy\}  
　　2. a custom destroy-method definition xml配置中的destroy-method

接口里定义了一个变量String FACTORY\_BEAN\_PREFIX = "&";

这是用来区分是获取FactoryBean还是FactoryBean的createBean创建的实例.如果&开始则获取FactoryBean;否则获取createBean创建的实例.

我们来看下定义的方法:

a, 获取bean,这边可以实现单例,原型

Object getBean(String name) throws BeansException; 可以用别名查找哦

<T> T getBean(String name, Class<T> requiredType) throws BeansException;

<T> T getBean(Class<T> requiredType) throws BeansException; 这边的类型可以是接口或者子类,但不能是null

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

b, 判断是否包含bean.陷阱出现:这边不管类是否抽象类,懒加载,是否在容器范围内,只要符合都返回true,所以这边true,不一定能从getBean获取实例

boolean containsBean(String name);

c, 单例,原型,bean类型的判断

boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;

d, 获取bean 的类型,别名

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

String\[\] getAliases(String name);

## **2. AutowireCapableBeanFactory** ##

在BeanFactory基础上实现对已存在实例的管理.

可以使用这个接口集成其它框架,捆绑并填充并不由Spring管理生命周期并已存在的实例.像集成WebWork的Actions 和Tapestry Page就很实用.

一般应用开发者不会使用这个接口,所以像ApplicationContext这样的外观实现类不会实现这个接口,如果真手痒痒可以通过ApplicationContext的getAutowireCapableBeanFactory接口获取.

这边定义了5种自动装配策略:不注入AUTOWIRE\_NO,使用bean name策略装配AUTOWIRE\_BY\_NAME,使用类型装配策略AUTOWIRE\_BY\_TYPE,使用构造器装配策略AUTOWIRE\_CONSTRUCTOR,自动装配策略AUTOWIRE\_AUTODETECT

这边的自动策略是先尝试构造器,然后才是byType.这边应该是跟xml配置文件中的装配策略对应.

继续看定义的api:

a, 创建和填充外部bean实例的典型方法

<T> T createBean(Class<T> beanClass) throws BeansException;

void autowireBean(Object existingBean) throws BeansException; // 使用autowireBeanProperties装配属性

Object configureBean(Object existingBean, String beanName) throws BeansException; // 自动装配属性,填充属性值,使用诸如setBeanName,setBeanFactory这样的工厂回调填充属性,最好还要调用post processor

Object resolveDependency(DependencyDescriptor descriptor, String beanName) throws BeansException;

b, 在bean的生命周期进行细粒度控制的专门方法

Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException; // 会执行bean完整的初始化,包括BeanPostProcessors和initializeBean

Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck) throws BeansException;

*　　　　*void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

Object initializeBean(Object existingBean, String beanName) throws BeansException;

Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException;

Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException;

Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException;

## **3. HierarchicalBeanFactory** ##

提供父容器的访问功能.至于父容器的设置,需要找ConfigurableBeanFactory的setParentBeanFactory(接口把设置跟获取给拆开了!).

这边可说的不多,直接上api:

a, 获取父容器 bean factory

BeanFactory getParentBeanFactory();

b, 判断当前容器是否保护bean

boolean containsLocalBean(String name);

## **4. ListableBeanFactory** ##

获取bean时,Spring 鼓励使用这个接口定义的api. 还有个Beanfactory方便使用.其他的4个接口都是不鼓励使用的.

提供容器中bean迭代的功能,不再需要一个个bean地查找.比如可以一次获取全部的bean(太暴力了),根据类型获取bean.在看SpringMVC时,扫描包路径下的具体实现策略就是使用的这种方式(那边使用的是BeanFactoryUtils封装的api).

如果同时实现了HierarchicalBeanFactory,返回值不会考虑父类BeanFactory,只考虑当前factory定义的类.当然也可以使用BeanFactoryUtils辅助类来查找祖先工厂中的类.

这个接口中的方法只会考虑本factory定义的bean.这些方法会忽略ConfigurableBeanFactory的registerSingleton注册的单例bean(getBeanNamesOfType和getBeansOfType是例外,一样会考虑手动注册的单例).当然BeanFactory的getBean一样可以透明访问这些特殊bean.当然在典型情况下,所有的bean都是由external bean定义,所以应用不需要顾虑这些差别.

注意:getBeanDefinitionCount和containsBeanDefinition的实现方法因为效率比较低,还是少用为好.

继续上api吧

a, 暴力获取全部bean的属性:

boolean containsBeanDefinition(String beanName);  //是否包含bean

int getBeanDefinitionCount();　// 当前factory中定义的bean数量

String\[\] getBeanDefinitionNames(); // 获取当前工厂中定义的所有bean 的name

b, 根据bean 的类型获取bean

这边的方法仅检查顶级bean.它不会检查嵌套的bean.FactoryBean创建的bean会匹配为FactoryBean而不是原始类型.

一样不会考虑父factory中的bean,非要用可以通过BeanFactoryUtils中的beanNamesForTypeIncludingAncestors.  
　　　　其他方式注册的单例这边会纳入判断.  
　　　　这个版本的getBeanNamesForType会匹配所有类型的bean,包括单例,原型,FactoryBean.返回的bean names会根据backend 配置的进行排序.

String\[\] getBeanNamesForType(Class<?> type); // 获取给定类型的bean names(包括子类),通过bean 定义或者FactoryBean的getObjectType判断.

String\[\] getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

<T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException; // 如果保护懒加载的类,FactoryBean初始化的类和工厂方法初始化的类会被初始化.就是说执行这个方法会执行对应的初始化.

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

c, 查找使用注解的类

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

d, 查找一个类上的注解,如果找不到,父类,接口使用注解也算.

<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType);

## **5. ConfigurableBeanFactory** ##

定义BeanFactory的配置.

这边定义了太多太多的api,比如类加载器,类型转化,属性编辑器,BeanPostProcessor,作用域,bean定义,处理bean依赖关系,合并其他ConfigurableBeanFactory,bean如何销毁.

定义了两个作用域: 单例和原型.可以通过registerScope来添加.

SCOPE\_SINGLETON,SCOPE\_PROTOTYPE

这边定义了好多好多的api,所以我们这边只讲业务,具体的api看文末的附录吧:

a, 父容器设置.而且一旦设置了就不让修改

b, 类加载器设置与获取.默认使用当前线程中的类加载器

c, 为了类型匹配,搞个临时类加载器.好在一般情况为null,使用上面定义的标准加载器

d, 是否需要缓存bean metadata,比如bean difinition 和 解析好的classes.默认开启缓存

e, 定义用于解析bean definition的表达式解析器

f, 类型转化器

g, 属性编辑器

h, BeanFactory用来转换bean属性值或者参数值的自定义转换器

i,string值解析器(想起mvc中的ArgumentResolver了)

j,大boss BeanPostProcessor用于增强bean初始化功能

k,作用域定义

l,访问权限控制

m, 合并其他ConfigurableBeanFactory的配置,包括上面说到的BeanPostProcessor,作用域等

n, bean定义处理

o, bean创建状态控制.在解决循环依赖时有使用

p, 处理bean依赖问题

q, bean生命周期管理-- 销毁bean

## **6. ConfigurableListableBeanFactory** ##

提供bean definition的解析,注册功能,再对单例来个预加载(解决循环依赖问题).

貌似我们一般开发就会直接定义这么个接口了事.而不是像Spring这样先根据使用情况细分那么多,到这边再合并

a, 设置忽略的依赖关系,注册找到的特殊依赖

void ignoreDependencyType(Class<?> type); // 忽略类型

void ignoreDependencyInterface(Class<?> ifc); // 忽略接口

void registerResolvableDependency(Class<?> dependencyType, Object autowiredValue);

boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor) throws NoSuchBeanDefinitionException;

b, 获取bean定义 (可以访问属性值跟构造方法的参数值)

BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

c, 锁定配置信息.在调用refresh时会使用到.

void freezeConfiguration();

boolean isConfigurationFrozen();

d, 预加载不是懒加载的单例.用于解决循环依赖问题

void preInstantiateSingletons() throws BeansException;

## **附录--ConfigureableBeanFactory中定义的api:** ##

a, 父容器设置.而且一旦设置了就不让修改

void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

b, 类加载器设置与获取.默认使用当前线程中的类加载器

void setBeanClassLoader(ClassLoader beanClassLoader);

ClassLoader getBeanClassLoader();

c, 为了类型匹配,搞个临时类加载器.好在一般情况为null,使用上面定义的标准加载器

void setTempClassLoader(ClassLoader tempClassLoader);

ClassLoader getTempClassLoader();

d, 是否需要缓存bean metadata,比如bean difinition 和 解析好的classes.默认开启缓存

void setCacheBeanMetadata(boolean cacheBeanMetadata);

boolean isCacheBeanMetadata();

e, 定义用于解析bean definition的表达式解析器

void setBeanExpressionResolver(BeanExpressionResolver resolver);

BeanExpressionResolver getBeanExpressionResolver();

f, 类型转化器

void setConversionService(ConversionService conversionService);

ConversionService getConversionService();

g, 属性编辑器

void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

h, BeanFactory用来转换bean属性值或者参数值的自定义转换器

void setTypeConverter(TypeConverter typeConverter);

TypeConverter getTypeConverter();

i,string值解析器(想起mvc中的ArgumentResolver了)

void addEmbeddedValueResolver(StringValueResolver valueResolver);

String resolveEmbeddedValue(String value);

j,大boss BeanPostProcessor用于增强bean初始化功能

void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

int getBeanPostProcessorCount();

k,作用域定义

void registerScope(String scopeName, Scope scope);

String\[\] getRegisteredScopeNames();

Scope getRegisteredScope(String scopeName);

l,访问权限控制

AccessControlContext getAccessControlContext();

m, 合并其他ConfigurableBeanFactory的配置,包括上面说到的BeanPostProcessor,作用域等

void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

n, bean定义处理

void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException; // 注册别名

void resolveAliases(StringValueResolver valueResolver);

BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; // 合并bean定义,包括父容器的

boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException; // 是否是FactoryBean类型

o, bean创建状态控制.在解决循环依赖时有使用

void setCurrentlyInCreation(String beanName, boolean inCreation);

boolean isCurrentlyInCreation(String beanName);

p, 处理bean依赖问题

void registerDependentBean(String beanName, String dependentBeanName);

String\[\] getDependentBeans(String beanName);

String\[\] getDependenciesForBean(String beanName);

q, bean生命周期管理-- 销毁bean

void destroyBean(String beanName, Object beanInstance);

void destroyScopedBean(String beanName);

void destroySingletons();

参考：[https://www.cnblogs.com/leftthen/p/5261837.html][https_www.cnblogs.com_leftthen_p_5261837.html]

[70]: /images/20220505/563e6b079e7c4572b27bd4cb08b11fe4.png
[https_blog.csdn.net_shenchaohao12321_article_details_80441204]: https://blog.csdn.net/shenchaohao12321/article/details/80441204
[4]: http://blog.jobbole.com/85537/
[https_www.cnblogs.com_leftthen_p_5261837.html]: https://www.cnblogs.com/leftthen/p/5261837.html