Spring中IOC容器常用的接口和具体的实现类

在Spring框架没有出现之前，在Java语言中，程序员们创建对象一般都是通过关键字new来完成，那时流行一句话“万物即可new，包括女朋友”。但是这种创建对象的方式维护成本很高，而且对于类之间的相互关联关系很不友好。鉴于这种情况，Spring框架应运而生，Spring框架绝对是一款伟大、设计优秀的框架，它的底层设计思想和应用策略使它一直火热到现在，并逐渐发展成为Spring生态。本篇内容就为大家来介绍下Spring框架中IOC容器相关的接口和API解析。

一、IOC思想介绍

IOC，其实是Inversion of Control单词的缩写，中文的意思是控制反转，也被称为依赖注入(DI)。这是一个过程，就是翻转资源获取的方向。把我们自己创建资源、向环境索取资源变成环境将资源准备好，我们享受资源注入。

IOC容器介绍

在Spring框架提供的功能模块中有一个功能叫做核心容器(Core Container)功能，这个核心容器的作用就是在Spring环境下使用任何功能都必须基于IOC容器。而这里的IOC容器主要包含管理组件对象的生命周期、实例化组件对象、管理组件对象之间的依赖关系等。该容器的设计替程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发效率。

该容器的主要实现依赖于工厂模式(BeanFactory)+反射。

IOC容器类型

上述IOC容器介绍中说到，IOC容器主要是依赖于工厂模式+反射，在Spring框架中，其实也确实为我们提供了一个顶层接口：BeanFactory工厂接口。该接口是顶层接口，其内部提供了能够管理任何类型对象的高级配置机制(API)。

API介绍如下：

public interface BeanFactory {

/**

* 用于取消引用FactoryBean实例，并将其与FactoryBean创建的bean区分开来。

*/

String FACTORY_BEAN_PREFIX = "&";

/**

* 返回指定bean的实例，该实例可以是共享的或独立的。此方法允许Spring BeanFactory用作Singleton或Prototype设计模式的替代。* 在Singleton bean的情况下，调用者可以保留对返回对象的引用。将别名转换回相应的规范bean名称。

* @param 命名要检索的bean的名称

* @return bean的一个实例

* @throws 如果没有具有指定名称的bean，抛出
NoSuchBeanDefinitionException

* @throws 如果无法获取bean，抛出BeansException

*/

Object getBean(String name) throws BeansException;

/**

* 返回指定bean的实例，该实例可以是共享的或独立的。

* 与getBean(String)的行为相同，但如果bean不是所需类型，则通过抛出
BeanNotOfRequiredTypeException来提供类型安全性的度量。

* 这意味着在转换结果正确时不能抛出ClassCastException,就像#getBean(String)一样。将别名转换回相应的规范bean名称。将询问父工厂是否在此工厂实例中找不到bean。

* @param 命名要检索的bean的名称

* @param bean要匹配的类型，可以是接口或是超类

* @return 一个bean实例

* @throws 如果没有具有指定名称的bean，抛出
NoSuchBeanDefinitionException

* @throws 如果bean不是要求的类型，抛出
BeanNotOfRequiredTypeException

* @throws 如果bean不能创建，抛出BeansException

*/

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

/**

* 返回指定bean的实例，该实例可以是共享的或独立的。

* 允许指定显式构造函数参数/工厂方法参数，覆盖bean定义中指定的默认参数（如果有）。

* @param 命名要检索的bean的名称

* @param args 使用显式参数创建bean实例时使用的参数（仅在创建新实例时应用，而不是在检索现有实例时应用）

* @return 一个bean实例

* @throws 如果没有具有指定名称的bean，抛出
NoSuchBeanDefinitionException

* @throws 如果已经给出了参数但受影响的bean不是Prototype,抛出
BeanDefinitionStoreException

* @throws 如果bean不能创建，抛出BeansException

*/

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

/**

* 返回唯一匹配给定对象类型的bean实例（如果有）。此方法进入ListableBeanFactory按类型查找区域，但也可以根据给定类型的名称转换为常规的按名称查找。

* @param bean要匹配的类型，可以是接口或是超类

* @return 匹配所需类型的单个bean的实例

* @throws 如果没有找到给定类型的bean，抛出
NoSuchBeanDefinitionException

* @throws 如果找到多个给定类型的bean，抛出
NoUniqueBeanDefinitionException

* @throws 如果无法创建bean，抛出BeansException

*/

<T> T getBean(Class<T> requiredType) throws BeansException;

/**

* 返回指定bean的实例，该实例可以是共享的或独立的。

* 允许指定显式构造函数参数/工厂方法参数，覆盖bean定义中指定的默认参数（如果有）。此方法进入ListableBeanFactory按类型查找区域，但也可以转换为传统的按名称查找 基于给定类型的名称。

* @param requiredType bean要匹配的类型，可以是接口或是超类

* @param args 使用显式参数创建bean实例时使用的参数（仅在创建新实例时应用，而不是在检索现有实例时应用）

* @return 一个bean实例

* @throws 如果没有找到给定类型的bean，抛出
NoSuchBeanDefinitionException

* @throws 如果已经给出了参数但受影响的bean不是Prototype,抛出
BeanDefinitionStoreException

* @throws 如果无法创建bean，抛出BeansException

* @since 4.1

*/

<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

/**

* 返回指定bean的提供程序，允许对实例进行惰性按需检索，包括可用性和唯一性选项。

* @param requiredType bean要匹配的类型，可以是接口或是超类

* @return 相应的提供者句柄

*/

<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

/**

* 返回指定bean的提供程序，允许对实例进行惰性按需检索，包括可用性和唯一性选项。

* @param requiredType bean要匹配的类型。可以是泛型类型声明。请注意，此处不支持集合类型，与反射注入点相反。* 要以编程方式检索与特定类型匹配的bean列表，请在此处将实际bean类型指定为参数，然后使用
ObjectProvider.orderedStream()或其延迟流/迭代选项。

* @return 相应的提供者句柄

*/

<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

/**

* 此bean工厂是否包含bean定义或具有给定名称的外部注册的bean的singleton实例

* 如果给定的名称是别名，它将被转换回相应的规范bean名称。

* 如果此工厂是分层的，将询问任何父工厂是否在这个工厂实例中找不到bean。如果找到匹配给定名称的bean定义或单例实例，则此方法将返回true。

* 无论命名bean定义是具体的还是抽象的，lazy还是eager的，作用域与否。因此，请注意此方法的true返回值不一定表示getBean将能够获取同名的实例。

* @param name 查询的bean的名称

* @return 给定名称的bean是否存在

*/

boolean containsBean(String name);

/**

* 该Bean是否是共享的单例? 也就是说， getBean()方法总是返回相同的实例

* 注意：返回false的此方法不能清楚地表明是独立的实例。它表示非单例实例，也可以对应于作用域的bean。

* 使用isPrototype操作显式检查是否是独立的实例。将别名转换回相应的规范bean名称。将询问父工厂是否在此工厂实例中找不到bean。

* @param name 查询的bean的名称

* @return 该bean是否有单例实例

* @throws 如果没有给定名称的Bean，抛出
NoSuchBeanDefinitionException

*/

boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

/**

* 该bean是否是Prototype? 也就是说，getBean总会返回独立实例吗

* 注意：返回false的此方法不能清楚地指示单个对象。它表示非独立实例，也可以对应于范围内的bean。

* 使用isSingleton操作显式检查共享单例实例。将别名转换回相应的规范bean名称。将询问父工厂是否在此工厂实例中找不到bean。

* @param name 查询的bean的名称

* @return 这个bean是否总是提供独立的实例

* @throws 如果没有给定名称的Bean，抛出
NoSuchBeanDefinitionException

*/

boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

/**

* 检查具有给定名称的bean是否与指定的类型匹配。更具体地说，检查对给定名称的getBean调用是否将返回可分配给指定目标类型的对象。

* 将别名转换回相应的规范bean的名称.将询问父工厂是否在此工厂实例中找不到bean。

* @param name 查询bean的名称

* @param typeToMatch 要匹配的类型

* @return 如果Bean类型匹配，返回true;如果bean类型不匹配或不确定，返回false。

* @throws 如果没有给定名称的Bean，抛出
NoSuchBeanDefinitionException

*/

boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

/**

* 检查具有给定名称的bean是否与指定的类型匹配。更具体地说，检查对给定名称的getBean调用是否将返回可分配给指定目标类型的对象。

* 将别名转换回相应的规范bean的名称.将询问父工厂是否在此工厂实例中找不到bean。

* @param name 查询bean的名称

* @param typeToMatch 要匹配的类型

* @return 如果Bean类型匹配，返回true;如果bean类型不匹配或不确定，返回false。

* @throws 如果没有给定名称的Bean，抛出
NoSuchBeanDefinitionException

*/

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

/**

* 确定给定名称的bean的类型。进一步来说，确定getBean方法为给定bean名称返回的对象类型。对于FactoryBean，返回FactoryBean创建的对象类型，由FactoryBean.getObjectType()公开。

* 将别名转换回相应的规范bean名称。将询问父工厂是否在此工厂实例中找不到bean。

* @param name 查询的bean的名称

* @return bean的类型, 或者不可确定返回null。

* @throws 如果没有给定名称的Bean，抛出
NoSuchBeanDefinitionException

*/

@Nullable

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

/**

* 返回给定bean名称的别名（如果有）。所有这些别名在getBean调用中使用时指向同一个bean。

* 如果给定名称是别名，则对应原始bean名称和其他别名（ 如果有的话）将返回，原始bean名称是数组中的第一个元素。将询问父工厂是否在此工厂实例中找不到bean。

* @param name 用于检查别名的bean名称

* @return 别名，如果没有，则为空数组

*/

String[] getAliases(String name);

}

BeanFactory顶层接口内部设计了上述API方法，所以它需要具体的实现类来实现这些方法，说到具体的实现类，那么我们就需要查看下该接口的子接口和相关实现类。我们借助开发工具IDEA来查看BeanFactory顶层接口的子接口和具体实现。

图解：

我们可以看到，BeanFactory有三大派生的直属接口，分别是：ListableBeanFactory，HierarchicalBeanFactory，AutowireCapableBeanFactory。其中

（1）ListableBeanFactory子接口：提供容器中bean迭代的功能。如返回所有Bean的名字、容器中Bean的数量等。

（2）HierarchicalBeanFactory子接口：提供父容器的访问功能，可通过 ConfigurableBeanFactory的setParentBeanFactory方法设置父容器，主要是为了实现Bean工厂的分层。

其中子容器可通过接口方法访问父容器；通过 HierarchicalBeanFactory 接口， Spring 的 IOC 容器可以建立父子层级关联的容器体系，子容器可以访问父容器中的Bean，但父容器不能访问子容器的Bean。

Spring 使用父子容器实现了很多功能，比如在 Spring MVC 中，展现层Bean位于一个子容器中，而业务层和持久层的Bean位于父容器中。这样，展现层Bean就可引用业务层和持久层的Bean，而业务层和持久层的 Bean 则看不到展现层的Bean。

（3）AutowireCapableBeanFactory子接口：为 Spring 容器之外的Bean ，也就是处理未交由Spring管理的Bean ，提供依赖注入的功能。

二、接口具体分析

HierarchicalBeanFactory接口分析

// 继承BeanFactory接口，父子级联IOC容器的接口

public interface HierarchicalBeanFactory extends BeanFactory {

// 返回父Bean工厂，如果没有，则返回null

@Nullable BeanFactory getParentBeanFactory();

/** 返回本地bean工厂, * 判断是否包含给定名称的bean，忽略父Bean工厂中定义的bean。这是containsBean的替代方案，忽略来自父bean工厂的给定名称的bean。 */

boolean containsLocalBean(String name);}

ListableBeanFactory接口分析

//扩展了BeanFactory接口,提供了对bean的枚举能力,

//即可以返回bean的实例集合,而不用像BeanFactory只能返回单个bean的实例

//注意:如果存在父容器的话该接口不会考虑父容器中的bean,只会返回当前容器中的

beanpublic interface ListableBeanFactory extends BeanFactory {

// 根据Bean的名称，判断容器中是否包含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);

// 根据类型 获取容器中的Bean对象

<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;

@Nullable <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType) throws NoSuchBeanDefinitionException;}

AutowireCapableBeanFactory接口分析

//扩展了BeanFactory，主要提供了自动装配能力，包含了bean的创建、注入配置、属性配置、依赖解析、后置处理器前后的实例化、bean的实例化、bean的销毁登

public interface AutowireCapableBeanFactory extends BeanFactory {

//无自动装配

int AUTOWIRE_NO = 0;

//by-name装配

int AUTOWIRE_BY_NAME = 1;

//by-type装配

int AUTOWIRE_BY_TYPE = 2;

//constructor构造函数装配

int AUTOWIRE_CONSTRUCTOR = 3;

//自动装配,已被标记为过时

@Deprecated

int AUTOWIRE_AUTODETECT = 4;

// 用给定的class创建一个Bean实例，完整经历一个Bean创建过程的生命周期节点回调，但不执行传统的autowiring

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

// 用于(再次)填充指定Bean被注解的元素或方法(如@Resource @Autowired)，不执行传统的autowiring

void autowireBean(Object existingBean) throws BeansException;

// 配置Bean

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;

// 将传入的第一个参数按照spring中按name或者按type装备的方法将传入的Bean的各个properties给装配上

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

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

// 初始化容器中的Bean

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

// 对Bean初始化前后应用逻辑处理器

// 执行BeanPostProcessor前置处理逻辑

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

// 执行BeanPostProcessor后置处理逻辑

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

// 销毁容器中的Bean

void destroyBean(Object existingBean);

// 根据传入的类型，从Spring容器(包括父子容器)中查找出指定类型下唯一的Bean，并将beanName与beanInstance包装成NamedBeanHolder对象返回

<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

// 解析Bean需要的依赖

@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;

}

SimpleJndiBeanFactory实现类分析

该实现类是基于JndiLocatorSupport的BeanFactory实现，并使用HashMap进行缓存处理。

这里需要注意的是SimpleJndiBeanFactory不支持枚举的Bean定义，因此没有实现ListableBeanFactory，而是直接实现的BeanFactory。

ApplicationContext接口分析

通过上述BeanFactory接口层级图，我们可以看到，在HierarchicalBeanFactory接口下，有一子接口叫做ApplicationContext。

这里我们也说一下为什么单独将该接口进行说明。

ApplicationContext隶属于org.springframework.context，它在继承BeanFactory接口的同时，同时还继承了如下接口：

EnvironmentCapable, ListableBeanFactory,HierarchicalBeanFactory,MessageSource, ApplicationEventPublisher, ResourcePatternResolver

使ApplicationContext接口包含了IOC完整实现的同时，还在其基础上扩展了许多功能。比如资源访问、事件机制、国际化(il8n)等。而我们一般都称ApplicationContext接口的具体实现类对象为ApplicationContext上下文，它为我们程序员良好运用Spring框架提供了很好的支持。

ApplicationContext接口源码解析：

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

// 返回此应用程序上下文的唯一id。返回:上下文的唯一id，如果没有则返回null @Nullable String getId(); // 返回此上下文所属的已部署应用程序的名称。返回:已部署应用程序的名称，默认情况下为空

String String getApplicationName();

// 返回此上下文的友好名称。返回:该上下文的显示名称(从不为空)

String getDisplayName();

// 返回第一次加载此上下文时的时间戳。返回:该上下文第一次加载时的时间戳(毫秒)

getStartupDate();

// 返回父上下文，如果没有父上下文并且这是上下文层次结构的根，则返回null。返回:父上下文，如果没有父上下文则返回null

@Nullable

ApplicationContext getParent();

/**

* 为此上下文公开
AutowireCapableBeanFactory功能。

* 除了初始化位于应用程序上下文之外的bean实例，将Spring bean生命周期(全部或部分)应用于它们之外，应用程序代码通常不使用它。

*/

AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

}

接下来我们分析一下ApplicationContext继承的接口，分析一下这些接口的作用及各自接口内API方法的意义。

EnvironmentCapable接口分析

// EnvironmentCapable提供了getEnvironment方法，获取当前Spring的配置信息（环境变量、application.properties等）

public interface EnvironmentCapable {

// 读取配置资源

Environment getEnvironment();

}

ApplicationEventPublisher接口分析

// 封装事件发布功能的接口

@FunctionalInterfacepublic interface ApplicationEventPublisher {

// 将应用程序事件通知与此应用程序注册的所有匹配侦听器。事件可以是框架事件(例如ContextRefreshedEvent)或特定于应用程序的事件

default void publishEvent(ApplicationEvent event) {

publishEvent((Object) event);

}

// 通知所有与此应用程序注册的事件匹配的侦听器。如果指定的事件不是一个ApplicationEvent，它将被包装在一个PayloadApplicationEvent中

// 这样的事件发布步骤实际上是一个多播程序的交接，并不意味着同步或异步执行，甚至根本不意味着立即执行。我们鼓励事件侦听器尽可能高效，单独使用异步执行来进行长时间运行和可能阻塞的操作。

void publishEvent(Object event);

}

MessageSource接口分析

// 用于解析消息的策略接口，支持此类消息的参数化和国际化

public interface MessageSource {

// 尝试解析该消息。如果没有找到消息，则返回默认消息

@Nullable

String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale);

// 尝试解析该消息。如果无法找到该消息，则将其视为错误

String getMessage(String code, @Nullable Object[] args, Locale locale) throws NoSuchMessageException;

// 尝试使用传入的MessageSourceResolvable参数中包含的所有属性来解析消息。

// 注意:我们必须在此方法上抛出NoSuchMessageException，因为在调用此方法时，我们无法确定可解析对象的defaultMessage属性是否为null。

String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException;}

ResourcePatternResolver接口分析

/**

* 根据路径或者通配符获取多个资源，用于将位置模式解析为Resource对象的策略接口。

* 可以用于任何类型的位置模式，该接口还建议为类路径中的所有匹配资源添加一个新的资源前缀“classpath:”。

*/

public interface ResourcePatternResolver extends ResourceLoader {

String CLASSPATH_ALL_URL_PREFIX = "classpath*:";

// 用于读取(指定位置下的)配置文件

Resource[] getResources(String locationPattern) throws IOException;

}

总结

上述内容，为大家介绍了BeanFactory顶层接口下其相关子接口具体的作用以及接口提供的抽象api的作用。帮助大家在源码层面理解Spring框架底层结构设计。我们在知晓底层设计结构之后，重点关注应是在ApplicationContext接口及其实现上。