Spring：所有依赖项注入的类型

一、前言

　　Spring文档严格只定义了两种类型的注入：构造函数注入和setter注入。但是，还有更多的方式来注入依赖项，例如字段注入，查找方法注入。下面主要是讲使用Spring框架时可能发生的类型。

二、构造函数注入（Constructor Injection）

　　这是最简单和推荐的依赖项注入方式。一个依赖类有一个构造函数，所有的依赖都被设置了，它们将由Spring容器根据XML，Java或基于注释的配置来提供。

package example;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

class Service1 {
    void doSmth() {
        System.out.println("Service1");
    }
}

class Service2 {
    void doSmth() {
        System.out.println("Service2");
    }
}

class DependentService {
    private final Service1 service1;
    private final Service2 service2;

    public DependentService(Service1 service1, Service2 service2) {
        this.service1 = service1;
        this.service2 = service2;
    }

    void doSmth() {
        service1.doSmth();
        service2.doSmth();
    }

}

public class Main {
    public static void main(String[] args) {
        ApplicationContext container = new ClassPathXmlApplicationContext("spring.xml");
        ((DependentService) container.getBean("dependentService")).doSmth();
    }
}

　　这里有2个独立服务和1个从属服务。依赖关系仅在构造函数中设置，要运行它，我们将初始化容器，并为其提供spring.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.xsd">

    <bean id="service1" class="example.Service1"/>
    <bean id="service2" class="example.Service2"/>

    <bean id="dependentService" class="example.DependentService">
        <constructor-arg type="example.Service1" ref="service1"/>
        <constructor-arg type="example.Service2" ref="service2"/>
    </bean>

</beans>

　　我们将所有3个服务声明为Spring bean，最后一个将前2个的引用为构造函数参数。但需要配置的东西比较多，是否需要编写这么多的配置？

　　我们可以使用“自动装配”功能，让Spring猜测从我们这边进行的最小配置工作应注入到什么位置。为了帮助Spring定位我们的代码，让我们用注解@Service和构造函数标记我们的服务，在注解中使用@Autowired或@Inject进行注入。@Autowired属于Spring框架，@Inject属JSR-330批注集合。

package example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Service;

@Service
class Service1 {
    void doSmth() {
        System.out.println("Service1");
    }
}

@Service
class Service2 {
    void doSmth() {
        System.out.println("Service2");
    }
}

@Service
class DependentService {
    private final Service1 service1;
    private final Service2 service2;

    @Autowired
    public DependentService(Service1 service1, Service2 service2) {
        this.service1 = service1;
        this.service2 = service2;
    }

    void doSmth() {
        service1.doSmth();
        service2.doSmth();
    }

}

public class Main {
    public static void main(String[] args) {
        ApplicationContext container = new ClassPathXmlApplicationContext("spring.xml");
        ((DependentService) container.getBean("dependentService")).doSmth();
    }
}

　　通过注解定义bean需要在spring.xml中开启以下配置：

<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">

    <!-- 使用注解来构造IoC容器 -->
    <context:component-scan base-package="example"/>
<beans/>

　　Spring提供了甚至在纯XML方法中也可以使用自动装配的可能性。但是，强烈建议避免使用此功能。

　　构造函数注入的优点：

1. 构造的对象是不可变的，并以完全初始化的状态返回给客户端。

2. 通过这种方法可以立即看到具有越来越多的依赖关系的问题。依赖越多，构造函数就越大。

3. 可以与setter注入或字段注入结合使用，构造函数参数指示所需的依赖关系，其他（可选）。

　　缺点：

1. 以后无法更改对象的依赖关系-不灵活性。

2. 具有循环依赖关系的机会更高，即所谓的“鸡与蛋”场景。

三、setter注入（Setter Injection）

 　　使用与之前示例相同的代码，简洁起见，构造函数注入不会有太多更改，因此仅更改的逻辑部分。

class DependentService {
    private Service1 service1;
    private Service2 service2;

    public void setService1(Service1 service1) {
        this.service1 = service1;
    }

    public void setService2(Service2 service2) {
        this.service2 = service2;
    }

    void doSmth() {
        service1.doSmth();
        service2.doSmth();
    }

}

　　正如注入类型的名称所暗示的那样，我们应该首先为依赖项创建setter。在这种情况下，不需要构造函数。让我们看一下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.xsd">

    <bean id="service1" class="example.Service1"/>
    <bean id="service2" class="example.Service2"/>

    <bean id="dependentService" class="example.DependentService">
        <property name="service1" ref="service1"/>
        <property name="service2" ref="service2"/>
    </bean>

</beans>

　　除了XML配置，还有基于注解的版本。

@Service
class DependentService {
    private Service1 service1;
    private Service2 service2;

    @Autowired
    public void setService1(Service1 service1) {
        this.service1 = service1;
    }

    @Autowired
    public void setService2(Service2 service2) {
        this.service2 = service2;
    }

    void doSmth() {
        service1.doSmth();
        service2.doSmth();
    }

}

　　这种类型的注入需要有Setter的存在，就像构造函数注入需要构造函数一样。

　　在描述构造函数注入的优点时，提到它可以轻松地与setter注入结合使用。

@Service
class DependentService {
    private final Service1 service1;
    private Service2 service2;

    @Autowired
    public DependentService(Service1 service1) {
        this.service1 = service1;
    }

    @Autowired
    public void setService2(Service2 service2) {
        this.service2 = service2;
    }

    void doSmth() {
        service1.doSmth();
        service2.doSmth();
    }
}

　　在示例中，service1对象是强制性依赖项（最终属性），在DependentService实例实例化期间仅设置一次。同时，service2是可选的，可以首先包含null，并且其值可以在创建后随时通过调用setter进行更改。用XML的方式，必须在bean声明中同时指定属性和builder-arg标记。

　　优点

1. 依赖关系解析或对象重新配置的灵活性，可以随时进行。另外，这种自由解决了构造函数注入的循环依赖问题。

　　缺点

1. null值检查是必需的，因为当前可能未设置依赖项。
2. 由于可能会覆盖依赖项，因此与构造函数注入相比，潜在的错误倾向更大，安全性更低。

四、字段注入（Field Injection）

@Service
class DependentService {
    @Autowired
    private Service1 service1;
    @Autowired
    private Service2 service2;

    void doSmth() {
        service1.doSmth();
        service2.doSmth();
    }
}

　　这种注入方式只有在基于注解的方法中才有可能，因为它实际上并不是一种新的注入方式，在较为底层的实现机制中，Spring使用反射来设置这些值。

　　优点

1. 易于使用，无需构造器或设置器

2. 可以轻松地与构造函数和(或)setter方法结合使用

　　缺点

1. 对对象实例化的控制较少。为了实例化测试的类的对象，需要配置Spring容器或模拟库，这取决于要编写的测试。

2. 在你发现设计中出现问题之前，许多依赖项可能达到数十种。

3. 依赖不是一成不变的，与setter注入相同。

五、查找方法注入（Lookup Method Injection）

　　由于特殊的使用情况，该注入类型的使用频率比上述所有其他类型的使用频率低，即依赖项的注入具有较小的寿命。

　　默认情况下，Spring中的所有bean均创建为singleton（单例），这意味着它们将在容器中创建一次，并且将在请求的任何位置注入相同的对象。但是，有时需要不同的策略，例如，每个方法调用都应从一个新对象完成。现在，假设将这个寿命短的对象注入到singleton对象中，Spring会在每次调用时自动刷新此依赖项吗？不，除非我们指出存在这种特殊的依赖类型，否则依赖仍将被视为单例。

　　回到实践中，我们又有了3个服务，其中一个依赖于其他服务，service2是通常的对象，可以通过任何先前描述的依赖项注入技术（例如，setter注入）注入DependentService中。Service1的对象将有所不同，不能被注入一次，每次调用都应访问一个新实例—让我们创建一个提供该对象的方法，并让Spring知道。

abstract class DependentService {
    private Service2 service2;

    public void setService2(Service2 service2) {
        this.service2 = service2;
    }

    void doSmth() {
        createService1().doSmth();
        service2.doSmth();
    }

    protected abstract Service1 createService1();
}

　　我们没有将Service1的对象声明为通常的依赖项，而是指定了Spring框架将覆盖该方法的方法，以便返回Service1类的最新实例。

　　依赖的方法提供者不一定要抽象和保护，它可以是公共的，也可以包含实现，但是请记住，它将在Spring创建的子类中被覆盖。

　　我们再次处于纯XML配置示例中，因此我们必须首先指出service1是一个寿命较短的对象，在Spring术语中，我们可以使用prototype范围（有多个实例），因为它小于单例。通过lookup-method标记，我们可以指示将注入依赖项的方法的名称。

<?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="service1" class="example.Service1" scope="prototype"/>
    <bean id="service2" class="example.Service2"/>

    <bean id="dependentService" class="example.DependentService">
        <lookup-method name="createService1" bean="service1"/>
        <property name="service2" ref="service2"/>
    </bean>

</beans>

　　也可以以基于注解的方式完成相同操作。

@Service
@Scope(value = "prototype")
class Service1 {
    void doSmth() {
        System.out.println("Service1");
    }
}

@Service
abstract class DependentService {
    private Service2 service2;

    @Autowired
    public void setService2(Service2 service2) {
        this.service2 = service2;
    }

    void doSmth() {
        createService1().doSmth();
        service2.doSmth();
    }

    @Lookup
    protected abstract Service1 createService1();
}

　　劣势与优势

　　将这种类型的依赖注入与其他类型的依赖注入进行比较是不正确的，因为它具有完全不同的用法。

六、结论

　　我们经历了由Spring框架实现的4种类型的依赖注入：

1. 构造函数注入- 良好，可靠且不变的，通过构造函数之一进行注入。可以配置为：XML，XML +注释，Java，Java +注释。

2. Setter注入- 更灵活，易变的对象，通过 Setter进行注入。可以配置为：XML，XML +注释，Java，Java +注释。

3. 与IoC容器结合使用，可快速方便地进行字段注入。可以在XML + Annotations，Java + Annotations中进行配置。

4. 查找方法注入——与其他方法完全不同，用于较小范围的注入依赖性。可以配置为：XML，XML +注释，Java，Java +注释。

参考：参考一、参考二、参考三、参考四