【源码】Spring —— BeanFactory 解读 1 BeanFactory 系列接口

前言
版本
BeanFactory
- HierarchicalBeanFactory
- ListableBeanFactory
- AutowireCapableBeanFactory
- - ConfigurableBeanFactory
  - - ConfigurableListableBeanFactory
总结

前言

BeanFactory

，字面意思：

bean工厂

，事实上，我们获取的

bean

就是由该接口的实现类生产，它维护所有的

bean

实例，并提供对应的方法

本章节罗列

BeanFactory

相关接口，从定义的方法认知整体接口

版本

Spring 5.3.x

BeanFactory

public interface BeanFactory {

	/**
	 * 标识获取 FactoryBean 本身的前缀 &
	 * 比如：getBean("&a") 是获取 name = a
	 * 		的 FactoryBean 本身
	 */
	String FACTORY_BEAN_PREFIX = "&";

	/**
	 * 根据指定 name 获取 bean
	 * 支持 别名检索 ｜ 父BeanFactory 检索
	 * @param requiredType 指定 bean 的类型
	 * @param args 指定构造 bean 实例对应的参数，如果获取到多个，会抛异常
	 */
	Object getBean(String name) throws BeansException;
	<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;

	/**
	 * 略
	 */
	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	/**
	 * 当前 beanFactory 中是否存在指定 name 对应的 BeanDefinition
	 * 		或者 单例实例
	 * 支持 别名检索 ｜ 父beanFactory 检索
	 * 注意：返回 true 并不意味着 getBean 可以获取到对应的 bean
	 */
	boolean containsBean(String name);

	/**
	 * 指定 name 的 bean 是否是 单例
	 * 不是 单例 也不意味着是 原型
	 * 支持 别名检索 ｜ 父beanFactory 检索
	 */
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	/**
	 * 指定 name 的 bean 是否原型，同 isSingleton
	 */
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	/**
	 * 指定 name 对应的 bean 是否匹配给定 ResolvableType
	 * 支持 别名检索 ｜ 父beanFactory
	 */
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

	/**
	 * 返回指定 name 的 bean 的类型
	 * 如果是个 FactoryBean，则返回的是它内部对象的类型，
	 * 		但是如果内部类型没有被提前暴露，则依据参数
	 * 		allowFactoryBeanInit 决定是否要提前初始化
	 * 		当前 FactoryBean 以获取内部类型
	 */
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
	@Nullable
	Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;

	/**
	 * 返回指定 beanName 的所有别名
	 * 如果指定的 beanName 也是一个别名，会返回原始 name 和所有 别名
	 * 		的数组（原始 name 在数组首位）
	 * 会同时在父 beanFactory 检索
	 */
	String[] getAliases(String name);

}

定义获取 FactoryBean 本身的前缀 &
定义一组 getBean 方法获取 bean 实例，这种设计方法很通用，内部实现最终都会收口到一个方法上，对调用者友好
值得一提的是， containsBean 方法返回 true 并不意味这 getBean 可以获取对应的 bean 实例
上述检索方法都支持 别名检索 ，同时也会去 父BeanFactory 中检索
其他方法见注释

HierarchicalBeanFactory

public interface HierarchicalBeanFactory extends BeanFactory {

	// 返回 父BeanFactory
	@Nullable
	BeanFactory getParentBeanFactory();

	/**
	 * 跟 BeanFactory#containsBean 类似，该方法只检索
	 * 		当前 BeanFactory，而不会去 父BeanFactory 检索
	 * @param name
	 * @return
	 */
	boolean containsLocalBean(String name);

}

BeanFactory

的

子接口

：

提供了层级关系维护， getParentBeanFactory 用于获取 父BeanFactory
containsLocalBean 不同于 BeanFactory#containsBean ，只会在当前层级中判断是否存在指定 name 的 bean实例

ListableBeanFactory

public interface ListableBeanFactory extends BeanFactory {
	
	/**
	 * 当前层级是否包含指定 beanName 对应的 BeanDefinition
	 */
	boolean containsBeanDefinition(String beanName);

	// 返回当前层级所有 BeanDefinition 个数
	int getBeanDefinitionCount();

	// 返回当前层级所有 BeanDefinition 名称数组
	String[] getBeanDefinitionNames();

	// 略
	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType, boolean allowEagerInit);
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType, boolean allowEagerInit);

	/**
	 * 获取当前层级指定类型的 beanName 数组
	 * @param type
	 * @param includeNonSingletons 是否包括非单例
	 * @param allowEagerInit 是否需要初始化懒加载单例｜FactoryBean
	 * @return
	 */
	String[] getBeanNamesForType(ResolvableType type);
	String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit);
	String[] getBeanNamesForType(@Nullable Class<?> type);
	String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

	/**
	 * 获取当前层级指定类型的所有 bean 实例，name -> bean实例
	 * @param type
	 * @param includeNonSingletons 是否包括非单例
	 * @param allowEagerInit 是否需要初始化懒加载单例｜FactoryBean
	 * @param <T>
	 * @return
	 * @throws BeansException
	 */
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
			throws BeansException;

	// 返回标注了指定 注解 的 beanName 数组
	String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);

	// 返回标注了指定 注解 的 bean示例集合：name -> bean实例
	Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;

	/**
	 * 依次从 指定bean 其父类 接口 和 工厂方法 上获取指定注解
	 */
	@Nullable
	<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
			throws NoSuchBeanDefinitionException;

}

BeanFactory

的

子接口

：

拓展了 枚举 功能，提供了多重维度的 get 方法，详情见注释
这些方法都仅限于当前层级的 枚举 ，如果需要考虑父级，可以借助 BeanFactoryUtils
containsBeanDefinition getBeanDefinitionCount getBeanDefinitionNames 这几个方法是完全基于当前 BeanFactory 中的 BeanDefinition 的，换句话说，对于我们通过 registerSingleton 等方法注册的 bean 实例，它们是不感知的
getBeanNamesForType getBeansOfType 方法是会感知自行注册 bean 实例的，当然大多数场景的 bean 实例都是基于 BeanDefinition 扫描的
getBeanDefinitionCount containsBeanDefinition 基于性能问题不建议直接调用

AutowireCapableBeanFactory

public interface AutowireCapableBeanFactory extends BeanFactory {
	
	// 默认注入模式，也就是基于注解的注入
	int AUTOWIRE_NO = 0;

	// 基于 name 注入
	int AUTOWIRE_BY_NAME = 1;

	// 基于类型注入
	int AUTOWIRE_BY_TYPE = 2;

	// 推断构造方法后注入
	int AUTOWIRE_CONSTRUCTOR = 3;

	// 自动检测 @Deprecated
	@Deprecated
	int AUTOWIRE_AUTODETECT = 4;

	// 通过此后缀获取原始实例（比如 代理实例的 target）
	String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";

	// 创建、填充 bean实例 相关方法

	/**
	 * 创建指定类型的 bean实例：包括 实例创建、带有注解属性的注入、
	 * 		各种初始化回调，还有 BeanPostProcessors 的执行
	 */
	<T> T createBean(Class<T> beanClass) throws BeansException;

	/**
	 * 填充指定 bean实例：执行实例化后回调、属性处理（注解注入）
	 * 本质上是为了给新实例 ｜ 反序列化实例 (重新)填充注解注入的字段和方法
	 */
	void autowireBean(Object existingBean) throws BeansException;

	/**
	 * 配置给定 bean实例：属性注入、property values 应用、工厂回调执行、post processors 执行
	 */
	Object configureBean(Object existingBean, String beanName) throws BeansException;

	// 更加细粒度控制 bean 生命周期的方法

	/**
	 * 基于 autowireMode 创建 bean实例
	 */
	Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

	/**
	 * 基于 autowireMode 实例化指定 bean实例
	 */
	Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

	/**
	 * 基于 autowireMode 注入指定 bean实例 的属性
	 */
	void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
			throws BeansException;

	/**
	 * 执行给定 beanName 对应 BeanDefinition 的 property values
	 */
	void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

	/**
	 * 初始化给定 bean：执行工厂回调、执行所有 post processors
	 */
	Object initializeBean(Object existingBean, String beanName) throws BeansException;

	// 执行给定 bean实例 的所有 BeanPostProcessor#postProcessBeforeInitialization
	Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException;

	// 执行给定 bean实例 的所有 BeanPostProcessor#postProcessAfterInitialization
	Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException;

	// 销毁指定 bean实例
	void destroyBean(Object existingBean);

	// 基于 name type 的依赖解析，可以理解为针对属性获取待注入的 bean实例
	<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;
	Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;
	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;
	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;
}

BeanFactory

的

子接口

：

拓展了 自动装配 能力
它的能力被单独拎出来，因此允许非 Spring 组件的实例也借助它来实现 自动装配
在 ApplicationContext 上下文中，可以通过 ApplicationContext#getAutowireCapableBeanFactor 获取该实例，当然也可以获取 BeanFactory 进行类型转换
它定义了不同的粒度生命周期的相关方法，详细见注释

ConfigurableBeanFactory

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry

HierarchicalBeanFactory

的子接口，拓展了配置能力，这是

Spring

常用的类设计模式，这一层抽象了所有

BeanFactory

类相关组件的配置，比如：

BeanExpressionResolver ： SpEL 解析器
ConversionService ：转换服务
PropertyEditorRegistrar ：支持添加 PropertyEditorRegistrar 以注册 PropertyEditor
TypeConverter ：类型转换的顶层接口，相当于整合了 ConversionService 和 PropertyEditorRegistry
StringValueResolver ：支持添加 StringValueResolver 来解析处理字符串
BeanPostProcessor ：支持添加 BeanPostProcessor 对 bean实例 进行后处理
另外还提供了诸如 getMergedBeanDefinition isFactoryBean 等方法

ConfigurableListableBeanFactory

public interface ConfigurableListableBeanFactory
		extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory

集大成者，整合了所有接口的能力，并拓展了

getBeanDefinition

等方法

总结

BeanFactory ，顶层接口，提供了最基础的方法譬如 getBean containsBean
HierarchicalBeanFactory ，子接口，拓展了 层级关系
ListableBeanFactory ，子接口，拓展了 枚举能力
AutowireCapableBeanFactory ，子接口，拓展了 自动装配 能力
ConfigurableBeanFactory ，子接口，拓展了相关组件 可配置化 的能力
ConfigurableListableBeanFactory ，集大成者，直接实现类 DefaultListableBeanFactory

下一章节：【源码】Spring —— BeanFactory 解读 2 AbstractBeanFactory

【源码】Spring —— BeanFactory 解读 1 BeanFactory 系列接口前言版本BeanFactory总结

【源码】Spring —— BeanFactory 解读 1 BeanFactory 系列接口

前言

版本

BeanFactory

HierarchicalBeanFactory

ListableBeanFactory

AutowireCapableBeanFactory

ConfigurableBeanFactory

ConfigurableListableBeanFactory

总结

继续阅读

驯服烂代码_驯服Tomcat：Tomcat 5的过滤技巧

基于Springboot+VUE+Mysql的大学生校园疫情防控管理系统

Using MessageConverter

驯服烂代码_C＃中的驯服配置

如何提高个人开源网站源码开发利用率

Spring Cloud整合Sleuth，当请求完成后，Zipkin没有链路信息

JAVA自学之路——马士兵

Rabbitmq命令行手动创建队列

整合 Spring 开发框架及服务端技术

SSM整合02---Spring-SpringMVC层一、添加web框架支持二、web.xml三、spring-mvc.xml

SSM框架（二）------------表现层的SpringMVC

Intellij idea基于Maven 的SSM 框架整合

Spring数据和Redis

SpringMVC的启动过程源码分析1 SpringMVC 配置XML的方式启动2 SpringMVC纯注解模式启动

Java Spring 框架

SpringCloud微服务（四）之ribbon笔记ribbon是什么？入门案例自定义均衡负载算法