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的理解，如有错误请指正。