长话短说Spring(1)之IoC控制反转

简书 Wwwwei
转载请注明原创出处,谢谢!

前言


  Spring的大名对于程序员来说如雷贯耳,IoC控制反转作为Spring的核心,重要程度可想而知,但是对于很多初学者而言看懂IoC确实不容易,本文主要说清楚IoC到底是个什么东西,至于更深层的原理则需要读者后续自己深究了。

IoC


什么是IoC?

  我们先来看一下比较官方的解释。
  IoC,Inversion of Control的缩写,中文名称为控制反转,意思是将对象的控制权转移至第三方,例如IoC容器,即可由IoC容器来管理对象的生命周期、依赖关系等。
  相信你一定没看懂。

举个例子

  在传统的人员招聘模式中,流程一般都是这样:HR从多如海的应聘简历中挑选然后进行笔试、面试等等一系列筛选后发放offer。这一系列过程复杂而且费时,最关键的是结果还不理想,特别是针对某些特定的岗位很难通过这一模式物色到合适的人才资源
  后来逐渐出现了一些公司专门提供类似的人才寻访服务,这就是大名鼎鼎的猎头行业。猎头的兴起可以说很大程度上改变了人才招聘的模式,现在公司需要招聘某个职位的人才,只需要告诉猎头我要一个怎样的人干怎样的工作等等要求,猎头就会通过自己的渠道去物色人才,经过筛选后提供给客户,大大简化了招聘过程的繁琐,提高了招聘的质量和效率。
  这其中一个很重要的变化就是公司HR将繁琐的招聘寻访人才的过程转移至了第三方,也就是猎头。相对比而言,IoC在这里充当了猎头的角色,开发者即公司HR,而对象的控制权就相当于人才寻访过程中的一系列工作

IoC设计模式和IoC容器

  回到我们所说的IoC,首先我们需要肯定的是IoC并不是特指某种技术,而是指一种思想或者说一种设计模式。我们可以简单的理解为我们在进行程序业务逻辑的编程时通常需要大量的对象来协作完成,而这些对象都需要我们通过类似如下语句

Object object=new Object();//对象申请

object.setName("XXX");//对象属性初始化赋值

的方式申请和初始化,而这些就是所谓的对象的控制权IoC设计模式的目的就是把这些对象的控制权转移至第三方,由第三方来进行和管理类似对象申请、初始化、销毁对象的控制权工作
  对于开发者来说,对象的控制权的转移意味着我们编程将更加简便,不用再去关心如何申请、初始化对象,甚至是管理对象、销毁等复杂的过程,这些都将由第三方完成,只需要告诉第三方我需要怎样的对象使用即可。
  这里还需要解释一个概念,所谓的IoC容器,就是实现了IoC设计模式的框架

Spring IoC


  Spring IoC实现了IoC设计模式,所以是IoC容器。所以,Spring IoC主要任务就是创建并且管理JavaBean的生命周期,即之前提到的对象的控制权
  那么对于Spring而言,JavaBean的生命周期包括哪些方面呢?这是我们下一个需要了解的问题。

Spring IoC的JavaBean的生命周期

(1)实例化JavaBean:Spring IoC容器实例化JavaBean
(2)初始化JavaBean:Spring IoC容器对JavaBean通过注入依赖进行初始化
(3)使用JavaBean:基于Spring应用对JavaBean实例的使用
(4)销毁JavaBean:Spring IoC容器销毁JavaBean实例

举个例子

  我们来看一个Spring IoC的例子:
  编写一个动物接口,代码如下:

package com.demo;

public interface Animal {
    void printWhoAmI();
}

  编写一个老虎类实现动物接口,代码如下:

package com.demo;

public class Tiger implements Animal {
    private String name;
    private int age;

    //省略属性的set和get方法

    @Override
    public void printWhoAmI() {
        // TODO Auto-generated method stub
        System.out.println("I am " + name);
        System.out.println("I am " + age + " years old");
    }

}

  编写Spring配置文件applicationContext.xml,代码如下:

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans   
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="tiger" class="com.demo.Tiger">
        <property name="name">
            <value>Tom</value>
        </property>
        <property name="age">
            <value>3</value>
        </property>
    </bean>
</beans>

  编写主测试类,代码如下:

package com.demo;

public class Test {

    public static void main(String[] args) {
        Resource resource = new ClassPathResource("applicationContext.xml");
        BeanFactory beanFactory = new XmlBeanFactory(resource);
        Animal tiger = (Tiger) beanFactory.getBean("tiger"); // 获取Tiger类对象tiger
        tiger.printWhoAmI();
    }

}

  我们可以发现Spring通过配置文件完成了Tiger类对象tiger申请和初始化,我们在使用Tiger类对象tiger时不再通过

// 创建Tiger类对象tiger
Animal tiger = new Tiger(); 
// Tiger类对象tiger初始化
tiger.setName("Tom"); 
tiger.setAge(3);

这种方式,而是将所有的JavaBean的生命周期操作和管理托管至Spring IoC容器,对于开发者而言,我们只需要关心业务逻辑需要怎样的JavaBean对象,告诉容器,使用即可,这里再次体现了所谓的控制反转的思想。

依赖注入

  我们可能会遇见这样的情况,Spring IoC容器管理的对象中可能会依赖其他对象,这是很常见的。这就意味着Spring IoC的一个重点是在系统运行中,动态的向某个对象提供它所需要的其他对象。这也是我们接下来要了解的依赖注入
  接着上述例子我们来看一下依赖注入的情况:
  编写一个笼子接口,代码如下:

package com.demo;

public interface Cage {
    void printInfo();
}

  编写一个铁笼子类实现笼子接口,并且具有一个动物类型的属性,代码如下:

package com.demo;

public class IronCage implements Cage {
    private String id;
    private Animal animal;

    //省略属性的set和get方法

    @Override
    public void printInfo() {
        // TODO Auto-generated method stub
        System.out.println("I am a IronCage");
        System.out.println("My id is " + id);
        System.out.println("There is the animal information");
        animal.printWhoAmI();
    }

}

  将Spring配置文件applicationContext.xml改写如下:

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans   
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="tiger" class="com.demo.Tiger">
        <property name="name">
            <value>Tom</value>
        </property>
        <property name="age">
            <value>3</value>
        </property>
    </bean>
    <bean id="ironCage" class="com.demo.IronCage">
        <property name="id">
            <value>001</value>
        </property>
        <property name="animal">
            <ref bean="tiger" />
        </property>
    </bean>
</beans>

  IronCage类对象ironCage中依赖Animal类型的animal属性,Spring IoC容器将Tiger类tiger对象注入作为animal的值,这就是依赖注入
  这里提一下,Spring支持多种属性赋值的情况,例如list、map:

<bean id="school" class="School">
    <!--1.value 普通赋值-->
    <property name="name">
        <value>XX学校</value>
    </property>
    <!--2.ref 引用其他JavaBean实例对象赋值-->
    <property name="student">
        <ref bean="student1" />
    </property>
    <!--3.list 集合类或者数组赋值-->
    <property name="studentList">
        <list>
            <ref bean="student1" />
            <value>student2</value>
        </list>
    </property>
    <!--4.map Map集合赋值-->
    <property name="studentMap">
        <map>
            <entry key="student1">
                <ref bean="student1" />
            </entry>
            <entry key="key2">
                <value>student2</value>
            </entry>
        </map>
    </property>
</bean>

Spring 如何实现IoC?

  了解了Spring IoC的强大功能之后,我们可能都会好奇Spring究竟是如何做到这样?
  Java一个很重要的特性就是支持反射(reflection)机制,它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性,Spring就是通过反射来实现注入的
  下面我们讲讲Spring实现这一过程的具体方式。这里我们需要介绍几个重要的概念:
  (1) Bean的xml配置文件:我们以XML格式描述bean的相关信息,主要包括bean的名称、类型、属性等等。
  (2) BeanDefinition :字面翻译可以理解为bean的定义,对于Spring来说我们之前使用的描述bean的XML配置文件并不能直接使用,所以需要一个Spring能够理解的数据结构进行存储和管理这些bean的描述信息,这就是BeanDefinition。
  (3) BeanFactory:BeanFactory是用于访问Spring Bean容器的根接口,是一个单纯的Bean工厂,也就是常说的IOC容器的顶层定义,处于Spring的核心。所以可以理解为Spring统一使用BeanFactory访问Spring IoC容器,各种IOC容器是在其基础上为了满足不同需求而扩展的,包括经常使用的ApplicationContext
  通俗的说,如果我们将bean看做是一个产品,那么Bean的xml配置文件可以看成是普通客户对于想要产品的概念图,而BeanDefinition则是专业人士根据客户的概念图设计产品的设计图,对于BeanFactory,我们可以看成是一个能够根据产品设计图生产产品的工厂
  这样来看,三者的关系是否更容易理解了呢?接着我们继续讲Spring实现这一过程的具体方式。Spring IoC的实现过程主要分为两部分,即IoC容器初始化和依赖注入。接着上面的比喻,IoC容器初始化就是我们将客户的产品概念图转换成产品设计图,同时告知工厂的过程依赖注入工厂生产产品,我们通过工厂拿到我们所需的产品投入使用的过程。我们来看下详细过程:

IoC容器初始化

IoC容器初始化过程

  IoC容器初始化过程主要经过以下几个阶段:
  1.解析阶段:Spring会解析Bean的XML配置文件,将XML元素进行抽象,抽象成Resource对象。
  2.转换阶段:通过Resource对象将配置文件进行抽象后转换成Spring能够理解的BeanDefinition结构。
  3.注册阶段:Spring IoC容器的实现,从根源上是beanfactory,但真正可以作为一个可以独立使用的ioc容器还是DefaultListableBeanFactory。
  DefaultListableBeanFactory间接实现了BeanFactory接口,是整个bean加载的核心部分,是Spring注册及加载bean的默认实现,我们可以理解为Spring bean工厂的发动机。DefaultListableBeanFactory源码中有2个重要的属性,如下所示:

/** Map of bean definition objects, keyed by bean name */  
private final Map beanDefinitionMap = new ConcurrentHashMap(256);  
  
/** List of bean definition names, in registration order */  
private volatile List beanDefinitionNames = new ArrayList(256); 

  在bean的定义被解析转换成BeanDefinition的过程中,同时解析得到beanName,将beanName和BeanDefinition存储到beanDefinitionMap中,同时会将beanName存储到beanDefinitionNames中。
  也就是说,注册的实质就是以beanName为key,以beanDefinition为value,将其put到BeanFactory的HashMap属性中。

依赖注入

依赖注入过程

  依赖注入过程主要经过以下几个阶段:
  1.bean初始化阶段:完成IoC容器初始化后,即上述第一过程后,Spring会加载没有设置lazy-init(延迟加载)属性的bean,进行bean的初始化。
  2.bean实例化阶段:初始化bean,首先需要创建bean实例。
  3.bean属性依赖注入阶段依据BeanDefinition的信息来递归完成依赖注入。首先通过递归,在上下文查找需要的bean和构造bean的递归调用;其次在依赖注入时,通过递归调用容器的getBean()方法,得到当前bean的依赖bean,同时也触发对依赖bean的创建和注入。
  补充一下,DefaultListableBeanFactory间接继承DefaultSingletonBeanRegistry,DefaultSingletonBeanRegistry中有如下属性,

/** Cache of singleton objects: bean name --> bean instance */  
private final Map singletonObjects = new ConcurrentHashMap(256);  

  singletonObjects用于存储单例bean的实例,getBean()方法就是从这个Map里取实例对象。

最后对Spring IoC实现做个总结

  概括的描述一下,首先解析applicationgContext.xml,将XML中定义的bean解析成Spring内部的BeanDefinition,并以beanName为key,BeanDefinition为value存储到DefaultListableBeanFactory中的beanDefinitionMap(其实就是一个ConcurrentHashMap)中,同时将beanName存入beanDefinitionNames(List类型)中,然后遍历beanDefinitionNames中的beanName,进行bean的实例化并填充属性,在实例化的过程中,如果有依赖没有被实例化将先实例化其依赖,然后实例化本身,实例化完成后将实例存入单例bean的缓存中,当调用getBean方法时,到单例bean的缓存中查找,如果找到并经过转换后返回这个实例,之后就可以直接使用了。
  这里强烈建议大家看一篇文章,对于Spring IoC的原理解释的很清楚。
  spring ioc原理(看完后大家可以自己写一个spring)
  同时感谢以下博文,写作时作为参考借鉴
  Spring IOC核心源码学习
  深入理解Spring系列

下节 长话短说Spring(2)之AOP面向切面编程
简书 Wwwwei
转载请注明原创出处,谢谢!

推荐阅读更多精彩内容