Spring之IOC容器

在前面博客中介绍什么是依赖注入时有提到：依赖注入是组件之间依赖关系由容器在运行期决定，即由容器动态的将某个依赖关系注入到组件之中。那什么是容器?既然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"});