亲宝软件园·资讯

展开

Spring框架中IoC容器与DI依赖注入教程

yyhgo_ 人气:0

一、Spring 是什么

我们通常所说的 Spring 指的是 Spring Framework (Spring 框架),它是⼀个开源框架,有着活跃而庞大的社区,这就是它之所以能长久不衰的原因。Spring ⽀持⼴泛的应⽤场景,它可以让 Java 企业级的应用程序开发起来更简单。

⽤⼀句话概括 Spring:Spring 是包含了众多工具方法的 IoC 容器。

那么问题来了,什么是容器?什么又是 IoC 容器呢?

1.1 什么是容器

顾名思义,容器是用来容纳某种物品的。

我们接触过的容器都有哪些?

1.2 什么是 IoC

IoC = Inversion of Control 翻译成中⽂是 “控制(权)反转” 的意思,也就是说 Spring 是⼀个 “控制反转” 的容器。怎么理解这句话呢?我们先从以下示例开始 ~

二、理解 IoC

2.1 传统程序开发的问题

假如,我们现在构建⼀辆 “车” 的程序,我们的实现思路是这样的:

构建⼀辆车 (Car Class),然而车需要依赖车身 (FrameWork Class),而车身需要依赖底盘 (Bottom Class),而底盘需要依赖轮胎 (Tire Class),最终程序的实现代码如下:(轮胎只有一个 size 属性)

package old;
/**
 * 构建“车”
 */
public class Car {
    private Framework framework;
    public Car(int size) {
        framework = new Framework(size);
    }
    public static void main(String[] args) {
        int size = 15;
        // 构建并运行车
        Car car = new Car(size);
        car.init();
    }
    // 运行
    public void init() {
        System.out.println("Car init.");
        // 依赖 framework init() 方法
        framework.init();
    }
}
package old;
/**
 * 车身
 */
public class Framework {
    private Bottom bottom;
    public Framework(int size) {
        bottom = new Bottom(size);
    }
    public void init() {
        System.out.println("Framework init.");
        // 依赖 Bottom:init()
        bottom.init();
    }
}
package old;
/**
 * 底盘
 */
public class Bottom {
    private Tire tire;
    public Bottom(int size) {
        tire = new Tire(size); // 自己(创)造
    }
    public void init() {
        System.out.println("Bottom init.");
        // 依赖:Tire:init()
        tire.init();
    }
}
package old;
/**
 * 轮胎
 */
public class Tire {
    // 尺寸
    private int size = 17;
    // 材质...
    // 花纹...
    // 颜色...
    // ...
    public Tire(int size) {
        this.size = size;
    }
    public void init() {
        System.out.println("Tire size:" + size);
    }
}

以上程序中,轮胎属性信息只有 size,然而随着对车的需求量越来越大,个性化需求也会越来越多,这时候我们就需要加工具有多个属性的轮胎。

而以上程序的问题是:添加轮胎属性时,即最底层代码改动之后,整个调用链上的所有代码 (所有类) 都需要修改。

2.2 分析

如何解决上述问题呢?

我们可以尝试不在每个类中自己创建下级类,如果自己创建下级类就会出现当下级类发生改变操作,自己也要跟着修改。

我们只需要将原来由自己创建的下级类,改为传递的方式 (也就是注入的方式),因为我们不需要在当前类中创建下级类了,所以下级类即使发生变化 (创建或减少参数),当前类本身也无需修改任何代码,这样就完成了程序的解耦。

解耦指的是解决了代码的耦合性问题,耦合性换⼀种叫法为程序相关性。好的程序代码的耦合性 (代码之间的相关性) 是很低的 ~~

这就好比我们打造⼀辆完整的汽车,如果所有的配件都是自己造,那么当客户需求发⽣改变的时候,我们就要自己动手来改了;但如果我们是把轮胎外包出去,那么我们只需要向代理工厂下订单就行了,我们自身是不需要出力的。

2.3 控制反转式程序开发

基于以上思路,我们把调用汽车的程序示例改造⼀下,把创建子类的方式,改为注入传递的方式,具体实现代码如下:

package v2;
public class TireV2 {
    private int size = 17;
    private String color = "黑色";
    public TireV2(int size, String color) {
        this.size = size;
        this.color = color;
    }
    public void init() {
        System.out.println("Tire v2 size:" + size);
    }
}
package v2;
public class BottomV2 {
    private TireV2 tireV2;
    public BottomV2(TireV2 tireV2) {
        this.tireV2 = tireV2;
    }
    public void init() {
        System.out.println("Bottom v2 init.");
        tireV2.init();
    }
}
package v2;
public class FrameworkV2 {
    private BottomV2 bottomV2;
    public FrameworkV2(BottomV2 bottomV2) {
        this.bottomV2 = bottomV2;
    }
    public void init() {
        System.out.println("Framework v2 init.");
        bottomV2.init();
    }
}
package v2;
/**
 * 控制反转的车
 */
public class CarV2 {
    private FrameworkV2 frameworkV2; // 依赖
    public CarV2(FrameworkV2 frameworkV2) {
//        frameworkV2 = new FrameworkV2(); // 自己创建(自己控制对象的生命周期)
        this.frameworkV2 = frameworkV2; // Car 构造方法不会在创建
    }
    public void init() {
        System.out.println("Car v2 init.");
        // 依赖 framework:init()
        frameworkV2.init();
    }
}

启动类:

package v2;
public class App {
    public static void main(String[] args) {
        // 程序调用
        int size = 15;
        String color = "红色";
        TireV2 tireV2 = new TireV2(size, color);
        BottomV2 bottomV2 = new BottomV2(tireV2);
        FrameworkV2 frameworkV2 = new FrameworkV2(bottomV2);
        CarV2 carV2 = new CarV2(frameworkV2);
        carV2.init();
    }
}

代码经过以上调整,无论底层类如何变化,整个调用链是不用做任何改变的。这样就完成了代码之间的解耦,从而实现了更加灵活、通用的程序设计!

2.4 对比总结规律

在传统的代码中对象创建顺序是:Car -> Framework -> Bottom -> Tire

改进之后解耦的代码的对象创建顺序是:Tire -> Bottom -> Framework -> Car

传统代码是 Car 创建并控制了 Framework,Framework 创建并控制了 Bottom,依次往下…而改进之后的控制权发生了反转,不再是上级对象创建并控制下级对象了,而是下级对象注入当前对象中,下级不再由上级类控制了!这样即使下级类发生任何改变,当前类都是不受影响的,这就是典型的控制反转,也就是 IoC 的实现思想。

谁调用我,就把控制权交给谁!而不是自己来控制,不用自己去new对象

2.5 理解 Spring IoC

回到我们的主题 Spring,本⽂刚开始咱们就讲:Spring 是包含了多个工具方法的 IoC 容器,这就是对 Spring 最核心的总结。“集成多个工具方法”这事咱们以后慢慢再谈,那如何理解“Spring 是⼀个 IoC 容器”这句话呢?

既然 Spring 是⼀个 IoC(控制反转)容器,重点还在“容器”⼆字上,那么它就具备两个最基础的功能:

也就是说 学习 Spring 最核心的功能,就是学习将对象存入到 Spring 中,再从 Spring 中获取对象的过程 ~

将对象存放到容器中的好处:将对象存储在 IoC 容器相当于将以后可能用到的所有工具都制作好并放到仓库中,需要的时候直接取就行了,用完再把它放回到仓库。而 new 对象的方式相当于,每次需要工具了,才现做,用完就扔掉了也不会保存,下次再用的时候还得重新做,这就是 IoC 容器和普通程序开发的区别。

Spring 是⼀个 IoC 容器,即 对象创建和销毁的权利都交给 Spring 来管理了,它本身又具备了存储对象和获取对象的能力。

三、DI 概念说明

谈到 IoC,不得不提的⼀个词就是 “DI”,DI 是 Dependency Injection 的缩写,翻译成中⽂是 “依赖注入” 的意思。

所谓依赖注入,就是由 IoC 容器在运行期间,动态地将某种依赖关系注入到对象之中。 所以,依赖注入(DI)和控制反转(IoC)是从不同的角度的描述的同⼀件事情,就是指通过引入 IoC 容器,利用依赖关系注⼊的方式,实现对象之间的解耦。

IoC 是“目标”也是⼀种思想,而目标和思想只是⼀种指导原则,最终还是要有可行的落地⽅案,而 DI 就属于具体的实现。

比如说我今天心情比较好,要吃一顿好的犒劳犒劳自己,那么“吃⼀顿好的”是思想和目标 (是 IoC),但最后我是吃海底捞还是必胜客…?这就是具体的实现,就是 DI 。

四、总结

Ioc全称Inversion of Control,把创建对象的权利交给容器,对象的实例不再由调用者来创建,而是由容器来创建,容器会负责控制程序之间的关系,而不是由调用者的程序代码直接控制。这样,控制权由应用代码转移带了容器,控制权发生了反转,这就是控制反转。它是spring框架的核心思想之一。

DI全称Dependency Injection,当某个java 实例需要另一个java实例时,创建被调用者的工作不是由调用者实现,而是由spring容器来完成,然后注入调用者,因此称为依赖注入。

加载全部内容

相关教程
猜你喜欢
用户评论