個人對【依賴倒置(DIP)】、【控制反轉(IOC)】、【依賴注入(DI)】淺顯理解

一、依賴倒置（Dependency Inversion Principle）

依賴倒置是面向對象設計領域的一種軟件設計原則。（其他的設計原則還有：單一職責原則、開放封閉原則、里式替換原則、接口分離原則，合稱SOLID）

話說設計原則有什么用呢？

設計原則是無數編程前輩總結下來的經驗，好似編程界的金科玉律。在我看來就像是武俠小說中武林秘籍，內功心法。熟練掌握設計原則，必定會在編程道路上順風順水，獨霸一方。

言歸正傳，依賴倒置原則，依賴指的是什么？倒置又是什么呢？

先說說依賴，依賴是一種關系，A在某種情況下存在對B的需求關系，我們就可以看作A依賴B。

在生活中，魚依賴於水而生存，水被魚依賴；程序中，業務層依賴邏輯層，邏輯層依賴於數據層...

我們用面向對象編程來展示一下上面依賴關系：

    /// <summary>
    /// 河水
    /// </summary>
    public class RiverWater
    {
        public void GiveNutrition()
        {
            Console.WriteLine("我是河水，我給小魚提供養分。");
        }
    }
    /// <summary>
    /// 魚
    /// </summary>
    public class Fish
    {
        private RiverWater riverWater;
        public void Live()
        {
            riverWater = new RiverWater();
            riverWater.GiveNutrition();
        }
    }

Fish內部存在對RiverWater的引用，也就是說Fish 依賴於RiverWarter。

依賴關系整明白了，我們再來看看依賴倒置原則的定義：（敲黑板，划重點）

1.上層模塊不應該依賴底層模塊，它們都應該依賴於抽象。 2.抽象不應該依賴於細節，細節應該依賴於抽象。

問題又來了，什么是上層模塊和底層模塊？

對於任何一個組織機構而言，它一定有架構的設計，有職能的划分。按照職能的重要性，自然而然就有了上下之分。並且，隨着模塊的粒度划分不同這種上層與底層模塊會進行變動，也許某一模塊相對於另外一模塊它是底層，但是相對於其他模塊它又可能是上層。拿一個公司架構來看，管理層就是上層，管理層之下就是底層。然后，我們再以部門為體系划分，各個部門經理以上部分是上層，之下的組織都可以稱為底層。

由此，我們可以看到，在一個特定體系中，上層模塊與底層模塊可以按照決策能力高低為准繩進行划分。

映射到我們軟件實際開發中，一般我們也會將軟件進行模塊划分，比如業務層、邏輯層和數據層。 業務層中是軟件真正要進行的操作，也就是做什么；邏輯層是軟件現階段為了業務層的需求提供的實現細節，也就是怎么做；數據層指業務層和邏輯層所需要的數據模型。

因此，按照決策能力的高低進行模塊划分。業務層自然就處於上層模塊，邏輯層和數據層自然就歸類為底層。

什么是抽象和細節？

抽象就是對一類事物或行為的概括，總結其共性。抽象往往是相對具體而言，具體也就是這里的細節。比如：人是抽象，張三、李四就是具體；水是抽象，河水，井水就是具體的；武功秘籍是抽象的，獨孤九劍，葵花寶典是具體的；運動是抽象的，跑步，游泳是具體的...

映射到軟件開發中，抽象可以是接口或者抽象類的形式：

    public abstract class Water
    {
        public abstract void GiveNutrition();
    }
    /// <summary>
    /// 河水
    /// </summary>
    public class RiverWater : Water
    {
        public override void GiveNutrition()
        {
            Console.WriteLine("河水-提供養分。");
        }
    }
    /// <summary>
    /// 井水
    /// </summary>
    public class WellWater : Water
    {
        public override void GiveNutrition()
        {
            Console.WriteLine("井水-提供養分。");
        }
    }

Warter是抽象類，是抽象的，RiverWarter、WellWater繼承了Water，它們是具體的。

現在，搞清楚了上層模塊、底層模塊、抽象和具體。可以正式開始學習依賴倒置原則這個概念了。

先來看看我們平時開發的編碼邏輯：

/// <summary>
    /// 魚
    /// </summary>
    public class Fish
    {
        private RiverWater riverWater;
        public Fish()
        {
            riverWater = new RiverWater();
        }
        public void Live()
        {
            Console.WriteLine("我的生活靠：");
            riverWater.GiveNutrition();
        }
    }

我們創建了一條小魚fish，它的生活靠河水riverWater。　　

    class Program
    {
        static void Main(string[] args)
        {
            Fish fish = new Fish();
            fish.Live();
        }
    }

執行結果：

有一天，河水干涸了，小魚的生活要靠井水wellWater。於是代碼就要修改

/// <summary>
    /// 魚
    /// </summary>
    public class Fish
    {
        private RiverWater riverWater;
        private WellWater wellWater;
        public Fish()
        {
            //riverWater = new RiverWater();
            wellWater = new WellWater();
        }
        public void Live()
        {
            Console.WriteLine("我的生活靠：");
            //riverWater.GiveNutrition();
            wellWater.GiveNutrition();
        }
    }

我們就要修改Fish類的代碼。哪天，小魚游到了湖水lakeWater里。代碼又要修改

    /// <summary>
    /// 湖水
    /// </summary>
    public class LakeWater : Water
    {
        public override void GiveNutrition()
        {
            Console.WriteLine("湖水-提供養分。");
        }
    }
    /// <summary>
    /// 魚
    /// </summary>
    public class Fish
    {
        private RiverWater riverWater;
        private WellWater wellWater;
        private LakeWater lakeWater;
        public Fish()
        {
            //riverWater = new RiverWater();
            //wellWater = new WellWater();
            lakeWater = new LakeWater();
        }
        public void Live()
        {
            Console.WriteLine("我的生活靠：");
            //riverWater.GiveNutrition();
            //wellWater.GiveNutrition();
            lakeWater.GiveNutrition();
        }
    }

我們添加了LakeWater這個新的實現類，再次修改Fish類。

這是最基礎的演示代碼，如果工程大了，代碼復雜了，Fish面對需求變動時改動的地方會更多。那么問題來了：

有沒有方法讓Fish類變動的少一些？

依賴倒置原則正好適用於解決這類情況。下面，我們嘗試運用依賴倒置原則對代碼進行改造。

首先是上層模塊和底層模塊的拆分。按照決策能力高低或者重要性划分，Fish屬於上層模塊，RiverWater、WellWater 和 LakeWater 屬於底層模塊。

上層模塊不應該依賴於底層模塊。 Fish 這個類顯然是依賴於 RiveWater/WellWater/LakeWater。Fish 類中 Live() 的能力完全依賴於屬性riveWater/wellWater/lakeWater 對象。

上層和底層都應該依賴於抽象。因此我們要引入抽象——Water類。Fish類中 Live() 這個方法依賴於 Water的抽象方法，它沒有限定養分的提供方式，任何 RiverWater、WellWater 或者是 LakeWater 都可以的。

    /// <summary>
    /// 魚
    /// </summary>
    public class Fish
    {
        private Water water;
        public Fish()
        {
            water = new LakeWater();
        }
        public void Live()
        {
            Console.WriteLine("我的生活靠：");
            warter.GiveNutrition();
        }
    }

 運行結果：

到這一步，我們可以說是符合了上層不依賴於底層，依賴於抽象的准則了。

最后來說說我對倒置的理解：在未使用依賴倒置原則編碼以前，魚依賴具體的河水/井水，河水/井水是被依賴的。使用依賴倒置以后，魚依賴於抽象的水，具體的河水/井水不再被依賴，反而它們要求實現抽象的水（細節依賴於抽象），這種依賴關系的改變稱之為倒置。

二、控制反轉（Inversion Of Control）

 控制反轉(IOC)意思是對控制權的反轉。

那么控制權指的是什么？又是怎么反轉的？

以上面的例子來說,魚(Fish類)依賴於水(Water類)，所以Fish類內部控制着Water類的實例創建，這種方式可以理解為控制正轉。雖然魚已經依賴於抽象的水，Live()方法不會再因為生活水域的改變而改變，但水域變化時，我們還是要修改Fish類：

 

==>

現在我們改變這種方式，將Water類的實例化移到Fish外面：

    /// <summary>
    /// 魚
    /// </summary>
    public class Fish
    {
        private Water water;
        public Fish(Water _water)
        {
            water = _water;
        }
        public void Live()
        {
            Console.WriteLine("我的生活靠：");
            water.GiveNutrition();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Water water = new RiverWater();
            Fish fish = new Fish(water);
            fish.Live();
            Console.ReadKey();
        }
    }

這樣，不論水域怎么變化，Fish 列都不需要修改了。Fish 把內部依賴的創建權力移交給了 Program 這個類中的 Main() 方法。也就是說 Fish 只關心依賴提供的功能，但並不關心依賴的創建。

這種思想其實就是 IOC，IOC 是一種新的設計模式，它對上層模塊與底層模塊進行了更進一步的解耦。控制反轉的意思是反轉了上層模塊對於底層模塊的依賴控制。比如上面代碼，Fish 不再親自創建 Water 對象，它將依賴的實例化的權力交接給了 Program。而 Program 在 IOC 中又指代了 IOC 容器 這個概念。 

IOC 模式最核心的地方就是在於依賴方與被依賴方之間，也就是上文中說的上層模塊與底層模塊之間引入了第三方，這個第三方統稱為 IOC 容器，因為 IOC 容器的介入，導致上層模塊對於它的依賴的實例化控制權發生變化，也就是所謂的控制反轉的意思。

三、依賴注入（Dependency Injection）

依賴注入(DI)，它是實現IOC的實現方式，動態地將某種依賴關系注入到對象之中。

回顧上面的例子，Fish 不在實例化創建Water，它就需要在外部（IOC 容器）賦值給它，這個賦值的動作有個專門的術語叫做注入（injection）。類似於，魚生活在魚缸里了，外接一個水龍頭，水龍頭另一頭連接着水塔，這個水塔就好比是IOC容器，魚不用關心生活在什么水里了，需要水時，打開水龍頭（注入）就好了，至於水塔里裝的是河水、井水還是海水，都不用考慮。

實現依賴注入有 3 種方式：

 1. 構造函數中注入 

    public class Fish
    {
        private Water water;
        public Fish(Water _water)
        {
            water = _water;
        }
        public void Live()
        {
            Console.WriteLine("我的生活靠：");
            water.GiveNutrition();
        }
    }

優點：在 Person 一開始創建的時候就確定好了依賴。 

缺點：后期無法更改依賴。

2. setter 方式注入 

    public class Fish
    {
        private Water water;
        public Fish()
        {
        }
        public void setWater(Water _water)
        {
            water = _water;
        }
        public void Live()
        {
            if (water != null)
            {
                Console.WriteLine("我的生活靠：");
                water.GiveNutrition();
            }
        }
    }

優點：Fish 對象在運行過程中可以靈活地更改依賴。 

缺點：Fish 對象運行時，可能會存在依賴項為 null 的情況，所以需要檢測依賴項的狀態

3. 接口注入

    public class Fish : ISetWater
    {
        private Water water;
        public Fish()
        {
        }
        public void Live()
        {
            if (water != null)
            {
                Console.WriteLine("我的生活靠：");
                water.GiveNutrition();
            }
        }

        public void SetWater(Water _water)
        {
            water = _water;
        }
    }

    public interface ISetWater
    {
        void SetWater(Water water);
    }

這種方式和 Setter 方式很相似，接口的存在，表明了一種依賴配置的能力。比如，魚有 活魚和死魚，接口注入方式，我們就可以控制，只給活魚注入配置。

四、總結

1. 依賴倒置是面向對象開發領域中的軟件設計原則，它倡導上層模塊不依賴於底層模塊，抽象不依賴細節。
2. 依賴反轉是遵守依賴倒置這個原則而提出來的一種設計模式，它引入了 IoC 容器的概念。
3. 依賴注入是為了實現依賴反轉的一種手段之一。
4. 它們的本質是為了代碼更加的“高內聚,低耦合”。