java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring依赖注入

深入了解Spring中的依赖注入DI

作者:god23bin

这篇文章主要介绍了Spring 中的依赖注入,包括注入的方式,写法,该选择哪个注入方式以及可能出现的循环依赖问题等内容,需要的可以参考一下

什么是依赖注入

依赖注入是一个过程,举个例子:

public class A {
    private B b;
    // 省略 getter 和 setter
    // 省略构造方法
}

现在 A 类 是依赖 B 类的,没有 B,A 什么都不是。Spring IoC 容器创建好 B 的实例对象后并赋值给 A 对象中的 b 属性(成员变量)的过程,就是所谓的「依赖注入」。

当然,这也是所谓的控制反转了,对象 b 的创建不是我们手动 new 创建的,而是 Spring IoC 容器创建的。

使用 DI 原则,可以让代码更加简洁,当对象提供其依赖项时,解耦也更加有效。依赖项 B 注入给 A 的实例对象,A 的实例对象是不会查找它的依赖项 B 的,也不知道依赖项 B 的位置。

依赖注入主要有两种实现方式:基于构造方法的依赖注入基于 Setter 的依赖注入

基于构造方法的依赖注入

基于构造方法的 DI 是通过 Spring IoC 容器调用带有许多参数的构造方法来完成的,每个参数表示一个依赖项。这与上一篇中调用具有特定参数的静态工厂方法来构造 Bean 是几乎等价的。

public class Vehicle {
    // Vehicle 依赖于 Producer 对象,或者说 Vehicle 持有一个 Producer 依赖项
    private final Producer producer;
    // 构造方法,让 Spring IoC 容器能够注入 Producer 对象给 Vehicle 对象
    public Vehicle(Producer producer) {
        this.producer = producer;
    }
}

注意,这个 Vehicle 类就只是一个普通的 Java Bean,或者说 POJO,没什么特别之处,最普通不过的类了,没有继承或者实现 Spring 指定的任意类。

构造方法中参数的解析

Spring IoC 是通过构造方法参数的解析来匹配需要注入的依赖项。换句话说,解析实际上就是通过匹配参数的类型,来确定注入什么依赖项

如果构造方法的参数中没有存在潜在的歧义,那么在 Bean 被实例化的时候,构造方法中参数的顺序和实例化时进行赋值是一样的。

package cn.god23bin.demo.model;
public class A {
    private B b;
    private C c;
    public A(B b, C c) {
        this.b = b;
        this.c = c;
    }
}

单独写这些类,是完成不了依赖注入的,这时候需要配置元数据了,让它与 Java 类相结合,才能发挥 Spring IoC 的作用。

现在假设 B 和 C 是没有任何继承上的关联,也没有任何潜在的歧义,那么我们在配置元数据中的配置是正常的,需要使用到 <constructor-arg/> 标签,该标签只需有一个 ref 属性,即引用(reference),指明 A 的构造方法的参数为 B 和 C,如下:

<beans>
	<bean id="a" class="cn.god23bin.demo.model.A">
		<constructor-arg ref="b"/>
		<constructor-arg ref="c"/>
	</bean>
	<bean id="b" class="cn.god23bin.demo.model.B"/>
	<bean id="c" class="cn.god23bin.demo.model.C"/>
</beans>

我们知道,B 和 C 是属于引用类型,类型是确切的,所以直接使用 ref 属性。

如果是基本数据类型,那么赋值时,就可能会有歧义,Spring 不能确定这个值的类型,比如一个基本数据类型的值是 true这时候歧义就出现了,它是布尔类型还是字符串类型呢?这就需要由我们来告诉 Spring 了,就需要使用 typevalue 属性来指定。

比如:

package cn.god23bin.demo.model;
public class D {
    private final int money;
    private final String power;
    public D(int money, String power) {
        this.money = money;
        this.power = power;
    }
}
<bean id="d" class="cn.god23bin.demo.model.D">
	<constructor-arg type="int" value="25000000"/>
	<constructor-arg type="java.lang.String" value="25"/>
</bean>

当然,除了使用 type 指定基本数据类型,还有两个属性可以解决歧义,分别是 indexname 属性。

index 属性:

使用 index 属性指定构造方法参数的下标,下标是从 0 开始的,来解决参数类型出现歧义的情况。

<bean id="d" class="cn.god23bin.demo.model.D">
	<constructor-arg index="0" value="25000000"/>
	<constructor-arg index="1" value="25"/>
</bean>

name 属性:

使用 name 属性指定构造方法参数的名称来解决歧义。

<bean id="d" class="cn.god23bin.demo.model.D">
	<constructor-arg name="money" value="25000000"/>
	<constructor-arg name="power" value="25"/>
</bean>

基于 Setter 的依赖注入

基于 Setter 的 DI,是在 Spring IoC 容器调用了 Bean 的无参构造方法或者无参的静态工厂方法实例化了 Bean 之后,再来调用 Bean 的 Setter 方法来实现的。

下面这个依旧是普通的 Java Bean,当然你加上相关业务逻辑,就不是纯粹的 Java Bean 了,不过 Spring 依旧能够管理这种对象。

Vehicle:

public class Vehicle {
    // Vehicle 持有的 Producer 依赖项
    private Producer pro;
    // 同理
    private Author aut;
    // 同理
    private int money;
    // setter 方法,可以让 Spring IoC 容器调用注入 Producer 对象
    public void setProducer(Producer pro) {
        this.pro = pro;
    }
    // 同理
    public void setAut(Author aut) {
        this.aut = aut;
    }
    // 同理
    public void setMoney(int money) {
        this.money = money
    }
    // 业务逻辑,有关 Producer 的...
}

对应的配置元数据:

<bean id="vehicle" class="cn.god23bin.demo.model.Vehicle">
    <!-- 使用 property 标签的 ref 属性注入引用类型的依赖项 -->
    <property name="pro" ref="producer"/>
    <!-- 使用内嵌 ref 标签 注入 -->
    <property name="aut">
    	<ref bean="author"/>
    </property>
    <property name="money" value="255"/>
</bean>
<bean id="producer" class="cn.god23bin.demo.model.Producer"/>
<bean id="author" class="cn.god23bin.demo.model.Author"/>

Spring IoC 容器(ApplicationContext)支持基于构造方法的 DI 和基于 Setter 的 DI,也支持使用构造方法注入了一部分依赖项后,再使用 Setter 的方式注入其他的依赖项。

我们可以通过配置一个 BeanDefinitionPropertyEditor 来实现这些属性的注入。但是,我们基本不会这样用,而是使用 XML 的 Bean 定义,使用注解的 Bean 定义(比如 @Component@Controller 等),又或者使用 @Bean 这种基于 Java 配置类的方式(@Configuration)来定义。

实际上,这些最终都会转成 BeanDefinition 对象的并被 Spring IoC 使用。

选择哪个 DI 方式

在代码的编写中,选择使用构造方法注入还是使用 Setter 注入呢?

官网上是这么说的:

Since you can mix constructor-based and setter-based DI, it is a good rule of thumb to use constructors for mandatory dependencies and setter methods or configuration methods for optional dependencies. Note that use of the @Autowired annotation on a setter method can be used to make the property be a required dependency; however, constructor injection with programmatic validation of arguments is preferable.

The Spring team generally advocates constructor injection, as it lets you implement application components as immutable objects and ensures that required dependencies are not null. Furthermore, constructor-injected components are always returned to the client (calling) code in a fully initialized state. As a side note, a large number of constructor arguments is a bad code smell, implying that the class likely has too many responsibilities and should be refactored to better address proper separation of concerns.

Setter injection should primarily only be used for optional dependencies that can be assigned reasonable default values within the class. Otherwise, not-null checks must be performed everywhere the code uses the dependency. One benefit of setter injection is that setter methods make objects of that class amenable to reconfiguration or re-injection later. Management through JMX MBeans is therefore a compelling use case for setter injection.

Use the DI style that makes the most sense for a particular class. Sometimes, when dealing with third-party classes for which you do not have the source, the choice is made for you. For example, if a third-party class does not expose any setter methods, then constructor injection may be the only available form of DI.

简而言之,Spring 团队是推荐用构造方法来完成 DI 的

对于构造方法进行 DI ,其中:

依赖的处理过程

Spring IoC 容器按如下方式执行 Bean 的依赖处理(Dependency Resolution Process,个人认为把 Resolution 理解成处理,解决等意思比较好)。

当 Spring IoC 容器被创建时,Spring IoC 容器一开始就会校验每个 Bean 的配置。在创建 Bean 之前,Bean 的属性本身不会被设置。

而且当容器被创建时,那些具有单例作用域的 Bean 也默认会被创建。对于其他情况的 Bean,只有在被请求时才会创建。

一个 Bean 的创建是有可能导致一堆 Bean 被创建,这一堆的 Bean 被称为 Bean 图(a graph of beans),因为 Bean 与 Bean 之间可能存在相互依赖,如同社会中的人一样,都有相关的联系,所以形成 Bean 图。

Bean 作用域在进行 Bean 定义的时候可以进行定义,使用 scope 属性即可定义 Bean 的作用域。

循环依赖

当你使用构造函数注入的时候,某种情况下可能产生一个无法解决的循环依赖问题。那什么是循环依赖

举个例子:

public class A {
    private B b;
    public A(B b) {
        this.b = b;
    }
}
public class B {
    private A a;
    public B(A a){
        this.a = a;
    }
}

如上所示,A 类通过构造方法注入需要 B 类的对象,而 B 类也通过构造方法注入 A 类的一个对象,这种情况就是所谓的循环依赖,A 和 B 之间相互依赖。

A 和 B 之间的循环依赖关系会迫使其中一个 Bean 在未完全初始化之前,被注入到另一个 Bean 中。

这时候,Spring IoC 容器会在运行时检测到这种循环的引用,并抛出一个 BeanCurrentlyInCreationException

有一种解决方案就是:修改 A 类或者 B 类的源代码,使其通过 Setter 方式注入依赖项。

当然,一般情况下,我们可以完全相信 Spring,Spring 会在容器加载时检测配置问题,如检查引用不存在的 Bean 或循环依赖等。它会尽量晚地设置 Bean 的属性以及处理依赖的关系。

假设当你请求一个对象时,如果在创建该对象或其依赖关系时出现问题,已经正确加载的 Spring 容器就会产生异常。所以,这意味着我们需要提前发现这些问题。

默认情况下,ApplicationContext 会预先实例化单例 Bean,所以在创建 Spring IoC 容器时会花费一些时间和内存。但好处是可以在容器创建时发现配置问题,而不是在后续出现。

如果不存在循环依赖关系,一个 Bean 在被注入到另一个 Bean 之前会被完全配置。这意味着当 A 依赖于 B 时,Spring IoC 容器会先完全配置好 B(包括实例化 Bean、设置依赖关系和调用相关的生命周期方法),再调用 A 的 Setter 方法。

依赖注入示例

下面写下示例,快速回顾下上面的两种注入方式,帮助大家更好理解在以 XML 作为配置元数据的情况下,使用基于构造方法的 DI 和基于 Setter 的 DI。

基于构造方法的 DI:

package cn.god23bin.demo.service;
import cn.god23bin.demo.repository.UserRepository;
public class UserService {
    // UserService 的依赖项 UserRepository
	private UserRepository userRepository;
    // 使用构造方法进行 DI,将 UserRepository 注入到 UserService
	public UserService(UserRepository userRepository) {
    	this.userRepository = userRepository;
	}
}
<bean id="userService" class="cn.god23bin.demo.service.UserService">
   <constructor-arg ref="userRepository" />
</bean>
<bean id="userRepository" class="cn.god23bin.demo.repository.UserRepository" />

基于 Setter 的 DI:

package cn.god23bin.demo.service;
import cn.god23bin.demo.repository.UserRepository;
public class UserService {
	private UserRepository userRepository;
	public void setUserRepository(UserRepository userRepository) {
		this.userRepository = userRepository;
	}
}
<bean id="userService" class="cn.god23bin.demo.service.UserService">
   <property name="userRepository" ref="userRepository" />
</bean>
<bean id="userRepository" class="cn.god23bin.demo.repository.UserRepository" />

总结

本文开头举了个例子讲了什么是依赖注入,实际上就是一个过程,把一个 Bean 注入到另一个 Bean 中的过程。

这个过程,在 Spring 中有两种方式来实现,一种是基于构造方法的 DI,另一种是基于 Setter 的DI。当然,网上讲到的依赖注入,还有好几种方式,目前对于我们来说,知道这两种就 OK。

对于这两种 DI,我们也说了如何选择,具体看官网的说法,推荐的是基于构造方法的 DI,当然,具体问题具体分析,有时候是需要用到基于 Setter 的 DI 的,比如解决循环依赖的时候。

接着也说了依赖的处理过程,简单点就是 Spring 会先根据配置元数据去创建 ApplicationContext 这个作为 Spring IoC 容器,在容器创建时,会验证 Bean 是否正确配置了,默认单例的 Bean 会先被创建等等等的处理。同时可能遇到循环依赖的问题,一种解决方案就是将某一个 Bean 使用 Setter 的方式注入依赖项。

以上就是深入了解Spring中的依赖注入DI的详细内容,更多关于Spring依赖注入的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:
阅读全文