Spring系列之依赖注入

最新推荐文章于 2020-12-04 05:32:06 发布
最新推荐文章于 2020-12-04 05:32:06 发布
阅读量235 收藏
点赞数
文章标签： java c++ c语言 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TIANTIAN_ZZ/article/details/104393339
版权

在这里插入图片描述

Spring系列之依赖注入

Spring 中所有的 Bean 都是通过容器来进行管理的。每个 POJO 都可以是一个 Spring Bean。容器会管理 Bean 的依赖关系，这种依赖关系有可能是 Bean 之间的，也有可能是 Bean 对配置数据的依赖。在使用 Spring 的时候，开发者需要做的就是让 Spring 容器知道这些依赖关系，然后剩下的事情交给 Spring 容器就行了。
在这里插入图片描述
Spring 容器在初始化的时候会做两件事，将配置中的所有 POJO 加载进容器生成 Bean 并且注入 Bean 之间的依赖关系。配置 Bean 之间的依赖关系就是我们所说的依赖注入，需要注意的是这个生成 Bean 和依赖注入之间并不存在严格的先后关系，具体下面再说。

Bean 的配置

如果我们想让 Spring 来管理 Bean，第一步就是要将这些 Bean 装入容器中。把 Bean 装入容器中的方式有三种：

  • 使用 xml 配置文件
  • 使用注解78
  • 使用 Java 代码

这三种方式完成的效果都一样，而且这三种方式可以混合使用。在下面我会主要使用 xml 的方式来作为例子来进行演示，因为 xml 配置文件相对比较直观，也会提供注解版本和 Java 代码版本的例子。

public class Gun implements Weapon{
    @Override
    public boolean attack() {
        return false;
    }
}

<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="gun" name="gun1,gun2" class="cn.rayjun.springdemo.springcontainer.Gun">
    </bean>
</beans>

在上面的配置文件中，我们创建一个 xml 配置文件，其中 xml 根元素是 beans，然后里面有一个bean 元素，这就是一个 Spring Bean。上面配置文件的意思就是告诉容器，我有一个名字叫做Gun 的 Java 类，现在交给你管理了，就这么简单。

上面 XML Bean 的配置中有 id，name，class 等几个属性。其中 class 很简单，就是类的全限定名称，这个相当于告诉 Spring 容器要创建哪个类的实例。id 和 name 都是用来标识一个 Bean 的唯一性。每个 Bean 的 id 在容器中只能是唯一的，而 name 则可以有多个，每个 name 使用,、; 或者空格来隔开，id 的命名需要符合 XML 的命名规范，也就是不能使用特殊字符，但 name 则可以使用特殊字符来进行命名，如果没有定义 id，则会把 name 的第一个值定为 id，如果 id 和 name 都没有定义，则使用类全名加上数字编号来作为 id。获取 bean 的时候，可以通过如下的方式获取:

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Gun gun1 = (Gun) context.getBean("gun1");
Gun gun = (Gun) context.getBean("gun");

System.out.println(gun == gun1); // true

在实际使用 Spring 的过程中是不会使用上面的方式来使用 Bean，都会通过依赖注入的方式来获取。

使用注解如何配置呢，使用注解的配置如下：

@Component
public class Gun implements Weapon{
    @Override
    public boolean attack() {
        return false;
    }
}

<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <context:component-scan base-package="cn.rayjun.springdemo"/>
</beans>

上面的代码与完全使用 xml 配置的效果相同，你可能会想，这样更麻烦了，其实不是，在 xml 中添加 context:component-scan 之后，cn.rayjun.springdemo 包下所有被 @Component 注解的类都会自动添加到容器中。也就是 xml 中就不再需要 这个标签了，如果想把 xml 从代码中完全剔除掉上面的代码可以写成这样：

@Component
public class Gun implements Weapon{
    @Override
    public boolean attack() {
        return false;
    }
}

@Configuration
@ComponentScan(basePackages = "cn.rayjun.springdemo")
public class SoldierConfig {
}

除了 @Component 注解之外，还有 @Repository, @Service, @Controller 等注解，@Repository 主要用来标识数据层，@Service 主要用来标识 Service 层，@Controller 主要用来标识 Controller 层。这些注解其实并没有什么不同，这么做只是为了让代码的分层更加清晰，这些注解都可以使用 @Componenet 替代。@Repository注解的实现如下:

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

实际上 @Repository 等注解就是使用 @Component 注解实现的。Spring 号称是无侵入性的，但是上面的代码却在 Gun 类上添加了 @Component 的注解，虽然不影响代码的功能，但还是稍微有点侵入性的，下面是终极的方案:

public class Gun implements Weapon{
    @Override
    public boolean attack() {
        return false;
    }
}

@Configuration
public class SoldierConfig {
    @Bean
    public Gun gun() {
        return new Gun();
    }
}

这里使用带 @Configuration 的配置类完全替代 XML，这样一来，代码中没有 XML，通过也做到了对代码真正的无侵入性。

上面是将代码放入到容器中的三种方法，这三种方法不是独立存在的，而是可以混用的。这三种配置各有各的好处，XML 让 Bean 之间的依赖很清晰，而且不用修改源码；注解可以基本消除掉配置文件，但是这样代码中就会充斥各种注解；Java 配置则可以完全替代 XML。

依赖注入

在上面我们说生成 Bean 和依赖注入不存在严格的先后关系，这是因为 DI有两种方式：构造方法参数注入 和 Setter 方法注入。如果是构造参数注入，那么在 Bean 生成对象的时候就需要将依赖注入，如果是 Setter 方法注入，则是在 Bean 对象生成之后才会注入。

下面来看看如何进行依赖注入，先来看 XML 版本：

// 构造方法注入
public class Soldier {
    private Weapon weapon;

    public Soldier(Weapon weapon) {
        this.weapon = weapon;
    }
}
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="gun" class="cn.rayjun.springdemo.springcontainer.Gun">
    </bean>
    
    <bean id="solider" class="cn.rayjun.springdemo.springcontainer.Soldier">
        <constructor-arg name="weapon" ref="gun"/>
    </bean>
</beans>

使用构造方法注入时，需要在构造方法的参数上声明所需要的依赖，然后在 XML 配置中通过 将依赖注入。再来看看 Setter 方法注入:

// setter 方法注入
public class Soldier {
    private Weapon weapon;

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="gun" class="cn.rayjun.springdemo.springcontainer.Gun">
    </bean>

    <bean id="solider" class="cn.rayjun.springdemo.springcontainer.Soldier">
        <property name="weapon" ref="gun"/>
    </bean>
</beans>

首先 Solider 中需要有待注入依赖的 Setter 方法，然后在 XML 配置中通过 来进行注入。那么构造参数注入和 Setter 方法注入怎么选呢？官方的推荐的做法是：如果依赖关系是强依赖时，使用构造参数注入，如果是可选依赖，则使用 setter 进行注入。强依赖可以理解为当前这个 Bean 正常运行所必须的依赖。

下面再来看看注解的是如何来进行依赖注入的，先看下面这段代码，下面的这段代码使用的是构造函数参数注入的方式：

@Component
public class Soldier {
    private Weapon weapon;
    @Autowired
    public Soldier(Weapon weapon) {
        this.weapon = weapon;
    }
}
@Component
public class Knife implements Weapon{
    public boolean attack() {
        return false;
    }
}
@Component
public class Gun implements Weapon{
    public boolean attack() {
        return false;
    }
}

除了使用构造函数参数注入之外，还可以使用 Setter 方法注入和成员变量注入，这些注入方式的效果都一样:

// Setter 方法注入
@Component
public class Soldier {
    private Weapon weapon;
    @Autowired
    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}
// 私有成员变量注入
@Component
public class Soldier {
    @Autowired
    private Weapon weapon;
}

在上面的代码中，我们使用的是 @Autowired 来进行注入，也可以使用 @Inject 来进行依赖注入。这两个注解是等价的，可以在代码中互相替换，但是推荐在整个项目中保持统一。如果项目的依赖比较复杂，那么代码中就会充斥着这些注解，这也是使用注解配置的问题，大量的这样的注解会让代码不好管。注解使用是最便利的，但也是最难管理的。

还有最后一种注入方式，使用 Java 代码进行注入：

@Configuration
public class SoldierConfig {

    @Bean
    public Gun newGun() {
        return new Gun();
    }

    @Bean
    public Knife newKnife() {
        return new Knife();
    }
    
    @Bean
    public Soldier newSoldier() {
        // 使用构造方法参数注入
        return new Soldier(newGun());
    }
    
    @Bean
    public Soldier newSoldier() {
        // 使用 Setter方法参数注入
        Soldier s = new Soldier();
        s.setWeapon(newGun());
        return s;
    }
}

@ComponentScan 注解用来配置需要扫描的包的范围，被 @Bean 注解的方法表示会得到一个返回类型的 Bean，然后可以直接通过调用相应方法为 Bean 注入依赖。使用 Java 配置的好处是即可以不使用 XML 配置文件，又不会对代码有侵入。上面的代码中都是类之间的依赖，如果依赖的是普通的字面量或者一些容器类型，也可以进行注入，注入的方式如下：

<bean id="soldier" class="cn.rayjun.springdemo.container.Soldier" >
    <property name="name" value="Tom"/>
    <property name="age" value="12" />
</bean>

配置的 value 会根据 Bean 中成员的类型自动进行转换。还可以注入容器类型的值：

<bean id="soldier" class="cn.rayjun.springdemo.container.Soldier" >
    <property name="name" value="Tom"/>
    <property name="age" value="12" />
    <property name="foods">
        <list>
            <value>apple</value>
            <value>orange</value>
            <value>banana</value>
        </list>
    </property>
</bean

依赖冲突

Soldier 中需要注入一个 Weapon 类型的 Bean，现在 Gun 和 Knife 都实现了 Weapon，采用上面的方式注入时，就会报 UnsatisfiedDependencyException 异常，因为容器无法决定要注入哪一个。解决的方法有三种：

  • @Primary 注解
  • @Qualifier 注解
  • 自定义注解

被 @Primary 注解的 Bean 会被优先注入，这样就不会报错：

@Component
public class Soldier {
    private Weapon weapon;
    @Autowired
    public Soldier(Weapon weapon) {
        this.weapon = weapon;
    }
}

@Component
public class Knife implements Weapon{
    public boolean attack() {
        return false;
    }
}

@Component
@Primary
public class Gun implements Weapon{
    public boolean attack() {
        return false;
    }
}

还可以使用 @Qualifier 来明确告诉容器使用的是哪个 Bean。

@Component
public class Soldier {
    private Weapon weapon;
    @Autowired
    public Soldier(@Qualifier("gun") Weapon weapon) {
        this.weapon = weapon;
    }
}

@Component
@Qualifier("knife")
public class Knife implements Weapon{
    public boolean attack() {
        return false;
    }
}

@Component
@Qualifier("gun")
public class Gun implements Weapon{
    public boolean attack() {
        return false;
    }
}

自定义注解稍微复杂点，后续再写文章来说明。

循环依赖

在一些情况下，会出现循环依赖，虽然这种情况比较少，但还是有可能会出现.

public class ClassA {

    private ClassB classB;

    public ClassA(ClassB classB) {
        this.classB = classB;
    }
}
public class ClassB {

    private ClassA classA;

    public ClassB(ClassA classA) {
        this.classA = classA;
    }
}

<bean id="classB" class="cn.rayjun.springdemo.springcontainer.cycle.ClassB">
    <constructor-arg name="classA" ref="classA"/>
</bean>

<bean id="classA" class="cn.rayjun.springdemo.springcontainer.cycle.ClassA">
    <constructor-arg name="classB" ref="classB"/>
</bean>

如果按照上面的配置，启动的时候会报 UnsatisfiedDependencyException 异常，这就是循环依赖，解决的办法也很简单，就是把构造方法注入改成 Setter 方法注入。

public class ClassA {
    private ClassB classB;

    public void setClassB(ClassB classB) {
        this.classB = classB;
    }
}
public class ClassB {

    private ClassA classA;

    public void setClassA(ClassA classA) {
        this.classA = classA;
    }
}
<bean id="classB" class="cn.rayjun.springdemo.springcontainer.cycle.ClassB">
    <property name="classA" ref="classA"/>
</bean>
<bean id="classA" class="cn.rayjun.springdemo.springcontainer.cycle.ClassA">
    <property name="classB" ref="classB"/>
</bean>

改成 Setter 方法之后就可以注入成功了，原因就是构造函数注入和 Setter 方法注入的时机不同，构造函数需要在生成对象的时候就注入，这是 ClassA 和 ClassB 就产生了鸡生蛋还是蛋生鸡的问题。而 Setter 方法注入这是在生成对象之后，那就可以成功注入了

最后:

在这里插入图片描述
上面都是自己整理好的！我就把资料贡献出来给有需要的人！顺便求一波关注，哈哈~各位小伙伴关注我后私信【Java】就可以免费领取哒

TIANTIAN_ZZ
关注
依赖注入的三种方式
bujidexinq的专栏
02-25 931
在前面的例子中，我们说了学渣要完成作业必须要依赖学霸。那么学霸应该怎么把自己的作业交给学渣呢？（依赖注入） 进行依赖注入有三种方式： 1、构造方法依赖注入 public class StupidStudent { private SmartStudent smartStudent; public StupidStudent(SmartStudent smartSt...
Spring系列之依赖注入的方式
weixin_34319999的博客
09-26 1632
一、依赖注入方式       对于spring配置一个bean时，如果需要给该bean提供一些初始化参数，则需要通过依赖注入方式，所谓的依赖注入就是通过spring将bean所需要的一些参数传递到bean实例对象的过程，spring的依赖注入有3种方式： ·使用属性的setter方法注入 ，这是最常用的方式；·使用构造器注入；·使用Filed注入（用于注解方式）。 1.使用属性注入    ...
依赖注入三种方式
09-18 303
依赖注入有三种方式： 1接口注入： 接口注入的意思是通过接口来实现信息的注入，而其它的类要实现该接口时，就可以实现了注入： 下面是代码 Java代码 publicinterfaceManager{ publicvoidmanage(Businessbusiness); } publicclassxx{ privateBusinessbusi...
依赖注入的3种方式
11-02 444
属性注入: Car.class public class Car { public String brand; private String corp; private double price; private int maxSpeed;public String getBrand() { return b...
Spring系列之依赖注入的三种方式.docx
06-19
【Spring 依赖注入详解】 在 Spring 框架中，依赖注入（Dependency Injection，简称 DI）是一种关键的设计模式，它允许我们解耦组件之间的依赖关系，使得代码更加灵活，易于测试和维护。依赖注入的三种主要方式是：...
Spring quartz Job依赖注入使用详解
10-19
主要介绍了Spring quartz Job依赖注入使用详解的相关资料,Spring quartz Job不能依赖注入，Spring整合quartz Job任务不能注入Spring4整合quartz2.2.3中Job任务使用@Autowired不能注入，需要的朋友可以参考下
spring四种依赖注入方式的详细介绍
08-31
Spring框架的依赖注入（Dependency Injection，DI）是其核心特性之一，它允许开发者将对象的创建和组装过程交由Spring容器来管理，从而降低代码之间的耦合度，提高可测试性和可维护性。本文将详细讲解Spring框架中的...
浅谈Spring IoC容器的依赖注入原理
08-27
Spring IoC容器的依赖注入原理是Spring框架的核心机制之一，负责将服务对象（Bean）实例化并将其提供给客户端使用。依赖注入原理可以分为两个阶段：IoC容器初始化和Bean实例化。 在IoC容器初始化阶段，主要完成的...
spring学习：依赖注入的几种方式讨论
08-09
在Spring框架中，依赖注入（Dependency Injection，简称DI）是一种重要的设计模式，它使得对象之间的耦合度降低，提高了代码的可测试性和可维护性。本文将深入探讨Spring中的依赖注入实现方式，以及如何通过样例文件...
依赖注入的三种方式_依赖注入的三种方式
weixin_39645308的博客
12-04 695
在前面的例子中，我们说了学渣要完成作业必须要依赖学霸。那么学霸应该怎么把自己的作业交给学渣呢？（依赖注入）进行依赖注入有三种方式：1、构造方法依赖注入public public 这种方式好比学渣从一开始就赖上了一个学霸，并且和这个学霸建立了长期合作关系。2、setter方法注入public public 这种方式学霸和学渣只是暂时的合作关系，如果学渣赖上了另一个学霸（调用set()方法传入了另一个...
依赖注入通常有三种方法:
IT_yanyilong的博客
07-31 2046
接口注入、设置注入和构造器注入[Spring工厂注入]、 1. 构造注入是指通过构造函数来传入具体类的对象，设值注入是指通过Setter方 法来传入具体类的对象，通过构造方法注入Bean 的属性值或依赖的对象，它保证了 Bean 实例在实例化后就可以使用。     2.接口注入是指通过在接口中声明的业务方法来传入具体类的对象。这些方法在定义时使用的是抽象类型，在运行时再传入具体类型的对象...
Spring 依赖注入的3种方式
yy的博客
07-14 247
在使用spring的功能之前必须要装配好bean，并且建立好他们之间的关系。     Spring中依赖注入有3种方式： 构造器注入 setter注入 接口注入 一、构造器注入 public class Role{ private Long id; private String roleName; private String note; public Role(){ this....
spring 依赖注入的3种方式
weixin_34405557的博客
06-02 136
　　在实际环境中实现IoC容器的方式主要分为两大类，一类是依赖查找，依赖查找是通过资源定位，把对应的资源查找回来；另一类则是依赖注入，而Spring主要使用的是依赖注入。一般而言，依赖注入可以分为3种方式。 　　•构造器注入。 　　•setter注入。 　　•接口注入。　　构造器注入和setter注入是主要的方式，而接口注入是从别的地方注入的方式，比如在Web工程中，配置的数据源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值