深入理解Spring容器体系结构

前言

在 spring 中，任何实现了 BeanFactory 接口的类都可以视为容器，它是 IOC 功能实现的核心，用于完成类实例从加载到销毁的整个生命周期的控制，这些被 spring 所管理的实例统称为 bean。

根据抽象层级的不同，容器又分为 BeanFactory 的直接实现，与基于 BeanFactory 的扩展实现 ApplicationContext，后者在前者的基础继承了 ResourceLoader和EnvironmentCapable接口，因而具备从某类运行环境的资源中直接加载 bean 的能力。

ApplicationContext 最常用的两个实现 ClassPathXmlApplicationContext 和 AnnotationConfigApplicationContext ，前者用于从项目路径下根据 xml 文件加载 bean，而后者通过扫描类注解完成 bean 的加载。这两者 ApplicationContext 实际上就对应了我们所熟悉的两类配置方式，前者就是传统的 xml 配置，后者则是通过 @Component 与 @Bean 等注解对 bean 进行配置。

本文将基于 spring 源码 5.2.x 分支，基于 BeanFactory 与 ApplicationContext 两大接口，介绍 spring 的两类容器的结构体系。

一、BeanFactory 接口体系

总览 BeanFactory 体系，按照接口的抽象层次，大体可以分层四层：

第一层：BeanFactory；
第二层：HierarchicalBeanFactory，ListableBeanFactory，AutowireCapableBeanFactory；
第三层：ConfigurableBeanFactory，此外还有一个关联性较强SingletonBeanRegistry；
第四层：ConfigurableListableBeanFactory；

1、BeanFactory

BeanFactory 是整个容器体系最顶层的接口，它的内容如下：

public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";
    // 获取bean相关的方法
    Object getBean(String name) throws BeansException;
    <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;
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

    // 容器 bean 属性的一些判断
    boolean containsBean(String name);
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

    // 获取 bean 在容器中的一些属性
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    String[] getAliases(String name);
}

我们可以直接从 BeanFactory 提供的方法看出，BeanFactory 定义了容器的一些基本能力：

容器可以根据名称、类型、构造函数这三个要素，单独或两两组合的的获得一个 bean；
容器获取的 bean 可以是单例多种多例的；
容器中的 bean 可以拥有多个名称；

2、分层工厂，批量工厂，自动装配工厂

BeanFactory 存在两个子接口 HierarchicalBeanFactory 和 ListableBeanFactory，它们进一步的扩展了容器的能力。

分层工厂 HierarchicalBeanFactory

HierarchicalBeanFactory 接口用于表示一个多集嵌套的 BeanFactory：

public interface HierarchicalBeanFactory extends BeanFactory {
    // 获取父工厂
    BeanFactory getParentBeanFactory();
    // 当前工厂是否存在与名称对应的 bean
    boolean containsLocalBean(String name);
}

批量工厂 ListableBeanFactory

ListableBeanFactory 接口定义了容器根据类型、名称或类上的注解批量的获取 bean 或 bean 名称的能力：

public interface ListableBeanFactory extends BeanFactory {
    // 容器中是否存在 bean
    boolean containsBeanDefinition(String beanName);
    // 容器中定义了多少 bean
    int getBeanDefinitionCount();
    // 获取容器中所有定义了的 bean 名称
    String[] getBeanDefinitionNames();
    
    // 根据类型批量获取 bean
    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);
    <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;
    
    // 根据类上的注解获取 bean
    String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
    <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType) throws NoSuchBeanDefinitionException;
}

根据注释，当一个类同时实现了 HierarchicalBeanFactory 和 ListableBeanFactory 接口时，ListableBeanFactory 中的方法是不会考虑到父工厂的，也就是说，spring 中的 ListableBeanFactory 接口表示的能力只针对当前实现它的类。

自动装配工厂 AutowireCapableBeanFactory

AutowireCapableBeanFactory 如同他的名称一样，用于为容器关联的 bean 提供自动装配功能：

public interface AutowireCapableBeanFactory extends BeanFactory {
    
    // 自动装配方式
	int AUTOWIRE_NO = 0; // 不自动装配
	int AUTOWIRE_BY_NAME = 1; // 根据bean名称自动装配
	int AUTOWIRE_BY_TYPE = 2; // 根据bean类型自动装配
	int AUTOWIRE_CONSTRUCTOR = 3; // 根据bean的构造方法自动装配
	int AUTOWIRE_AUTODETECT = 4; // 根据反射信息自动选择合适的方式自动装配，spring3 以后不再推荐该方式
	String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";
    
    // bean的创建与装配相关的方法
	<T> T createBean(Class<T> beanClass) throws BeansException;
	void autowireBean(Object existingBean) throws BeansException;
	Object configureBean(Object existingBean, String beanName) throws BeansException;
    
    // bean 声明周期相关的方法
	Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
	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;
	void destroyBean(Object existingBean);
    
    // 获取 bean 依赖的相关方法
	<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;
	Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;
    
}

比较值得注意的是，通过 AutowireCapableBeanFactory 定义的 API 不难看出，只要能获得对应的实例，我们是可以手动的对非 spring 托管的 bean 进行依赖注入的。

3、分层配置工厂

BeanFactory 的三级接口为 ConfigurableBeanFactory，它实现了 HierarchicalBeanFactory 和 SingletonBeanRegistry接口。

从字面上理解，它是一个可配置的 BeanFactory，它不仅支持 BeanFactory 分层，还支持以单例的方式操作 bean。它是整个 BeanFactory 体系中最重要的一环，通过这个接口，spring 通过该接口规定了一个 BeanFactory 应该具备以及可以从中获取哪些可配置的组件与参数。

这里我们先了解一下 SingletonBeanRegistry 接口，这个接口定义了容器根据名称注册或获取 bean 单例的能力：

public interface SingletonBeanRegistry {
    void registerSingleton(String beanName, Object singletonObject);
    Object getSingleton(String beanName);
    boolean containsSingleton(String beanName);
    String[] getSingletonNames();
    int getSingletonCount();
    Object getSingletonMutex();
}

然后回到 ConfigurableBeanFactory ，它在 HierarchicalBeanFactory 的基础上补充了大量的方法：

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
	String SCOPE_SINGLETON = "singleton"; // 单例
	String SCOPE_PROTOTYPE = "prototype"; // 多例

	// 配置父工厂
	void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
	
	// 配置类加载器
	void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);
	ClassLoader getBeanClassLoader();
	void setTempClassLoader(@Nullable ClassLoader tempClassLoader);
	ClassLoader getTempClassLoader();
	
	// 配置bean元信息缓存
	void setCacheBeanMetadata(boolean cacheBeanMetadata);
	boolean isCacheBeanMetadata();
	
	// 配置bean配置的表达式解析器，用于提供@Value值注册等功能
	void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
	BeanExpressionResolver getBeanExpressionResolver();
	
	// 配置类型转换器
	void setConversionService(@Nullable ConversionService conversionService);
	ConversionService getConversionService();
	void setTypeConverter(TypeConverter typeConverter);
	TypeConverter getTypeConverter();
	
	// 配置属性注册表
	void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
	void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
	void copyRegisteredEditorsTo(PropertyEditorRegistry registry);
	
	// 配置字符串解析器，用于提供解析xml中的bean属性的表达式等功能
	void addEmbeddedValueResolver(StringValueResolver valueResolver);
	boolean hasEmbeddedValueResolver();
	String resolveEmbeddedValue(String value);
	
	// 配置bean的后置处理器BeanPostProcessor
	void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
	int getBeanPostProcessorCount();

	// 配置bean的作用域，接口中已经默认提供了单例或多例的scopeName
	void registerScope(String scopeName, Scope scope);
	String[] getRegisteredScopeNames();
	Scope getRegisteredScope(String scopeName);

	// 配置访问控制
	AccessControlContext getAccessControlContext();

	// 从其他的工厂复制配置
	void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

	// 给指定的bean注册别名
	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的创建状态，管理bean的依赖与被依赖关系，用于处理循环依赖等问题
	void setCurrentlyInCreation(String beanName, boolean inCreation);
	boolean isCurrentlyInCreation(String beanName);
	void registerDependentBean(String beanName, String dependentBeanName);
	String[] getDependentBeans(String beanName);
	String[] getDependenciesForBean(String beanName);

	// bean的销毁相关方法
	void destroyBean(String beanName, Object beanInstance);
	void destroyScopedBean(String beanName);
	void destroySingletons();
}

这个接口定义了非常多的 API，按照用途来说，这些 API 大概分为三类：

bean 的管理方法：包括 bean 依赖状态与生命周期的获取，bean 的销毁，bean 作用域域、定义信息与别名的操作；
bean 创建过程中使用组件的配置：包括字符串解析器，类加载器，类型转换器，属性注册表，bean 的后置处理器等组件的配置；
工厂本身状态的一些操作：包括父工程配置，工厂间依赖的拷贝，以及访问控制等。

4、批量分层配置工厂

ConfigurableListableBeanFactory 是 BeanFactory 体系的第四级接口，也是最后一级接口。它继承了 ConfigurableBeanFactory、ListableBeanFactory与AutowireCapableBeanFactory 接口，因此它具备到目前为止 BeanFactory 前三级接口定义的全部能力。

它表示了一个可以配置的，允许按单例或多例操作 bean，支持自动装配 bean，并且可以根据 bean 的名称、类型或者类上注解批量获取 bean 的超级 bean 工厂。

它在上述功能的基础上，又针对各接口提供的功能定义了一些新的补充方法：

public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
    // 自动装配相关配置
    void ignoreDependencyType(Class<?> type);
    void ignoreDependencyInterface(Class<?> ifc);
    void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);
    boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor) throws NoSuchBeanDefinitionException;
    
    // 获取bean的定义信息
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    
    // 获取已经定义的bean名称的迭代器
    Iterator<String> getBeanNamesIterator();
    // 清除bean元信息缓存
    void clearMetadataCache();
    
    // 冻结配置，冻结后工厂的配置不允许进一步修改
    void freezeConfiguration();
    boolean isConfigurationFrozen();
    
    // 实例化所有未实例化的单例bean
    void preInstantiateSingletons() throws BeansException;
}

二、ApplicationContext 接口体系

严格来说，ApplicationContext 是 BeanFactory 的子类，或者说，BeanFactory 是其组成的一部分。但是由于其附加了很多 BeanFactory 所不具备的功能，因此一般将其与 BeanFactory 体系分开看待。

ApplicationContext 有 web 环境上下文与非 web 环境上下文的两个实现体系，单纯按接口层次分为三层：

第一层：ApplicationContext ；
第二层：WebApplicationContext 和 ConfigurableApplicationContext ；
第三层：ConfigurableApplicationContext ；

1、ApplicationContext

ApplicationContext 接口是基于 BeanFactory 的进一步实现，它同时实现了 EnvironmentCapable，ListableBeanFactory，HierarchicalBeanFactory，MessageSource，ApplicationEventPublisher 以及 ResourcePatternResolver 接口。相较 BeanFactory ，它的功能要更加强大。

ApplicationContext 继承的各个接口分别对应它提供各项功能：

HierarchicalBeanFactory 与 ListableBeanFactory：提供像 BeanFactory 一样操作 bean 的功能；
ApplicationEventPublisher：提供向监听器发布事件的能力；
ResourcePatternResolver 与 EnvironmentCapable：提供选择性的某个特定环境的文件资源中加载配置的能力；
MessageSource：提供解析消息并支持国际化配置的能力；

结合它提供的功能和它的名称，我们可以大概了解，与 BeanFactory 专门用于操作 bean 不同，ApplicationContext 用于提供 spring 程序在某个特定环境运行时所具备的全部信息的“上下文”对象，它之于 BeanFactory ，就像带各种功能的超级保温杯之于普通的水杯。

它定义的方法如下：

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    // 获取上下文id
    String getId();
    // 获取对应应用程序名称
    String getApplicationName();
    // 获取上下文的展示名称
    String getDisplayName();
    // 获取容器被启动的时间
    long getStartupDate();
    // 获取父级上下文
    ApplicationContext getParent();
    // 获取自动装配bean工厂
    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}

这里可以看到，虽然 ApplicationContext 没继承 AutowireCapableBeanFactory 接口，但是他依然可以通过方法获取到对应的装配工厂。

2、web 应用上下文与可配置上下文

WebApplicationContext

WebApplicationContext 是 web 环境的上下文，该上下文几乎没有可配置项，主要用于配置 Servlet 上下文：

public interface WebApplicationContext extends ApplicationContext {
    String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT";
    
    // 作用域
    String SCOPE_REQUEST = "request";
    String SCOPE_SESSION = "session";
    String SCOPE_APPLICATION = "application";
    
    // 固定的bean名称
    String SERVLET_CONTEXT_BEAN_NAME = "servletContext";
    String CONTEXT_PARAMETERS_BEAN_NAME = "contextParameters";
    String CONTEXT_ATTRIBUTES_BEAN_NAME = "contextAttributes";
    
    // 获取ServletContext
    ServletContext getServletContext();

}

ConfigurableApplicationContext

ConfigurableApplicationContext 表示一个可以配置的上下文容器，与 WebApplicationContext 不同，它提供了一些参数和属性的配置方法：

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
    
    String CONFIG_LOCATION_DELIMITERS = ",; \t\n";
    String CONVERSION_SERVICE_BEAN_NAME = "conversionService";
    String LOAD_TIME_WEAVER_BEAN_NAME = "loadTimeWeaver";
    String ENVIRONMENT_BEAN_NAME = "environment";
    String SYSTEM_PROPERTIES_BEAN_NAME = "systemProperties";
    String SYSTEM_ENVIRONMENT_BEAN_NAME = "systemEnvironment";
    String SHUTDOWN_HOOK_THREAD_NAME = "SpringContextShutdownHook";
    
    // 配置上下文的id
    void setId(String id);
    // 配置上下文父容器
    void setParent(@Nullable ApplicationContext parent);
    
    // 配置上下文允许环境
    void setEnvironment(ConfigurableEnvironment environment);
    @Override
    ConfigurableEnvironment getEnvironment();
    
    // 获取bean后置处理器
    void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor);
    
    // 添加一个应用监听器，用于监听ApplicationEventPublisher发布的事件
    void addApplicationListener(ApplicationListener<?> listener);
    
    // 配置类加载器
    void setClassLoader(ClassLoader classLoader);
    
    // 配置资源协议处理器
    void addProtocolResolver(ProtocolResolver resolver);
    
    // 刷新配置
    void refresh() throws BeansException, IllegalStateException;
    
    // 关闭此上下文容器时的回调函数
    void registerShutdownHook();
    
    // 关闭上下文容器，并释放资源
    void close();
    
    // 当前容器是否已经调用过refresh()，并且尚未关闭
    boolean isActive();
    
    // 获取bean工厂
    ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;

}

它有一个通用可配置上下文的实现类：GenericApplicationContext，在非 web 环境中，该实现类的两个子类是最经常用到的：

GenericXmlApplicationContext：基于 xml 配置文件配置的上下文；
AnnotationConfigApplicationContext：基于注解配置的上下文；

3、可配置的web应用上下文

ConfigurableApplicationContext 接口同时继承了 WebApplicationContext 和 ConfigurableApplicationContext，代表了一个可以配置的 web 上下文容器：

public interface ConfigurableWebApplicationContext extends WebApplicationContext, ConfigurableApplicationContext {

	String APPLICATION_CONTEXT_ID_PREFIX = WebApplicationContext.class.getName() + 
	String SERVLET_CONFIG_BEAN_NAME = "servletConfig";

	// 配置Servlet容器
	void setServletContext(@Nullable ServletContext servletContext);
	void setServletConfig(@Nullable ServletConfig servletConfig);
	@Nullable
	ServletConfig getServletConfig();

    // 设置命名空间
	void setNamespace(@Nullable String namespace);
	@Nullable
	String getNamespace();
	
	// 设置配置文件的路径，比如WEB-INF
	void setConfigLocation(String configLocation);
	void setConfigLocations(String... configLocations);
	@Nullable
	String[] getConfigLocations();

}

一般 web 环境下实例化的上下文都为该接口的实例。

三、总结

在 spring 中，容器分为两大类：BeanFactory 和 ApplicationContext。

BeanFactory

其中，BeanFactory 是纯粹的用于管理 bean 对象生命周期的容器，它的接口体系分为四层：

BeanFactory 接口本身，是容器的最高层抽象；
HierarchicalBeanFactory ：分层工厂，表示一个存在层级关系的容器；

ListableBeanFactory：批量工厂，表示一个允许根据名称、类型或类注解等属性批量的操作 bean 的容器；

AutowireCapableBeanFactory：自动装配工厂，表示一个可以关联需要自动装配的 bean 的容器；
ConfigurableBeanFactory：分层配置工厂，是 HierarchicalBeanFactory 和 SingletonBeanRegistry 接口的组合，表示一个分层的、可以以单例模式操作 bean，并且允许调整配置的容器；
ConfigurableListableBeanFactory：可配置的批量工厂，是ConfigurableBeanFactory 与 AutowireCapableBeanFactory 接口的组合，具备 BeanFactory 体系中的全部能力。

ApplicationContext

ApplicationContext 是基于 BeanFactory 的扩展，它实现了其他的接口，因此具有一些 BeanFactory 不具备的功能：

ApplicationEventPublisher：提供向监听器发布事件的功能；
ResourcePatternResolver 与 EnvironmentCapable：提供选择性的某个特定环境的文件资源中加载配置的功能；
MessageSource：提供解析消息并支持国际化配置的功能；

从层次来说，ApplicationContext 主要分为三层：

ApplicationContext 接口本身，是基于 BeanFactory 接口的扩展，是整个应用上下文体系的最顶层接口；
WebApplicationContext：web 应用上下文，用于承载 ServletContext；

ConfigurableApplicationContext：用于非 web 环境下的可配置应用上下文；
ConfigurableApplicationContext：可配置的 web 应用上下文，同时继承了 WebApplicationContext 和 ConfigurableApplicationContext 接口，代表了一个可以配置的 web 上下文容器。

在一般的 web 环境中启动的都是该上下文的实例。