前言:
在我们的前两篇文章当中我们看完之后其实我们都会发现当我们进行相关的重要的行为的时候如我们看到的GetBean或者在Register方法的时候会出现BeanFactroy进行调用那么这个时候我们就会产生一个疑惑这个到底是什么为什么这么重要,在我没有说的时候我们从字面上进行一个简单的分析就是说这个是一个Bean工厂那么工厂不就是用来进行加工的那么加工肯定是需要原料以及加工流程的这么想的话其实已经把这个功能基本上都全部进行概括了,那么下面的话我们就来进行解说。
1.用到BeanFactory的地方:这里的话就大概进行记录
//这个就是对多播器的Bean进行一次的注册
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
2.什么是BeanFactory：
BeanFactory他就是一个顶级的工厂的接口,那么就是生产以及管理Bean的一个工厂,那么这个接口也是SpringIOC容器的一个核心接口提供了一些通用的方法如:getBean,containsBean方法但是这个只是一个接口那么就是他的实现类如：如 DefaultListableBeanFactory、XmlBeanFactory、ApplicationContext等下面的话就来看看这个接口的源码:
public interface BeanFactory {
//对FactoryBean的转义定义，因为如果使用bean的名字检索FactoryBean得到的对象是工厂生成的对象，
//如果需要得到工厂本身，需要转义
String FACTORY_BEAN_PREFIX = "&";
//根据bean的名字，获取在IOC容器中得到bean实例
Object getBean(String name) throws BeansException;
//根据bean的名字和Class类型来得到bean实例，增加了类型安全验证机制。
<T> T getBean(String name, @Nullable 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;
//提供对bean的检索，看看是否在IOC容器有这个名字的bean
boolean containsBean(String name);
//根据bean名字得到bean实例
//这个Bean是不是单例
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
//是不是多例的
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
//用于检查给定名称的 Bean 是否可以被赋值给指定的目标类型。
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);
}3.BeanFactory接口的大家族
(这个就是以DefaultListableBeanFactory这个是Spring默认的工厂实现为例)：其实这个就是一种继承的关系也就是可以在实现父类的功能的基础之上可以实现一些自己的额外的一些功能
1.ListableBeanFactory:
这个接口有几大说明的点 第一点就是说实现这个接口的工厂可以一次性批量获得其管理的Bean而不是一个个进行获得 第二点为只会管理当前工厂里面的Bean而不是管其他工厂的Bean,如果说你必须要管的话那么就是可以通过BeanFactoryUtils工具类才能实现 第三点就是说这个里面的方法是对工厂里面的BeanDefinition起作用
public interface ListableBeanFactory extends BeanFactory {
// 对BeanDefinition的一些细节操作
boolean containsBeanDefinition(String beanName);
int getBeanDefinitionCount();
String[] getBeanDefinitionNames();
// 对 BeanFactory 中获取ObjectProvider方法的拓展
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType, boolean allowEagerInit);
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType, boolean allowEagerInit);
// 获取指定类型（子类）的bean names
// boolean includeNonSingletons 参数决定是否考虑 singleotn 以外的bean
// boolean allowEagerInit 是否初始化对应FactoryBean，如果false则类型直接匹配对应的FactoryBean
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);
/**
基本同上，返回的 Map 结构
k：beanName
v：beanInstance
**/
<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实例集合：beanName -> bean 实例
Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
// 获取指定 beanName 上的注解
// 同样涉及 FactoryBean 初始化的问题，由参数 allowFactoryBeanInit 决定
@Nullable
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException;
@Nullable
<A extends Annotation> A findAnnotationOnBean(
String beanName, Class<A> annotationType, boolean allowFactoryBeanInit)
throws NoSuchBeanDefinitionException;
<A extends Annotation> Set<A> findAllAnnotationsOnBean(
String beanName, Class<A> annotationType, boolean allowFactoryBeanInit)
throws NoSuchBeanDefinitionException;
}
2.HierarchicalBeanFactory：
这个接口的实现就是比较简单了就是实现了分层的能力如不同的模块可以拥有不同BeanFactory但是可以共享一些全局配置的一些属性,可以访问父工厂里面的Bean
3.AutowireCapableBeanFactory:
这个接口的话 第一点实现一个自动装配的能力,第二点还提供了控制Spring中Bean对象的生命周期的一整套的方法为 实例化 属性填充 初始化回调(这个里面就是会设置到后置处理器的回调的处理)这个过程 第三点:允许非 Spring 组件的实例也借助它来实现自动装配以及控制Bean的生命周期
public interface AutowireCapableBeanFactory extends BeanFactory {
//这个就是表示的就是进行不进行依赖注入
int AUTOWIRE_NO = 0;
//这个就是表示通过name进行依赖注入
int AUTOWIRE_BY_NAME = 1;
//这个就是表示的就是通过type进行依赖注入
int AUTOWIRE_BY_TYPE = 2;
//这个就是表示的就是构造方法的依赖注入
int AUTOWIRE_CONSTRUCTOR = 3;
//这个是根据类的结构选择合适的依赖注入的方式但是这个已经过时了
@Deprecated
int AUTOWIRE_AUTODETECT = 4;
//这个就是说根据这个的后缀进行依赖注入
String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";
//这个就是说创建一个新的Bean的实例
<T> T createBean(Class<T> beanClass) throws BeansException;
//对于给定的Bean对象进行属性填充
// 通过after-instantiation 和 property post-processing 回调的执行
void autowireBean(Object existingBean) throws BeansException;
//这个就是通过自动装配的话然后配置这个Bean对象
// 如设置这个Bean的名字以及BeanFactory也可以是后置处理器
Object configureBean(Object existingBean, String beanName) throws BeansException;
//-------------------------------------------------------------------------
// 下面的话就是可以控制一个Bean的生命周期的全过程:
//1.进行是实例化的处理
//2.进行属性填充
//3.初始化
//-------------------------------------------------------------------------
/*这个就是对Bean进行实例化
*1.通过这个Bean的Class对象进行创建(这个毫无疑问就是进行反射)
*2.自动装配的模式是byType还是说是byName
*3.应用所有的BeanPostProcessor回调(这个就是进行后置处理器)
* */
@Deprecated(since = "6.1")
Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;see #applyBeanPostProcessorsAfterInitialization
*/
//这个就是通过自动装配的策略创建一个实例但是不应用标准的后置处理器
Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
//这个就是对Bean对象进行属性填充一些已经存在的Bean对象通过name或者说是type
void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
throws BeansException;
//通过BeanName对已经创建成功的Bean进行属性赋值
void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
//这个就是引用后置处理器也就是说在Bean初始化之前进行一些操作
@Deprecated(since = "6.1")
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException;
//这个就是进行初始化Bean
//这个就是要应用一些工厂的回调如setBeanName setFactory
//除此以外还会应用所有的BeanPostProcessor
Object initializeBean(Object existingBean, String beanName) throws BeansException;
//这个就是说应用这个方法的话就是Bean初始话之后就会进行一些额外逻辑的处理
@Deprecated(since = "6.1")
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException;
//这个就是要销毁Bean
// 使用DisposableBean接口定义的销毁方法
void destroyBean(Object existingBean);
//匹配属性对应的Bean
//解析唯一匹配给定对象类型(如果有的话)的bean实例，包括它的bean名称
//如果我们通过调用GetBean()方法匹配多个的Bean的话那么其实就是
//getBean(class)的变体
<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;
//解析给定bean名称的bean实例， 向目标工厂方法公开提供依赖描述符。
// 这实际上是getBean(String, Class)的一个变体，
Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;
@Nullable
// 针对此工厂中定义的bean解析指定的依赖项，注入的时候很有用。
// 通过一个依赖的描述（对方法，字段，构造器的抽象），获得一个bean
Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;
//它负责根据给定的依赖描述符在Bean工厂中查找并返回一个匹配的Bean实例
@Nullable
Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;
}
4.ConfigurableBeanFactory
这个接口的话其实就是继承了HierarchicalBeanFactory接口那么在基本的分层功能的基础上拓展了一些配置功能
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
//作用域是单例的
String SCOPE_SINGLETON = "singleton";
//作用域是多例的
String SCOPE_PROTOTYPE = "prototype";
//设置父BeanFactory
void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
//设置Bean的类加载器默认的情况下就是线程上下文类加载器
void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);
@Nullable
//获得类加载器
ClassLoader getBeanClassLoader();
//设置临时的类加载器为了类型的匹配默认是没有的
void setTempClassLoader(@Nullable ClassLoader tempClassLoader);
@Nullable
//获得临时的类加载器
ClassLoader getTempClassLoader();
//设置Bean的元数据的缓存
// 如果关闭这个设置的话那么创建一个Bean实例的话将重新查询classloader
//则这个就是体现出缓存的作用就是提高效率
void setCacheBeanMetadata(boolean cacheBeanMetadata);
boolean isCacheBeanMetadata();
// 设置和获取SpEL表达式解析器
void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
@Nullable
BeanExpressionResolver getBeanExpressionResolver();
//设置以及获得后台的引导的任务执行器
void setBootstrapExecutor(@Nullable Executor executor);
@Nullable
Executor getBootstrapExecutor();
//设置以及获得转换服务
void setConversionService(@Nullable ConversionService conversionService);
@Nullable
ConversionService getConversionService();
//添加属性编辑器
void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
void copyRegisteredEditorsTo(PropertyEditorRegistry registry);
//配置和获取类型转化器，
// 相当于整合了 ConversationService 和 PropertyEditorRegister
void setTypeConverter(TypeConverter typeConverter);
TypeConverter getTypeConverter();
//为注入的值添加一个String解析器
void addEmbeddedValueResolver(StringValueResolver valueResolver);
boolean hasEmbeddedValueResolver();
@Nullable
String resolveEmbeddedValue(String value);
//添加以及获取Bean的后置处理器
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
int getBeanPostProcessorCount();
//注册自定义的作用范围
void registerScope(String scopeName, Scope scope);
String[] getRegisteredScopeNames();
@Nullable
Scope getRegisteredScope(String scopeName);
//设置以及获得启动的步骤
void setApplicationStartup(ApplicationStartup applicationStartup);
ApplicationStartup getApplicationStartup();
//从被给的BeanFactory拷贝一些配置
void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
//注册以及解决别名
void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
void resolveAliases(StringValueResolver valueResolver);
//获得合并的Bean定义
BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
//是否为工厂Bean
boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;
//设置Bean的创建的状态
void setCurrentlyInCreation(String beanName, boolean inCreation);
//判断Bean是否在创建中
boolean isCurrentlyInCreation(String beanName);
//注册一个依赖的Bean在这个Bean在被销毁之前
void registerDependentBean(String beanName, String dependentBeanName);
//如果有的话，返回指定bean的所有bean的名称
String[] getDependentBeans(String beanName);
//如果有的话，返回指定bean的依赖的所有bean的名称
String[] getDependenciesForBean(String beanName);
//销毁给定的Bean的名字的Bean
void destroyBean(String beanName, Object beanInstance);
//销毁指定作用域的Bean
void destroyScopedBean(String beanName);
//销毁这个工厂里面的所有的单例的Bean包括实现disposable接口的Bean
void destroySingletons();
}5.ConfigurableListableBeanFactory:
这个接口的话就是整合上面所有的BeanFactory接口的全部的方法除此以外还额外拓展了preInstantiateSingletons方法
preInstantiateSingletons():
这个方法就是对Bean进行一些提前的实例化确保所有被配置为单例且不是懒加载的Bean都被提前创建和初始化(会走完整个Bean的生命周期)提高整体的一个效率如:数据库管理池,缓存管理器这些Bean
public void preInstantiateSingletons() throws BeansException {
// 记录日志，跟踪预实例化单例的过程
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// 创建一个当前 Bean 定义名称列表的副本，以允许在初始化方法中注册新的 Bean 定义
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 触发所有非懒加载的单例 Bean 的初始化
List<CompletableFuture<?>> futures = new ArrayList<>();
// 设置标志，表示当前处于预实例化阶段
this.preInstantiationPhase = true;
this.preInstantiationThread.set(PreInstantiation.MAIN);
try {
// 遍历所有 Bean 名称
for (String beanName : beanNames) {
// 获取合并后的本地 Bean 定义
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 如果 Bean 不是抽象的且是单例的
if (!mbd.isAbstract() && mbd.isSingleton()) {
// 预实例化单例 Bean，并将返回的 CompletableFuture 添加到 futures 列表中
//因为有的Bean是可以进行提前的创建的提高效率
//进行Bean的创建
CompletableFuture<?> future = preInstantiateSingleton(beanName, mbd);
if (future != null) {
futures.add(future);
}
}
}
} finally {
// 清除预实例化线程标识
this.preInstantiationThread.remove();
// 重置预实例化阶段标志
this.preInstantiationPhase = false;
}
// 如果有未完成的 CompletableFuture，等待它们全部完成
if (!futures.isEmpty()) {
try {
CompletableFuture.allOf(futures.toArray(new CompletableFuture<?>[0])).join();
} catch (CompletionException ex) {
// 重新抛出异常
ReflectionUtils.rethrowRuntimeException(ex.getCause());
}
}
// 触发所有适用的 Bean 的后初始化回调
for (String beanName : beanNames) {
// 获取单例实例
Object singletonInstance = getSingleton(beanName, false);
// 如果单例实例实现了 SmartInitializingSingleton 接口
if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) {
// 记录启动步骤
StartupStep smartInitialize = getApplicationStartup().start("spring.beans.smart-initialize")
.tag("beanName", beanName);
// 调用 afterSingletonsInstantiated 方法
//这个就是说单例Bean完成初始化之后进行一个额外的操作
smartSingleton.afterSingletonsInstantiated();
// 结束启动步骤记录
smartInitialize.end();
}
}
}
