Spring的工作原理（二）IOC-DI-阿里云开发者社区

Spring的工作原理（二）IOC-DI

由上一篇文章其实借着打印HelloWorld的这个例子已经简单理解了什么是控制反转。这里再一次详细讲解一下。

一、什么是IOC，什么是DI？

先把定义记住，后面才能有序的进行，否则就容易看不懂。

1.1 IOC（Inversion of Control）-控制反转。

控制反转与其定义为Spring中的一种技术，不如说是一种设计思想。在之前我们使用new的方式来进行创建对象，现在创建对象的权利交给了Spring来统一管理：即对对象的定义、作用域、生命周期、后置处理器、定义集成。

1.2 DI（Dependency Injection）-依赖注入。

懂了控制反转之后，依赖注入就容易理解了，依赖注入的原理就是控制反转，因为管理权在Spring，如果对象与对象之间存在一定的联系，那么由Spring容器（或者叫IOC容器）动态的将某个依赖关系注入到组件当中，这个过程就是依赖注入。组件之间的依赖关系由容器运行期决定。

举个例子

在Spring框架下，当Bean实例 A运行过程中需要引用另外一个Bean实例B时，Spring框架会创建Bean的实例B，并将实例B通过实例A的构造函数、set方法、自动装配和注解方式注入到实例A，这种注入实例Bean到另外一个实例Bean的过程称为依赖注入。

二、IOC控制反转基础知识

本节就是讲解IOC怎么进行控制反转的，并且通过哪一个类、或者哪一个接口实现的。它是怎么进行管理Bean对象的？管理了对象的哪一些地方？怎么进行创建？销毁时间是什么？下面就详细介绍一下：

2.1 IOC对bean的获取

首先，被Spring管理的类使用哪一个接口创建？那就需要了解一下Spring中的Spring BeanFactory容器和Sring ApplicationContext容器。

2.1.1 Spring BeanFactory容器

这个容器接口在org.springframework.beans.factory.BeanFactor中被定义。BeanFactory中有大量的接口被实现，最常用的就是XmlBeanFactory类。它可以从一个XML文件中读取元数据，获取Bean。

例如我们声明了一个Spring的xml配置文件为Beans.xml，实体类为HelloWorld.java

   <bean id="helloWorld" class="com.tutorialspoint.HelloWorld">
       <property name="message" value="Hello World!"/>
   </bean>

我们使用XmlBeanFactory进行读取Beans.xml,并创建HelloWorld的方式为：

XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("Beans.xml"));
HelloWorld obj = (HelloWorld) factory.getBean("helloWorld"); //HelloWorld被Bean设置的Id为"helloWorld"

分析一下：

第一步就是利用Spring框架提供的XmlBeanFactory()API生成工厂Bean并利用 ClassPathResource() API 去加载在路径 CLASSPATH 下可用的 bean 配置文件。在此时XmlBeanFactory()初始化所有的Bean对象。

第二步就是利用第一步生成Bean工厂对象，利用getBean()方法获取所需要的Bean。该方法是通过配置文件中的Bean Id来返回一个真正的对象。

2.1.2 Spring ApplicationContext 容器

说到ApplicationContext容器，其实它是BeanFactory 的子接口。称为Spring上下文。

接口：org.springframework.context.ApplicationContext interface中被定义。

最常被使用的 ApplicationContext 接口实现：

FileSystemXmlApplicationContext：该容器从 XML 文件中加载已被定义的 bean。在这里，你需要提供给构造器 XML 文件的完整路径。
ClassPathXmlApplicationContext：该容器从 XML 文件中加载已被定义的 bean。在这里，你不需要提供 XML 文件的完整路径，只需正确配置 CLASSPATH 环境变量即可，因为，容器会从 CLASSPATH 中搜索 bean 配置文件。
WebXmlApplicationContext：该容器会在一个 web 应用程序的范围内加载在 XML 文件中已被定义的 bean。

例如我们声明了一个Spring的xml配置文件为Beans.xml，实体类为HelloWorld.java

   <bean id="helloWorld" class="com.tutorialspoint.HelloWorld">
       <property name="message" value="Hello World!"/>
   </bean>

我们使用FileSystemXmlApplicationContext进行读取Beans.xml,并创建HelloWorld的方式为：

ApplicationContext context = new FileSystemXmlApplicationContext("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");

其他两个同理。不过是路径不同。

分析一下：

第一步生成工厂对象。加载完指定路径下 bean 配置文件后，利用框架提供的 FileSystemXmlApplicationContext API 去生成工厂 bean。FileSystemXmlApplicationContext 负责生成和初始化所有的对象，比如，所有在 XML bean 配置文件中的 bean。

第二步用第一步生成的上下文中的 getBean() 方法得到所需要的 bean。这个方法通过配置文件中的 bean ID 来返回一个真正的对象。一旦得到这个对象，就可以利用这个对象来调用任何方法。

2.2 IOC容器对Bean的管理

由2.1 我们可以知道在Bean中定义了一个HelloWorld对象。就来详细研究一下，Bean的定义、作用域、生命周期。

2.2.1 SpringBean定义

属性	描述
class	这个属性是强制性的，并且指定用来创建 bean 的 bean 类。
name	这个属性指定唯一的 bean 标识符。在基于 XML 的配置元数据中，你可以使用 ID 和/或 name 属性来指定 bean 标识符。
scope	这个属性指定由特定的 bean 定义创建的对象的作用域。
constructor-arg	基于构造函数的依赖注入。
properties	基于设置函数的依赖注入。
autowiring mode	自动装配实现
lazy-initialization mode	延迟初始化的 bean 告诉 IoC 容器在它第一次被请求时，而不是在启动时去创建一个 bean 实例。
initialization 方法	在 bean 的所有必需的属性被容器设置之后，调用回调方法。
destruction 方法	当包含该 bean 的容器被销毁时，使用回调方法。

Spring和Bean之间的关系图：

2.2.2 配置数据元供给Spring

（1）基于 XML 的配置文件

（2）基于注解的配置

（3）基于 Java 的配置

让我们一一来看一下：

（1）基于 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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
   <!-- 基础的Bean对象加载方式 -->
   <bean id="..." class="...">
       <!-- collaborators and configuration for this bean go here -->
   </bean>
 
   <!-- Bean的懒加载方法 -->
   <bean id="..." class="..." lazy-init="true">
       <!-- collaborators and configuration for this bean go here -->
   </bean>
 
   <!-- Bean初始化方法 -->
   <bean id="..." class="..." init-method="...">
       <!-- collaborators and configuration for this bean go here -->
   </bean>
   <!-- Bean的销毁方法 -->
   <bean id="..." class="..." destroy-method="...">
       <!-- collaborators and configuration for this bean go here -->
   </bean>
 
   <!-- more bean definitions go here -->
 
</beans>

对于Spring Bean的定义，属于默认空间命名，没有空间名。

xmlns="http://www.springframework.org/schema/beans"

对于xsi来说，它是一个标准命名空间。这个命名空间为每个文档中指定相应的Schema文件，这是标准组织定义的标准命名空间。

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

（2）基于注解的配置

自从Spring2.5之后，Spring就可以用配置注解的方式进行依赖注入。该种方式无需在xml中配置Bean引用。

注解配置默认在Spring中是关闭的，需要在配置文件中进行打开。（引入context空间）

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
    <context:annotation-config/>
 
</beans>

下面就可以使用注解，解释几个常用的重要注解：

@Required注解应用于bean属性的setter方法，用来检查是否已经设置了所有必需的属性。
@Autowired它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。
@Qualifier，通过指定确切的将被引用的bean，@Autowired和@Qualifier注解可以用来删除混乱
SR-250 Annotations，Spring支持JSR-250的基础的注解，其中包括了@Resource，@PostContruct和@PreDestory注解

简介项目：

pom.xml文件中引入了

spring-core spring-beans spring-context junit

package com.mcb.spring.vo;
public class HelloWorld {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void sayHello(){
        System.out.println(name+"说： Hello World");
    }
}

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">
 
    <context:annotation-config />
    <bean id="hello" class="com.mcb.spring.vo.HelloWorld">
        <property name="name" value="Sum"/>
    </bean>
</beans>

import com.mcb.spring.vo.HelloWorld;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class TestSpring {
    @Test
    public void sayHello(){
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        HelloWorld hello = (HelloWorld)context.getBean("hello");
        hello.sayHello();
    }
}

A. @Required

将该注解加到setter 方法中：

    @Required
    public void setName(String name) {
        this.name = name;
    }

此时如果我们将Beans.xml中name的<property>属性注释掉，我们会发现class报错。并提示"必须的参数缺失"。

如果我们将注解@Required去掉，并且同样注释参数，运行程序。运行成功，但是参数为属性name的值为 null。

B.@Autowired

1，setter方法中的@Autowired

我们稍微改造一下上面的工程，添加Person类

Person类：

package com.mcb.spring.vo;
 
public class Person {
    private String name;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

定义Beans.xml。将Person放在Spring进行管理。

    <context:annotation-config />
    <bean id="hello" class="com.mcb.spring.vo.HelloWorld">
        <!--<property name="name" value="Sum"/>-->
    </bean>
 
    <bean id="person" class="com.mcb.spring.vo.Person">
        <property name="name" value="Tom"/>
    </bean>

将Person对象通过setter方法进行注入。

package com.mcb.spring.vo;
import org.springframework.beans.factory.annotation.Autowired;
public class HelloWorld {
    private String name;
    public String getName() {
        return name;
    }
    @Autowired    // 将Person类注入进来
    public void setName(Person person) {
        this.name = person.getName();
    }
    public void sayHello(){
        System.out.println(name+"说： Hello World");
    }
}

运行程序，让我们看一下结果：

2，同理在属性中和构造方法中@Autowired ，原理一致。都可以将Person对象注入到HelloWorld中，进行name输出。

    @Autowired    // 将Person类注入进来
    private Person person;

    @Autowired
    public HelloWorld(Person person) {
        this.name = person.getName();
    }

C.@Qualifier

结合使用@Qualifier和@Autowired注解通过指定哪一个真正的bean将会被装配来消除混乱。

还是以上图工程为例：配置同一个Preson，两个不同对象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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">
    <context:annotation-config />
    <bean id="hello" class="com.mcb.spring.vo.HelloWorld">
        <!--<property name="name" value="Sum"/>-->
    </bean>
    <bean id="person1" class="com.mcb.spring.vo.Person">
        <property name="name" value="Tom"/>
    </bean>
    <bean id="person2" class="com.mcb.spring.vo.Person">
        <property name="name" value="Jim"/>
    </bean>
</beans>

在HelloWorld中进行注入

package com.mcb.spring.vo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
public class HelloWorld {
    @Autowired
    @Qualifier("person2")
    private Person person;
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void sayHello(){
        System.out.println(person.getName()+"说： Hello World");
    }
}

运行测试类，进行打印：

D. SR-250 Annotations

在此我们了解一下一个注解@Resource。

上图使用了 @Autowired 和Qualifier来进行了注入。

@Autowired
@Qualifier("person2")
private Person person;

我们还可以使用@Resource进行注入。

@Resource(name = "person2")
private Person person;

可以达到同样的效果。

他们的区别如下：

@Autowired注解为Spring提供的注解，只按照byType方式注入，默认情况下，它要求依赖对象必须存在，如果允许为null，可以设置它的required属性为false,如果我们想按照byName方式来装配，可以结合@Qualifier注解一起使用；
@Resource为J2EE提供的注解，它有两个重要的属性：name和type。而默认情况下，@Resource注解按照byName的方式来装配。@Resource的装配顺序是这样的：如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。

（3）基于 Java 的配置

Spring中为了减少XML配置，可以声明一个配置类类对bean进行配置，主要用到两个注解@Configuration和@bean

第一步：在Spring中开启包扫描。

<beans>
     <context:component-scan base-package="com.mcb.spring.vo"/>
</beans>

第二步：建立SpringConfig类。

package com.mcb.spring.config;
 
import com.mcb.spring.vo.HelloWorld;
import com.mcb.spring.vo.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class SpringConfig {
    @Bean
    public HelloWorld helloWorld(Person person){
        HelloWorld helloWorld = new HelloWorld();
        helloWorld.setName(person.getName());
        return helloWorld;
    }
    @Bean
    public Person person() {
        Person person = new Person();
        person.setName("Jim");
        return person;
    }
}

第三步：测试类使用AnnotationConfigApplicationContext获取ApplicationContext类。

import com.mcb.spring.config.SpringConfig;
import com.mcb.spring.vo.HelloWorld;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class TestSpring {
    @Test
    public void sayHello(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        HelloWorld hello = (HelloWorld)context.getBean(HelloWorld.class);
        hello.sayHello();
    }
}

运行正常。

在第一步中，也可以用@ComponentScan注解代替xml的方式进行。

@Configuration
@ComponentScan(basePackages = "com.mcb.spring.config")
public class SpringConfig {
    ......
}

温馨提示：什么时候下使用什么样的注解呢？

2.2.3 Spring Bean的作用域

当Spring定义一个Bean时，必须声明该作用域的选项。目前支持五个作用域，分别是：singleton、prototype、request、session、global session。

用例： bean属性：scope

<bean id="..." class="..." scope="singleton">
    <!-- collaborators and configuration for this bean go here -->
</bean>

2.2.4 Spring Bean 生命周期

Bean的生命周期可以表达为： Bean的定义--> Bean的初始化--> Bean的使用 --> Bean的销毁

A。Bean的初始化回调函数。（实现InitializingBean）

import org.springframework.beans.factory.InitializingBean;

    public void afterPropertiesSet() throws Exception {
        System.out.println("我是Init回调函数");
    }

B。Bean的销毁回调函数。(DisposableBean)

import org.springframework.beans.factory.DisposableBean;

public void destroy() throws Exception {
        System.out.println("我是destroy回调函数");
}

C。Bean的初始化方法、销毁方法自定义。

public void destoryMy() {
    System.out.println("我是销毁方法");
}

public void init() {
        System.out.println("我是初始化方法");
}

<bean id="helloWorld" class="com.mcb.spring.vo.HelloWorld" init-method="init" destroy-method="destoryMy">
 
</bean>

将A、B、C同时配置后，结果如下：

我是Init回调函数
我是初始化方法
Jim说： Hello World
我是destroy回调函数
我是销毁方法

温馨提示：InitializingBean和DisposableBean的回调方法尽量不要使用，因为XML配置在命名方法上提供了极大的灵活性。

调用destory的时候，需要关闭hook的registerShutdownHook();

ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld hello = (HelloWorld)context.getBean("helloWorld");
hello.sayHello();
((ClassPathXmlApplicationContext) context).registerShutdownHook();

默认初始化和销毁方法（Beans 标签下）

Spring的工作原理（二）IOC-DI