Spring之IOC原理详解

链接上一篇：spring框架组件分析

概念

IOC

Ioc英文为 Inversion of Control，即反转模式，这里有著名的好莱坞理论：你呆着别动，到时我会找你。后被Martin Fowler改名为 Dependency Injection 依赖注射，也就是将类之间的关系通过第三方进行注射，不需要类自己去解决调用关系。

实现原理

好，现在我们说说实现原理，其实很简单。

IOC

创建BeanFactory工厂

Ioc 容器实际上就是 Context 组件结合其他两个组件共同构建了一个 Bean 关系网，构建的入口就在 AbstractApplicationContext 类的 refresh 方法中。这个方法的代码如下：

public void refresh() throws BeansException, IllegalStateException {
        //创建synchronized所使用的对象监视器 var1
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            //为刷新准备新的context
            this.prepareRefresh();
            //刷新所有BeanFactory子容器
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            //创建BeanFactory
            this.prepareBeanFactory(beanFactory);
            try {
                //注册实现了BeanPostProcessor接口的bean
                this.postProcessBeanFactory(beanFactory);
                //初始化和执行BeanFactoryPostProcessor beans
                this.invokeBeanFactoryPostProcessors(beanFactory);
                //初始化和执行BeanPostProcessors beans
                this.registerBeanPostProcessors(beanFactory);
                //初始化MessageSource
                this.initMessageSource();
                //初始化 event multicaster
                this.initApplicationEventMulticaster();
                //刷新由子类实现的方法
                this.onRefresh();
                //检查注册事件
                this.registerListeners();
                //初始化non-lazy-init单利Bean
                this.finishBeanFactoryInitialization(beanFactory);
                //执行LifecycleProcessor.onRefresh()和ContextRefreshedEvent事件
                this.finishRefresh();
            } catch (BeansException var9) {
                if(this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }
                //销毁Beans
                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }

这个方法就是构建整个 Ioc 容器过程的完整的代码，了解了里面的每一行代码基本上就了解大部分 Spring 的原理和功能了。

这段代码主要包含这样几个步骤：

• 构建 BeanFactory，以便于产生所需的“演员”
• 注册可能感兴趣的事件
• 创建 Bean 实例对象
• 触发被监听的事件

下面就结合代码分析这几个过程。

ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);  

上面两句代码就是在创建和配置 BeanFactory。这里是 refresh 也就是刷新配置，前面介绍了 Context 有可更新的子类，这里正是实现这个功能，当 BeanFactory 已存在是就更新，如果没有就新创建。下面是更新 BeanFactory 的方法代码：
AbstractApplicationContext的抽象方法refreshBeanFactory在AbstractRefreshableApplicationContext中实现。
AbstractRefreshableApplicationContext. refreshBeanFactory

 protected final void refreshBeanFactory() throws BeansException {
        if(this.hasBeanFactory()) {
            this.destroyBeans();
            this.closeBeanFactory();
        }

        try {
            //BeanFactory 的原始对象是 DefaultListableBeanFactory
            DefaultListableBeanFactory ex = this.createBeanFactory();
            ex.setSerializationId(this.getId());
            this.customizeBeanFactory(ex);
            //这个方法将开始加载、解析 Bean 的定义，也就是把用户定义的数据结构转化为 Ioc 容器中的特定数据结构。
            this.loadBeanDefinitions(ex);
            Object var2 = this.beanFactoryMonitor;
            synchronized(this.beanFactoryMonitor) {
                this.beanFactory = ex;
            }
        } catch (IOException var5) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
        }
    }

这段代码清楚的说明了 BeanFactory 的创建过程。
注意 BeanFactory 对象的类型的变化，在什么情况下使用不同的子类这非常关键。这个非常关键，因为他设计到后面对这个对象的多种操作，下面看一下这个类的继承层次类图：

从这个图中发现除了 BeanFactory 相关的类外，还发现了与 Bean 的 register 相关。
这个过程可以用下面时序图解释：

Bean 的解析和登记流程时序图如下：

创建好 BeanFactory 后，接下去添加一些 Spring 本身需要的一些工具类，这个操作在 AbstractApplicationContext 的 prepareBeanFactory 方法完成。

AbstractApplicationContext 中接下来的三行代码对 Spring 的功能扩展性起了至关重要的作用。
前两行主要是让你现在可以对已经构建的 BeanFactory 的配置做修改，
后面一行就是让你可以对以后再创建 Bean 的实例对象时添加一些自定义的操作。
所以他们都是扩展了 Spring 的功能，所以我们要学习使用 Spring 必须对这一部分搞清楚。

其中在 invokeBeanFactoryPostProcessors 方法中主要是获取实现 BeanFactoryPostProcessor 接口的子类。并执行它的 postProcessBeanFactory 方法。

这个方法的声明如下：
BeanFactoryPostProcessor.postProcessBeanFactory

void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 
    throws BeansException;

它的参数是 beanFactory，说明可以对 beanFactory 做修改。

这里注意这个 beanFactory 是 ConfigurableListableBeanFactory 类型的，说明不同 BeanFactory 所使用的场合不同，这里只能是可配置的 BeanFactory，防止一些数据被用户随意修改。

registerBeanPostProcessors 方法也是可以获取用户定义的实现了 BeanPostProcessor 接口的子类，并执行把它们注册到 BeanFactory 对象中的 beanPostProcessors 变量中。

BeanPostProcessor 中声明了两个方法：

• postProcessBeforeInitialization、postProcessAfterInitialization 分别用于在 Bean 对象初始化时执行。可以执行用户自定义的操作。

后面的几行代码是初始化监听事件和对系统的其他监听者的注册，监听者必须是 ApplicationListener 的子类。

创建Bean实例并构建关系网

下面就是 Bean 的实例化代码，是从 finishBeanFactoryInitialization 方法开始的。

AbstractApplicationContext.finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(
    ConfigurableListableBeanFactory beanFactory) { 

    // 不使用TempClassLoader
    beanFactory.setTempClassLoader(null); 

    // 禁止修改当前Bean的配置信息
    beanFactory.freezeConfiguration(); 

    // 实例化non-lazy-init类型的bean
    beanFactory.preInstantiateSingletons(); 
}

从上面代码中可以发现 Bean 的实例化是在 BeanFactory 中发生的。

preInstantiateSingletons 方法的代码如下：

DefaultListableBeanFactory.preInstantiateSingletons

public void preInstantiateSingletons() throws BeansException { 
    if (this.logger.isInfoEnabled()) { 
        this.logger.info("Pre-instantiating singletons in " + this); 
    } 
    synchronized (this.beanDefinitionMap) { 
        for (String beanName : this.beanDefinitionNames) { 
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); 
            if (!bd.isAbstract() && bd.isSingleton() 
                && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) { 
                    //注意这里，出现了个FactoryBean 而非beanFactory
                    final FactoryBean factory = 
                        (FactoryBean) getBean(FACTORY_BEAN_PREFIX+ beanName); 
                    boolean isEagerInit; 
                    if (System.getSecurityManager() != null 
                        && factory instanceof SmartFactoryBean) { 
                        isEagerInit = AccessController.doPrivileged(
                            new PrivilegedAction() { 
                            public Boolean run() { 
                                return ((SmartFactoryBean) factory).isEagerInit(); 
                            } 
                        }, getAccessControlContext()); 
                    } 
                    else { 
                        isEagerInit = factory instanceof SmartFactoryBean 
                            && ((SmartFactoryBean) factory).isEagerInit(); 
                    } 
                    if (isEagerInit) { 
                        getBean(beanName); 
                    } 
                } 
                else { 
                    getBean(beanName); 
                } 
            } 
        } 
    } 
}

FactoryBean是个特殊的 Bean， 他是个工厂 Bean，可以产生 Bean 的 Bean，这里的产生 Bean 是指 Bean 的实例。

如果一个类继承 FactoryBean 用户可以自己定义产生实例对象的方法只要实现他的 getObject 方法。然而在 Spring 内部这个 Bean 的实例对象是 FactoryBean，通过调用这个对象的 getObject 方法就能获取用户自定义产生的对象，从而为 Spring 提供了很好的扩展性。Spring 获取 FactoryBean 本身的对象是在前面加上 & 来完成的。

如何创建 Bean 的实例对象以及如何构建 Bean 实例对象之间的关联关系式 Spring 中的一个核心关键，下面是这个过程的流程图：

如果是普通的 Bean 就直接创建他的实例，是通过调用 getBean 方法。下面是创建 Bean 实例的时序图：

还有一个非常重要的部分就是建立 Bean 对象实例之间的关系，这也是 Spring 框架的核心竞争力，何时、如何建立他们之间的关系请看下面的时序图：

扩展点

对 Spring 的 Ioc 容器来说，主要有BeanFactoryPostProcessor， BeanPostProcessor。它们分别是在构建 BeanFactory 和构建 Bean 对象时调用。还有就是 InitializingBean 和 DisposableBean 他们分别是在 Bean 实例创建和销毁时被调用。用户可以实现这些接口中定义的方法，Spring 就会在适当的时候调用他们。还有一个是 FactoryBean 他是个特殊的 Bean，这个 Bean 可以被用户更多的控制。
这些扩展点通常也是我们使用 Spring 来完成我们特定任务的地方，如何精通 Spring 就看你有没有掌握好 Spring 有哪些扩展点，并且如何使用他们，要知道如何使用他们就必须了解他们内在的机理。可以用下面一个比喻来解释。

生动描述Ioc

我们把 Ioc 容器比作一个箱子，这个箱子里有若干个球的模子，可以用这些模子来造很多种不同的球，还有一个造这些球模的机器，这个机器可以产生球模。那么他们的对应关系就是 BeanFactory 就是那个造球模的机器，球模就是 Bean，而球模造出来的球就是 Bean 的实例。那前面所说的几个扩展点又在什么地方呢？ BeanFactoryPostProcessor 对应到当造球模被造出来时，你将有机会可以对其做出设当的修正，也就是他可以帮你修改球模。而 InitializingBean 和 DisposableBean 是在球模造球的开始和结束阶段，你可以完成一些预备和扫尾工作。BeanPostProcessor 就可以让你对球模造出来的球做出适当的修正。最后还有一个 FactoryBean，它可是一个神奇的球模。这个球模不是预先就定型了，而是由你来给他确定它的形状，既然你可以确定这个球模型的形状，当然他造出来的球肯定就是你想要的球了，这样在这个箱子里尼可以发现所有你想要的球

我们使用 Spring 必须要首先构建 Ioc 容器，没有它 Spring 无法工作，ApplicatonContext.xml 就是 Ioc 容器的默认配置文件，Spring 的所有特性功能都是基于这个 Ioc 容器工作的，比如 AOP。

Ioc 它实际上就是为你构建了一个魔方，Spring 为你搭好了骨骼架构，这个魔方到底能变出什么好的东西出来，这必须要有你的参与。那我们怎么参与？这就是前面说的要了解 Spring 中那有些扩展点，我们通过实现那些扩展点来改变 Spring 的通用行为。AOP 的实现就是 Spring 本身实现了其扩展点来达到了它想要的特性功能。

---

学习自《深入分析 Java Web 技术内幕》，还望各位多多指导。