Spring全家桶学习笔记 02 | 控制反转IoC与依赖注入DI

应了上一篇所言,我决定在创建第一个Spring程序之前先理解它的核心思想。(也由此纪念我的第一次面试没答上来依赖注入)

控制反转 IoC

何为控制反转

Inversion of Control,控制反转,一种设计思想,首先引用开涛老师对Ioc的理解

​ 在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们来深入分析一下:
​ 谁控制谁,控制什么:传统Java SE程序设计,我们直接在对象内部通过new进行创建对象,是程序主动去创建依赖对象;而IoC是有专门一个容器来创建这些对象,即由Ioc容器来控制对象的创建;谁控制谁?当然是IoC 容器控制了对象;控制什么?那就是主要控制了外部资源获取(不只是对象包括比如文件等。
​ 为何是反转,哪些方面反转了:有反转就有正转,传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象,也就是正转;而反转则是由容器来帮忙创建及注入依赖对象;为何是反转?因为由容器帮我们查找及注入依赖对象,对象只是被动的接受依赖对象,所以是反转;哪些方面反转了?依赖对象的获取被反转了。

Ioc实例

文字解释晦涩难懂,不妨用实例解释明白,

实例背景

有三个家庭结伴出游,A家庭有一辆奥迪Audi,B家庭有一辆宝马Audi,C家庭有一辆奔驰Benz。

在抛出IoC实例之前,有必要先看一看普通情况下的“正转”是什么样的:

假如A家庭出游在程序中是这样设计的:

pulic class FamilyA{
    public void go(){
        Audi audi = new Audi();
        audi.move();
    }
}
FamilyA familyA = new FamilyA();
familyA.go();

可以看到,在familyA的go方法中由familyA对象实例化了一个奥迪车对象,从而调用该对象的start方法。如此就会引申出一个问题:倘若日后A家庭换了一辆保时捷Porsche,那么A家庭再次出游时就需要对familyA类大范围的修改,其中所有涉及到Audi的地方全部需要更换为Porsche,代价相当之大。

以上例子中,familyA对象主动控制获取依赖对象的过程,通俗的说就是A家庭出游需要奥迪车,而familyA对象主动实例化Audi对象,这就是正转。

正转会带来很多问题,例如高耦合,而IoC的出现实质上就是为了解耦。那如何用IoC的思想解决这个问题呢?

首先定义一个Family接口,接口中只有一个go方法

public interface Family(){
    void go();
}

接下来再定义一个Car接口,接口中拥有汽车的基本功能

public interface Car(){
    void move();
}

这样自驾游的家庭ABC就是以下这种形式

public abstract class SelfDrivingTourFamily implements Family{
    
    protected Car car;
    
    public SelfDrivingTourFamily(Car car){
        this.car= car;
    }
    
    public abstract void go();
}

以Audi为例,各品牌车的类如下

public class Audi implements Car{
    
    public void move(){
        System.out.println("The Audi moves.");
    }
}

以A家庭为例,各家庭的类如下

public class FamilyA extends SelfDrivingTourFamily{
    
    public FamilyA(Car car){
        super(car);
    }
    
    public void go(){
        car.move();
    }
}

为了简单说明,本篇就不涉及容器的部分,我将main方法所处类视为一个容器(不知能否这样理解)。

这种情况下想要实现A家庭出游则需要在程序中这样设计:

FamilyA familyA = new FamilyA(Audi audi);
familyA.go();

如此一来,一旦面对上述A家庭换车的情况,只需要在添加了实现Car接口的Porsche类的情况下将实例化语句FamilyA familyA = new FamilyA(Audi audi);改为FamilyA familyA = new FamilyA(Porsche porsche);无需再对FamilyA类大动干戈。

从familyA对象主动控制获取Audi车对象到familyA对象借由容器控制获取Audi车对象,从对象控制依赖对象,到容器控制依赖对象,这就是反转。

那么依赖注入呢?

依赖注入

依赖注入(Dependency Injection)与控制反转实质上是对同一概念不同角度的解读。

例如上文正转的例子中,familyA对象高度依赖Audi类。需要自己实例化audi对象。而在反转的例子中,familyA对象无需关心自己此时开的是什么车,交由容器将audi对象注入family对象中,这就是依赖注入。

实际上依赖注入的说法比控制反转更加贴合代码,依赖注入明确描述了familyA对象依靠Ioc容器注入其依赖的audi对象。

总结

IoC与DI的核心思想就是要将具体类之间的依赖转换成抽象依赖,用上例说明就是SDTFamily类应该依赖于抽象的Car类,而不是具体的Audi类。

以上就是我对IoC与DI的理解,如有错误请指正。

你可能感兴趣的:(Spring)