在前面博客中介绍什么是依赖注入时有提到：依赖注入是组件之间依赖关系由容器在运行期决定，即由容器动态的将某个依赖关系注入到组件之中。那什么是容器?既然Spring框架实现了IOC，那Spring中的容器是什么呢?
一、容器介绍
在日常生活中容器是指用以容纳物料并以壳体为主的基本装置，它是用来盛放东西的。在编程中容器是用来存储和组织其他对象的对象，首先要确定容器也是对象，也可以当做bean，只是这个对象是用来存储和组织其他对象，那其他对象是什么呢?其他对象其实就是bean对象，这也是面向对象编程的一种体现，万物皆对象。在Spring提供了BeanFactory、ApplicationContext两个IOC容器，来管理众多的bean对象。
二、BeanFactory
一提到工厂我们生活当中可能会想到富某康，工厂是一类用以生产货物的大型工业建筑物。而BeanFactory不是用来生产货物的而是用来生产管理bean的。BeanFactory会在bean的生命周期的各个阶段中对bean进行各种管理，并且Spring将这些阶段通过各种接口暴露给我们，让我们可以对bean进行各种处理，我们只要让bean实现对应的接口，那么Spring就会在bean的生命周期调用我们实现的接口来处理该bean。那它是怎么实现的呢?它主要分两个阶段。
1）、Bean容器的启动
工厂要生产货物那首先得把工厂运转起来之后才能生产货物。同样bean容器要管理bean也需要先把容器启动起来，获取到bean的定义信息之后才能管理。
1. 读取bean的xml配置文件，然后将xml中每个bean元素分别转换成BeanDefinition对象。
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements BeanDefinition, Cloneable { private volatile Object beanClass; private String scope = SCOPE_DEFAULT; private boolean abstractFlag = false; private boolean lazyInit = false; private int autowireMode = AUTOWIRE_NO; private int dependencyCheck = DEPENDENCY_CHECK_NONE; private String[] dependsOn; private ConstructorArgumentValues constructorArgumentValues; private MutablePropertyValues propertyValues; private String factoryBeanName; private String factoryMethodName; private String initMethodName; private String destroyMethodName;
BeanClass保存bean的class属性，scop保存Bean的作用域，abstractFlag保存该bean是否抽象，lazyInit保存是否延迟初始化，autowireMode保存是否自动装配，dependencyCheck保存是否坚持依赖，dependsOn保存该bean依赖于哪些bean(这些bean必须提取初始化)，constructorArgumentValues保存通过构造函数注入的依赖，propertyValues保存通过setter方法注入的依赖，factoryBeanName和factoryMethodName用于factorybean，也就是工厂类型的bean，initMethodName和destroyMethodName分别对应bean的init-method和destory-method属性。后面会对这些内容进行详细介绍。
2. 通过BeanDefinitionRegistry将bean注册到beanFactory中
上面获取到bean的信息之后，是怎么注册到BeanFactory中的呢？其实是通过BeanDefinitionRegistry将bean注册到beanFactory中。因为BeanFactory的实现类，需要实现BeanDefinitionRegistry 接口。
public interface BeanDefinitionRegistry extends AliasRegistry { void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException; void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; boolean containsBeanDefinition(String beanName); String[] getBeanDefinitionNames(); int getBeanDefinitionCount(); boolean isBeanNameInUse(String beanName); }
BeanDefinitionRegistry接口提供了根据beanName注册对应beanDefinition的方法,而在DefaultListableBeanFactory中实现了该方法，并将beanDefinition保存在了ConcurrentHashMap中。
@SuppressWarnings("serial")
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
/** Map of bean definition objects, keyed by bean name */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
// ... ...
this.beanDefinitionMap.put(beanName, beanDefinition);
}
另外Spring还对外暴露了一些接口用来对bean初始化，例如BeanFactoryPostProcessor。
public interface BeanFactoryPostProcessor { /** * Modify the application context's internal bean factory after its standard * initialization. All bean definitions will have been loaded, but no beans * will have been instantiated yet. This allows for overriding or adding * properties even to eager-initializing beans. * @param beanFactory the bean factory used by the application context * @throws org.springframework.beans.BeansException in case of errors */ void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException; }
我们可以翻译一下postProcessBeanFactory的注释信息，postProcessBeanFactory可以修改应用上下文中已经进行standard初始化的beanFactory，此时所有bean的定义信息已经加载完成，但还未实例化，允许覆盖、新增甚至重新初始化bean信息，一个典型的例子就是属性覆盖器PropertyOverrideConfigurer。对于一些参数可以配置在properties中，而不用配置在Spring的XML配置文件中。
2)、容器Bean的实例化
上面把bean容器启动之后，工厂算是运转起来了，配方(beanDefinition)也已经准备充分，然后就是生产(实例化)、管理货物(bean)了。实例化bean主要通过反射和CGLIB两种方式，在bean的实例化过程中，Spring也暴露了一些接口。
BeanNameAware 获取该bean在配置文件中对应的id
BeanFactoryAware 获取实例化该bean的BeanFactory
InitializingBean bean实例化、所有属性设置后调用初始化方法
DisposableBean 在bean丢弃的时候调用销毁方法
我们可以通过示例演示一下这几个接口的使用。
1. 首先创建了Maven project,pom.xml引入spring-core、spring-context。
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.demo</groupId> <artifactId>BeanFactoryDemo</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>BeanFactoryDemo</name> <url>http://maven.apache.org</url> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring.version>5.0.0.RELEASE</spring.version> </properties> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> </dependencies> </project>
2. 创建bean对象，实现上面列出的接口
package com.demo.model; import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.beans.factory.BeanNameAware; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; public class UserBean implements BeanNameAware,BeanFactoryAware,InitializingBean,DisposableBean { public void setBeanName(String name) { System.out.println(name); } public void setBeanFactory(BeanFactory beanFactory) throws BeansException { System.out.println(beanFactory); } public void afterPropertiesSet() throws Exception { System.out.println("InitializingBean"); } public void destroy() throws Exception { System.out.println("DisposableBean"); } }
3. bean配置
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="user" class="com.demo.model.UserBean"></bean> </beans>
4. 测试
使用ApplicationContext获取BeanFactory，再通过getBean方法获取到对应的bean，最后调用destroy方法进行销毁，从输出结果可以看到依次调用了BeanNameAware,BeanFactoryAware,InitializingBean,DisposableBean接口。
public static void main( String[] args ) throws Exception { ApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"}); BeanFactory factory=context; UserBean user=(UserBean)factory.getBean("user"); user.destroy(); }
输出结果:user
org.springframework.beans.factory.support.DefaultListableBeanFactory@6bf256fa: defining beans [user]; root of factory hierarchy
InitializingBean
DisposableBean
三、ApplicationContext
在上面的示例中使用了ApplicationContext获取bean的配置，然后直接将ApplicationContext接口 对象赋值给了BeanFactory接口对象,为什么可以赋值呢?其实ApplicationContext接口实现了BeanFactory接口。
public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver
从上面ApplicationContext接口的继承关系可以看到，它还通过继承其他接口扩展了BeanFactory的功能。MessageSource：为应用提供国际化访问功能。ResourceLoader：提供资源（如URL和文件系统）的访问支持。ApplicationEventPublisher：引入事件机制，包括启动事件、关闭事件等，让容器在上下文中提供了对应用事件的支持。它代表的是一个应用的上下文环境。beanFactory主要是面对与 spring 框架的基础设施，面对 spring 自己。而 Applicationcontex 主要面对与 spring 使用的开发者。基本都会使用 Applicationcontex 并非 beanFactory 。所以在上面实例使用的ApplicationContext获取BeanFactory接口对象。
上面获取ApplicationContext对象是通过ClassPathXmlApplicationContext方法获取的，还有一种获取方式，使用FileSystemXmlApplicationContext方法获取。ClassPathXmlApplicationContext ： 从类路径下加载配置文件。文件路径：默认指的是项目的classpath路径下面，所以不需要写前缀classpath:。如果指向绝对路径，需要加上file:。New ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"});FileSystemXmlApplicationContext：从文件系统中加载配置文件。文件路径：默认指的是项目的根目录下，想使用项目的classpath路径下面，需要加上classpath:。new FileSystemXmlApplicationContext(new String[]{"classpath:ApplicationContext.xml"});