我曾想深刻了解的：依賴倒置、控制反轉、依賴注入

時間 2020-02-15

標籤深刻瞭解依賴倒置控制反轉注入欄目設計模式简体版

原文原文鏈接

大道至簡

咱們在軟件工程中進行的架構設計、模塊實現、編碼等工做，不少時候說到底就是圍繞一件事進行：解耦。編程

三層架構，MVC，微服務，DDD.咱們分析問題，抽象問題，而後劃分邊界，劃分層次。設計模式

也是爲了讓咱們的類、模塊、系統有更強的複用能力，提升生產效率。架構

這一次，我想深刻了解和探討我曾經很迷糊，也沒有一直仔細瞭解的：依賴倒置、控制反轉、依賴注入這些概念。mvc

什麼是依賴？

一般能夠理解爲一種須要，需求。須要協助才能完成一件事情。

例如，咱們依賴日誌服務寫日誌：框架

public class Contract
    {
       public void Successed()
        {
            string msg = "save, successed!";
            Log log = new Log();
            log.Write(msg);
        }
    }

Contract類正依賴Log類，協助完成整個業務流程。這就產生了依賴。函數

什麼是抽象？什麼是細節？

咱們常常會據說，面向接口編程，依賴於抽象不能依賴於具體實現細節。微服務

咱們每次修改接口時候，必定會去修改具體實現。可是咱們修改具體實現卻不多修改接口。編碼

因此接口比具體實現更穩定。架構設計

此時，咱們在中間加入一層接口，看看如何。設計

public interface ILog
    {
        void Write();
    }

public void Successed()
     {
         string msg = "save, successed!";
         
         ILog log = new Log();
         log.Write(msg );
     }

關係變化如圖：

什麼是上層模塊？什麼是底層模塊？

此時，Contract類能夠看作上層。Log看作底層。

上層模塊：指揮控制

底層模塊：策略實現

依賴倒置

理清楚了上層、底層、細節、抽象、依賴概念，

咱們不難發現，上面的依賴箭頭髮生了改變。

因此依賴倒置也由此而來：

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

依賴倒置，使得咱們的擴展性加強。

public class Log:ILog
public class NLog : ILog
public class Log4 : ILog

// ILog log = new Log();
// ILog log = new Log4();
ILog log = new NLog();
log.Write(msg);

以上代碼咱們也能夠看出，咱們須要不斷註釋修改Contract類，以致於引用不一樣的Log組件來應對需求。

每次都要修改這個類來知足需求(修改關閉，擴展開放原則)，顯然是咱們所不但願的。形成這種現象的緣由是：

由於對於上層的Contract類，不只僅負責業務邏輯的實現，第二職責還要負責日誌實例的構造。

對於Program類，有日誌服務類直接拿來使用便可，不須要關心這些實例的構造。

有沒有一種機制可以將構造和使用進行分離？使得Contract的職責更加單一，耦合更低？（單一職責原則）

控制反轉

怎麼算是控制反轉了呢？

咱們改一下上面的代碼將日誌類的實例化控制權，轉移到類的外部：

public class Contract
    {
      public Contract(ILog log)
    }

調用

class Program
    {
        static void Main(string[] args)
        {
            ILog log = new NLog();
            Contract contract = new Contract(log);
            contract.Successed();
        }
    }

這樣，不管外部日誌組件如何變化，都不用會影響現有的Contract類。

Contract只專一於屬於本身的職責。上層Contract類和日誌類解耦更加完全。互不影響。

若是從職責角度來看，咱們是否是能夠有一個類專門來管理建立日誌類呢？

就像倉庫管理員同樣，根據單子出貨，不須要關心這些貨物到底如何被使用的。

public static class Ioc
    {
        public static ILog GetLogInstance(int type)
        {
            switch (type)
            {
                case 1: return new Log();
                case 2: return new Log4();
                case 3: return new NLog();
                default: return new Log();
            }
        }
    }

class Program
    {
        static void Main(string[] args)
        {           
            ILog log = Ioc.GetLogInstance(1);
            Contract contract = new Contract(log);
            contract.Successed();
        }
    }

依賴注入

什麼是依賴注入呢？

其實咱們剛剛已經實現過了，全文先是依賴倒置，而後控制反轉，而如今說的依賴注入是控制反轉的具體實現方式。

依賴注入是解開依賴並實現反轉的一種手段。

大約分爲三種方式：

構造函數方式

public class Contract
    {
        private ILog _log { get; set; }
        public Contract(ILog log)
        {
            _log = log;
        }
    }

優勢: 構造Contract就肯定好依賴。
缺點：後期沒法更改依賴。

Set方式注入

public class Contract
    {
        private ILog _log { get; set; }
        public Contract(ILog log)
        {
            _log = log;
        }
        public void Successed()
        {
            string msg = "save, successed!";
            _log.Write(msg);
        }

        public void SetLogInstance(ILog log)
        {
            _log = log;
        }
    }

優勢: 將Log實例化延遲，Contract類能夠靈活變更依賴。
缺點：使用_log前須要判斷null狀況

接口方式注入

public interface ILogSetter
    {
        ILog Setter(ILog log);
    }

public class Contract: ILogSetter
    {
        ... ...
        public ILog Setter(ILog log)
        {
            _log = log;
            return _log;
        }
    }

接口方式和方式二有點相似，這裏將依賴注入提高爲一種能力，能夠支配依賴關係的能力。