BeanFactory
-
BeanFactory定义获取Bean以及Bean的各种属性，顶层接口 -
ListableBeanFactory根据各种条件获取获取Bean的配置清单 -
HierarchicalBeanFactory继承关系BeanFactory，增加了对parentFactory支持 -
ConfigurableBeanFactory提供配置Factory的各种方法 -
AutowireCapableBeanFactory提供创建bean，自动注入，初始化以及应用Bean的后置处理器 -
AbstractAutowireCapableBeanFactory中 综合AbstractBeanFactory并对接口AutowireCapableBeanFactory进行实现 -
ConfigurableListableBeanFactoryBeanFactory配置清单，指定忽略类型以及接口等 -
AliasRegistry定义对alias的简单增删改等操作 -
SimpleAliasRegistry主要使用map作为alias的缓存，并对接口AliasRegistry进行实现 -
SingletonBeanRegistry定义对单例的注册机获取的接口 -
DefaultSingletonBeanRegistry对接口SingletonBeanRegistry的实现 -
FactoryBeanRegistrySupport在DefaultSingletonBeanRegistry基础上增加了对FactoryBean的特殊处理 -
AbstractBeanFactory综合FactoryBeanRegistrySupport和ConfigurableBeanFactory的功能，提供抽象实现 -
BeanDefinitionRegistry定义对BeanDefinition的各种增删改操作 -
DefaultListableBeanFactory综合上面所有功能，主要是对Bean注册后的处理
BeanFactory
/*
* @see BeanNameAware#setBeanName
* @see BeanClassLoaderAware#setBeanClassLoader
* @see BeanFactoryAware#setBeanFactory
* @see org.springframework.context.ResourceLoaderAware#setResourceLoader
* @see org.springframework.context.ApplicationEventPublisherAware#setApplicationEventPublisher
* @see org.springframework.context.MessageSourceAware#setMessageSource
* @see org.springframework.context.ApplicationContextAware#setApplicationContext
* @see org.springframework.web.context.ServletContextAware#setServletContext
* @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessBeforeInitialization
* @see InitializingBean#afterPropertiesSet
* @see org.springframework.beans.factory.support.RootBeanDefinition#getInitMethodName
* @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessAfterInitialization
* @see DisposableBean#destroy
* @see org.springframework.beans.factory.support.RootBeanDefinition#getDestroyMethodName
*/
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, 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;
// 5.1 Bean实例的提供工厂
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
// 提供对 bean 的检索，看看是否在 IOC 容器有这个名字的 bean
boolean containsBean(String name);
// 根据bean的名称判断bean的类型，如单例，原型
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
//得到 bean 实例的 Class 类型
@Nullable
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
@Nullable
Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
//得到 bean 的别名，如果根据别名检索，那么其原名也会被检索出来
String[] getAliases(String name);
}
ListableBeanFactory
根据各种条件获取获取Bean的配置清单
/**
* 该接口是对BeanFactory的扩展，允许预加载bean定义的BeanFactory可以实现此接
* 其目的在于使实现它的BeanFactory能够枚举所有的Bean
* 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
* 也即该接口只能枚举当前facotry的Bean
* 除getBeanNamesOfType，getBeansOfType方法外，其他方法也将忽略由SingletonBeanRegistry的方法
* 注册的Singleton Bean
* 除getBeanDefinitionCount和containsBeanDefinition外的方法不要频繁使用，性能很慢
*/
public interface ListableBeanFactory extends BeanFactory {
/**
* 根据给出的BeanName判断是否包含该Bean定义
* 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
* 也即该接口只能枚举当前facotry的Bean 忽略由SingletonBeanRegistry的方法 注册的Singleton Bean
*/
boolean containsBeanDefinition(String beanName);
/**
* 返回Bean定义的数目 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
* 也即该接口只能枚举当前facotry的Bean 忽略由SingletonBeanRegistry的方法 注册的Singleton Bean
*/
int getBeanDefinitionCount();
/**
* 返回所有Bean的BeanName组成的String数组
*/
String[] getBeanDefinitionNames();
/**
* 根据提供的类型返回匹配的BeanName数组 只检测顶层Bean，忽略嵌套Bean
* 对于FactoryBean，当提供的类型匹配FactoryBean.getObjectType时返回BeanName
* 当提供的类型匹配FactoryBean时返回&BeanName
* 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
* 也即该接口只能枚举当前facotry的Bean 不忽略由SingletonBeanRegistry的方法时注册的Singleton Bean
* 不检测无法实例化的Bean(如抽象Bean)
*/
String[] getBeanNamesForType(ResolvableType type);
/**
* 同上 String[] getBeanNamesForType(@Nullable Class<?> type);
* /** 作用同上 includeNonSingletons：判断是否匹配除Singleton外的其他scope allowEagerInit:
* false只匹配FactoryBean本身，true时还匹配FactoryBean.getObjectType()
*/
String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit);
/**
* 根据提供的类型返回匹配的Bean实例数组 只检测顶层Bean，忽略嵌套Bean
* 对于FactoryBean，当提供的类型匹配FactoryBean.getObjectType时返回BeanName
* 当提供的类型匹配FactoryBean时返回&BeanName
* 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
* 也即该接口只能枚举当前facotry的Bean 不忽略由SingletonBeanRegistry的方法时注册的Singleton Bean
* 不检测无法实例化的Bean(如抽象Bean)
*/
String[] getBeanNamesForType(@Nullable Class<?> type);
/**
* 同上 String[] getBeanNamesForType(@Nullable Class<?> type);
*
* /** 作用同上 includeNonSingletons：判断是否匹配除Singleton外的其他scope allowEagerInit:
* false只匹配FactoryBean本身，true时还匹配FactoryBean.getObjectType()
*/
String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);
/**
* 根据提供的类型返回匹配的Bean实例数组 只检测顶层Bean，忽略嵌套Bean
* 对于FactoryBean，当提供的类型匹配FactoryBean.getObjectType时返回BeanName
* 当提供的类型匹配FactoryBean时返回&BeanName
* 该接口不支持分层结构（对于继承了HierarchicalBeanFactory的BeanFactory来说）
* 也即该接口只能枚举当前facotry的Bean 不忽略由SingletonBeanRegistry的方法时注册的Singleton Bean
* 不检测无法实例化的Bean(如抽象Bean)
*/
<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
/**
* 作用同上 includeNonSingletons：判断是否匹配除Singleton外的其他scope allowEagerInit:
* false只匹配FactoryBean本身，true时还匹配FactoryBean.getObjectType()
*/
<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
throws BeansException;
/**
* 根据提供的注解类型找到对于的BeanName数组， 不创建实例， 但FactoryBean类型将被初始化，因为该方法考虑FactoryBean创建的对象
*/
String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
/**
* 根据提供的注解类型找到对于的Bean实例数组， FactoryBean类型将被初始化，因为该方法考虑FactoryBean创建的对象
*/
Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
/**
* 根据提供的注解类型和beanNaeme找到对应的Bean，Bean的类类型本身找不到，则遍历它的 接口和超类
* 如果不存在该Bean，则抛出NoSuchBeanDefinitionException 如果该Bean不支持该注解类型则返回null
*/
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException;
HierarchicalBeanFactory
/*
* 这个类接口比较简单 故名思义
* @see org.springframework.beans.factory.config.ConfigurableBeanFactory#setParentBeanFactory
*/
public interface HierarchicalBeanFactory extends BeanFactory {
@Nullable
BeanFactory getParentBeanFactory();
boolean containsLocalBean(String name);
}
ConfigurableBeanFactory
/*
* 提供配置Factory的各种方法
* @see org.springframework.beans.factory.BeanFactory
* @see org.springframework.beans.factory.ListableBeanFactory
* @see ConfigurableListableBeanFactory
*/
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
// 定义了两个作用域: 单例和原型.可以通过registerScope来添加.
String SCOPE_SINGLETON = "singleton";
String SCOPE_PROTOTYPE = "prototype";
// 父容器设置.而且一旦设置了就不让修改 搭配HierarchicalBeanFactory接口的getParentBeanFactory方法
void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
// 类加载器设置与获取.默认使用当前线程中的类加载器
void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);
@Nullable
ClassLoader getBeanClassLoader();
// 为了类型匹配,搞个临时类加载器.好在一般情况为null,使用上面定义的标准加载器
/*
* 设置、返回一个临时的类加载器
*/
void setTempClassLoader(@Nullable ClassLoader tempClassLoader);
@Nullable
ClassLoader getTempClassLoader();
/*
* 是否需要缓存bean metadata,比如bean difinition 和 解析好的classes.默认开启缓存
* 设置、是否缓存元数据，如果false，那么每次请求实例，都会从类加载器重新加载（热加载）
*/
void setCacheBeanMetadata(boolean cacheBeanMetadata);
boolean isCacheBeanMetadata();
/*
* 定义用于解析bean definition的表达式解析器
* Bean表达式分解器 supporting "#{...}" expressions in a Unified EL compatible style.
*/
void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
@Nullable
BeanExpressionResolver getBeanExpressionResolver();
// 类型转化器
// 指定一个Spring3.0 ConversionService来进行属性值的转换,是JavaBean中PropertyEditor的一种替代品
void setConversionService(@Nullable ConversionService conversionService);
@Nullable
ConversionService getConversionService();
// 属性编辑器
void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
// 注册自定义属性编辑器
void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
// 使用一个已经在BeanFactory里注册过的自定义属性编辑器来初始化给定的PropertyEditorRegistry.
void copyRegisteredEditorsTo(PropertyEditorRegistry registry);
/*
* BeanFactory用来转换bean属性值或者参数值的自定义转换器
* 设置、得到一个类型转换器
*/
void setTypeConverter(TypeConverter typeConverter);
TypeConverter getTypeConverter();
/*
* 为嵌入的值(如注释属性)添加字符串解析器
* string值解析器(如mvc中的ArgumentResolver了)
* 增加一个嵌入式的StringValueResolver
*/
void addEmbeddedValueResolver(StringValueResolver valueResolver);
boolean hasEmbeddedValueResolver();
@Nullable
String resolveEmbeddedValue(String value);
/**
* 后置处理器，BeanPostProcessor
**/
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
int getBeanPostProcessorCount();
/*--------------注册作用域---------------------*/
void registerScope(String scopeName, Scope scope);
String[] getRegisteredScopeNames();
@Nullable
Scope getRegisteredScope(String scopeName);
// 安全作用域 访问权限控制
AccessControlContext getAccessControlContext();
// 合并其他ConfigurableBeanFactory的配置,包括上面说到的BeanPostProcessor,作用域等
//从其他的工厂复制相关的所有配置
void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
/**---------------------------------注册别名*******************/
// 给指定的Bean注册别名
void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
void resolveAliases(StringValueResolver valueResolver);
/*------------------bean定义处理----------------------*/
// 返回指定Bean合并后的Bean定义，,包括父容器的
BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
// 是否是FactoryBean类型
boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;
/*--------- 处理bean依赖问题 ----------------------*/
// 设置一个Bean是否正在创建 bean创建状态控制.在解决循环依赖时有使用
void setCurrentlyInCreation(String beanName, boolean inCreation);
// bean创建状态控制.在解决循环依赖时有使用
// 返回指定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);
// 销毁所有的单例类
void destroySingletons();
}
AutowireCapableBeanFactory
对于想要拥有自动装配能力，并且想把这种能力暴露给外部应用的BeanFactory类需要实现此接口。
正常情况下，不要使用此接口，应该更倾向于使用BeanFactory或者ListableBeanFactory接口。此接口主要是针对框架之外，没有向Spring托管Bean的应用。通过暴露此功能，Spring框架之外的程序，具有自动装配等Spring的功能。
需要注意的是，ApplicationContext接口并没有实现此接口，因为应用代码很少用到此功能，如果确实需要的话，可以调用ApplicationContext的getAutowireCapableBeanFactory方法，来获取此接口的实例。
如果一个类实现了此接口，那么很大程度上它还需要实现BeanFactoryAware接口。它可以在应用上下文中返回BeanFactory。
/*
* @see org.springframework.beans.factory.BeanFactoryAware
* @see org.springframework.beans.factory.config.ConfigurableListableBeanFactory
* @see org.springframework.context.ApplicationContext#getAutowireCapableBeanFactory()
*/
public interface 
最低0.47元/天 解锁文章
126
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
