Spring IOC

字数 3595阅读 820

定义:

控制反转(Inversion Of Control):获得依赖对象的过程被反转了,由自身的管理,变成IOC容器注入
控制反转是Spring的核心,就是由Spring来控制对象的生命周期及对象间的关系
1)传统的开发模式:对象之间相互依赖
例如找女朋友,自己得到处找,从性格,外貌,身材等各个方面去考虑,去寻找


传统的开发模式.png

各个模块之间相互关联牵一发而动全身
2)IOC开发模式:IOC容器安排对象之间的关系
例如找女朋友的时候有一个婚介所,你把自己的需求提出来剩下的交给婚介所去安排就好了


IOC开发模式.png

把控制权交给了IOC容器,IOC容器相当于凝合剂的作用

IOC通俗理解:说的是创建实例对象的控制权从代码控制剥离到IOC容器控制,实际上就是在你的xml文件中控制,侧重原理
DI:说的是创建对象示例,为这个对象注入属性值和它的对象实例,侧重实现。

依赖注入和控制反转是对同一件事情的不同描述,从某个方面讲,就是它们描述的角度不同。依赖注入是从应用程序的角度在描述,可以把依赖注入描述完整点:应用程序依赖容器创建并注入它所需要的外部资源;而控制反转是从容器的角度在描述,描述完整点:容器控制应用程序,由容器反向的向应用程序注入应用程序所需要的外部资源。

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的生命周期
image.png

1.Spring对Bean进行实例化(相当于程序中的new Xx())
2.Spring将值和Bean的引用注入进Bean对应的属性中
3.如果Bean实现了BeanNameAware接口,Spring将Bean的ID传递给setBeanName()方法(实现BeanNameAware主要是为了通过Bean的引用来获得Bean的ID,一般业务中是很少有用到Bean的ID的)
4.如果Bean实现了BeanFactoryAware接口,Spring将调用setBeanFactory(BeanFactory bf)方法并把BeanFactory容器实例作为参数传入。(实现BeanFactoryAware 主要目的是为了获取Spring容器,如Bean通过Spring容器发布事件等)
5.如果Bean实现了ApplicationContextAwaer接口,Spring容器将调用setApplicationContext(ApplicationContext ctx)方法,把y应用上下文作为参数传入.(作用与BeanFactory类似都是为了获取Spring容器,不同的是Spring容器在调用setApplicationContext方法时会把它自己作为setApplicationContext 的参数传入,而Spring容器在调用setBeanDactory前需要程序员自己指定(注入)setBeanFactory里的参数BeanFactory )
6.如果Bean实现了BeanPostProcess接口,Spring将调用它们的postProcessBeforeInitialization(预初始化)方法(作用是在Bean实例创建成功后进行增强处理,如对Bean进行修改,增加某个功能)
7.如果Bean实现了InitializingBean接口,Spring将调用它们的afterPropertiesSet方法,作用与在配置文件中对Bean使用init-method声明初始化的作用一样,都是在Bean的全部属性设置成功后执行的初始化方法。
8.如果Bean实现了BeanPostProcess接口,Spring将调用它们的postProcessAfterInitialization(后初始化)方法(作用与6的一样,只不过6是在Bean初始化前执行的,而这个是在Bean初始化后执行的,时机不同 )
9.经过以上的工作后,Bean将一直驻留在应用上下文中给应用使用,直到应用上下文被销毁
10.如果Bean实现了DispostbleBean接口,Spring将调用它的destory方法,作用与在配置文件中对Bean使用destory-method属性的作用一样,都是在Bean实例销毁前执行的方法。

Spring Bean的作用域

  • singleton:单例模式,在整个Spring IoC容器中,使用singleton定义的Bean将只有一个实例
  • prototype:原型模式,每次通过容器的getBean方法获取prototype定义的Bean时,都将产生一个新的Bean实例
  • request:对于每次HTTP请求,使用request定义的Bean都将产生一个新实例,即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时,该作用域才有效
  • session:对于每次HTTP Session,使用session定义的Bean都将产生一个新实例。同样只有在Web应用中使用Spring时,该作用域才有效
  • globalsession:每个全局的HTTP Session,使用session定义的Bean都将产生一个新实例。典型情况下,仅在使用portlet context的时候有效。同样只有在Web应用中使用Spring时,该作用域才有效
例子:

我们来看一个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的实现原理

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容器的初始化.png

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属性中。

依赖注入
依赖注入的过程.png

依赖注入过程主要经过以下几个阶段:
  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的优点

  • 资源集中管理,实现资源的可配置和易管理。
  • 降低了使用资源双方的依赖程度,也就是我们说的耦合度。

依赖注入的四种方式:

依赖注入的四种方式

本文参考:https://www.jianshu.com/p/dff5484f4c01

推荐阅读更多精彩内容