2. 程式人生 > 實用技巧 >03依賴注入--01控制反轉、IoC模式

03依賴注入--01控制反轉、IoC模式

阿新 • • 發佈：2020-10-14

控制反轉Inversion of Control

DI和IoC幾乎都是成對出現的，我們在理解依賴注入之前首先要弄明白什麼是IoC，也就是控制反轉，體現的就是控制權的轉移，即控制權原來在A中，現在需要B來接管。那麼在軟體中是如何實現的。通過一個例子來說明傳統設計在採用IoC之後是如何實現反轉的。

我們模擬了一個http請求流程，由其中5個核心任務組成。

namespace IoCDemo
{
  class Program
  {
    static async Task Main()
    {
      while (true)
      {
        var address = new Uri("http://127.0.0.1:8080/api/test");
        await MvcLib.ListenAsync(address);
        while (true)
        {
          var request = await MvcLib.ReceiceAsync();
          var controller = await MvcLib.CreateControllerAsync(request);
          var view = await MvcLib.ExecuteControllerAsync(controller);
          await MvcLib.RenderViewAsync(view);
        }
      }
    }
  }
  public static class MvcLib
  {
    /// <summary>
    /// 啟動一個監聽器並將其繫結到指定的地址進行http請求的監聽
    /// </summary>
    /// <param name="address"></param>
    /// <returns></returns>
    public static Task ListenAsync(Uri address)
    {
      return Task.CompletedTask;
    }
    /// <summary>
    /// 接收抵達的請求
    /// </summary>
    /// <returns>接收到的請求</returns>
    public static Task<HttpContext> ReceiceAsync()
    {
      return Task.FromResult(new HttpContext());
    }
    /// <summary>
    /// 根據接收的請求解析並激活目標Controller物件
    /// </summary>
    /// <param name="request"></param>
    /// <returns>啟用的Controller物件</returns>
    public static Task<Controller> CreateControllerAsync(HttpContext request)
    {
      return Task.FromResult(new Controller());
    }
    /// <summary>
    /// 執行啟用的物件Controller，返回檢視
    /// </summary>
    /// <param name="controller"></param>
    /// <returns>表示檢視的物件</returns>
    public static Task<View> ExecuteControllerAsync(Controller controller)
    {
      return Task.FromResult(new View());
    }
    /// <summary>
    /// 將檢視裝換成html請求
    /// </summary>
    /// <param name="view"></param>
    /// <returns></returns>
    public static Task RenderViewAsync(View view)
    {
      return Task.CompletedTask;
    }
  }
  public class View
  {
  }
  public class Controller
  {
  }
  public class HttpContext
  {
  }
}

上面的程式碼中，類庫MvcLib僅僅通過api的形式提供單一功能的實現，http請求的工作流是在應用程式中進行了實現。但是所有的http請求都是這個工作流，也就是說這個工作流沒有得到重用。那麼我們可以通過一個框架（Framework）來實現工作流，以達到工作流複用的目的。那麼應用程式只需要複用框架即可。這裡面就是將對工作流的控制放到了框架中，而不是應用程式自己來控制，這個過程其實就是將工作流的控制權從應用程式交到了框架中，也就實現了控制反轉。
如果我們將一個工作流程定義在框架中（A→B→C），建立在框架基礎上的兩個應用程式App1和App2需要對這個工作流進行自定義。框架驅動工作流自動執行，並且會按照執行前自定義好的工作流內容進行執行。

綜上，IoC一方面通過流程控制從應用程式向框架反轉，實現了針對流程的重用，另一方面通過內建的擴充套件機制是這個被重用的流程能夠自由的被定製。

IoC模式

IoC被視為一種設計原則，在很多設計模式中都有所體現。

模板方法

將一個可複用的工作流程或者由多個步驟組成的演算法定義成模板方法，組成這個流程或者演算法的單一步驟則在響應的虛方法中實現，模板方法根據預先編排的流程呼叫這些虛方法。這些方法均定義在一個類中，可以通過派生類並重寫響應的虛方法的方式達到對流程定製的目的。

#region 模板方法
/// <summary>
/// 將整個執行流程放到類中，在類中分別定義了5個虛方法。
/// 模板方法StartAsync根據預定義的請求處理流程先後呼叫這5個方法。
/// 在具體的應用場景中，只需要例項化MvcEngine，並呼叫StartAsync方法就可以滿足基本要求
/// </summary>
public class MvcEngine
{
  public async Task StartAsync(Uri address)
  {
    await ListenAsync(address);
    while (true)
    {
      var request = await ReceiceAsync();
      var controller = await CreateControllerAsync(request);
      var view = await ExecuteControllerAsync(controller);
      await RenderViewAsync(view);
    }
  }

  protected virtual Task ListenAsync(Uri address) => Task.CompletedTask;
  protected virtual Task<HttpContext> ReceiceAsync() => Task.FromResult(new HttpContext());
  protected virtual Task<Controller> CreateControllerAsync(HttpContext request) => Task.FromResult(new Controller());
  protected virtual Task<View> ExecuteControllerAsync(Controller controller) => Task.FromResult(new View());
  protected virtual Task RenderViewAsync(View view) => Task.CompletedTask;
}
/// <summary>
/// 如果請求環節無法滿足應用場景，可以建立派生類，並重寫某個環節的虛方法即可。
/// </summary>
public class FoobarMvcEngine : MvcEngine
{
  protected override Task<Controller> CreateControllerAsync(HttpContext request)
  {
    //此處省略了擴充套件實現
   
    return Task.FromResult(new Controller());
  }
}
#endregion

工廠方法

對於一個複雜的流程，可以將組成流程的各個環節實現在響應的元件之中，所以針對流程的定製可以通過提供響應的元件的形式來實現。工廠方法和抽象工廠都可以實現。

工廠方法就是在某個類中定義用來提供所需服務的方法，這個方法可以是一個單純的虛方法，也可以是具有預設實現的虛方法，至於方法宣告的返回型別，可以是一個介面或者抽象類，也可以是未封閉的（Sealed）具體型別。派生型別可以採用重寫工廠方法的方式提供所需的服務物件。

針對上面的MVC框架流程，將整個請求處理流程獨立成幾個核心環節，核心環節對應不同的介面。

#region 工廠方法

/// <summary>
/// 監聽、接收和響應請求
/// </summary>
public interface IWebListener
  {
    Task ListenAsync(Uri address);
    Task<HttpContext> ReceiceAsync();
  }
public class WebListener : IWebListener
  {
    public Task ListenAsync(Uri address) => Task.CompletedTask;
    public Task<HttpContext> ReceiceAsync() => Task.FromResult(new HttpContext());
  }

/// <summary>
/// 根據當前上下文啟用目標Controller物件，並做一些釋放回收的工作
/// </summary>
public interface IControllerActivator
  {
    Task<Controller> CreateControllerAsync(HttpContext request);
    Task ReleaseAsync(Controller controller);
  }
public class ControllerActivator : IControllerActivator
  {
    public Task<Controller> CreateControllerAsync(HttpContext request) => Task.FromResult(new Controller());
    public Task ReleaseAsync(Controller controller) => Task.CompletedTask;
  }

/// <summary>
/// 針對Controller的執行
/// </summary>
public interface IControllerExecutor
  {
    Task<View> ExecuteAsync(Controller controller);
  }
public class ControllerExecutor : IControllerExecutor
  {
    public Task<View> ExecuteAsync(Controller controller) => Task.FromResult(new View());
  }

/// <summary>
/// 檢視的呈現
/// </summary>
public interface IViewRender
  {
    Task RenderViewAsync(View view);
  }
public class ViewRender : IViewRender
  {
    public Task RenderViewAsync(View view) => Task.CompletedTask;
  }

/// <summary>
/// 採用預設的實現，實現預定的流程
/// </summary>
public class MvcEngine1
  {
    public async Task StartAsync(Uri address)
    {
      var listener = GetWebListener();
      var controllerActivator = GetControllerActivator();
      var controllerExecutor = GetControllerExecutor();
      var viewRender = GetIViewRender();

      await listener.ListenAsync(address);
      while (true)
      {
        var request = await listener.ReceiceAsync();
        var controller = await controllerActivator.CreateControllerAsync(request);
        try
        {
          var view = await controllerExecutor.ExecuteAsync(controller);
          await viewRender.RenderViewAsync(view);
        }
        finally
        {
          await controllerActivator.ReleaseAsync(controller);
        }

      }
    }

    protected virtual IWebListener GetWebListener() => new WebListener();
    protected virtual IControllerActivator GetControllerActivator() => new ControllerActivator();
    protected virtual IControllerExecutor GetControllerExecutor() => new ControllerExecutor();
    protected virtual IViewRender GetIViewRender() => new ViewRender();
  }

/// <summary>
/// 定製化的IControllerActivator流程
/// 需要根據需要實現介面
/// </summary>
public class ControllerExActivator : IControllerActivator
  {
    public Task<Controller> CreateControllerAsync(HttpContext request)
    {
      //省略實現

      return Task.FromResult(new Controller());
    }
    public Task ReleaseAsync(Controller controller)
    {
      //省略實現

      return Task.CompletedTask;
    }
  }

/// <summary>
/// 如果請求環節無法滿足應用場景，可以建立派生類，並重寫某個環節的工廠方法即可。
/// </summary>
public class FoobarMvcEngine1 : MvcEngine1
  {
    protected override IControllerActivator GetControllerActivator()
    {
      return new ControllerExActivator();
    }
  }

#endregion

抽象工廠

工廠方法和抽象工廠都能夠生產物件例項，但是兩者本質上有區別。工廠方法利用定義在某個型別的抽象方法或者虛方法完成針對單一物件的提供，而抽象工廠是利用一個獨立的介面或者抽象類提供一組相關的物件。

定義了一個獨立的工廠介面或者抽象工廠類，並在其中定義多個工廠方法來提供多個相關物件。如果希望抽象工廠具有一組預設的輸出，可以將一個未封閉的型別作為抽象工廠，以虛方法的形式定義預設實現來返回物件。在具體的開發中，可以實現工廠介面或者繼承抽象工廠類，來實現具體的工廠類，然後提供一系列物件。

#region 抽象工廠

/// <summary>
/// 抽象工廠會建立多個例項
/// </summary>
public interface IMvcEngineFactory
  {
    IWebListener GetWebListener();
    IControllerActivator GetControllerActivator();
    IControllerExecutor GetControllerExecutor();
    IViewRender GetIViewRender();
  }
/// <summary>
/// 預設實現
/// </summary>
public class MvcEngineFactory : IMvcEngineFactory
  {
    public virtual IWebListener GetWebListener() => new WebListener();
    public virtual IControllerActivator GetControllerActivator() => new ControllerActivator();
    public virtual IControllerExecutor GetControllerExecutor() => new ControllerExecutor();
    public virtual IViewRender GetIViewRender() => new ViewRender();
  }

/// <summary>
/// 採用預設的實現，實現預定的流程
/// </summary>
public class MvcEngine2
  {
    public IMvcEngineFactory _engineFactory { get; }

    public MvcEngine2(IMvcEngineFactory engineFactory)
    {
      _engineFactory = engineFactory ?? new MvcEngineFactory();
    }

    public async Task StartAsync(Uri address)
    {
      var listener = _engineFactory.GetWebListener();
      var controllerActivator = _engineFactory.GetControllerActivator();
      var controllerExecutor = _engineFactory.GetControllerExecutor();
      var viewRender = _engineFactory.GetIViewRender();

      await listener.ListenAsync(address);
      while (true)
      {
        var request = await listener.ReceiceAsync();
        var controller = await controllerActivator.CreateControllerAsync(request);
        try
        {
          var view = await controllerExecutor.ExecuteAsync(controller);
          await viewRender.RenderViewAsync(view);
        }
        finally
        {
          await controllerActivator.ReleaseAsync(controller);
        }

      }
    }
  }

/// <summary>
/// 如果請求環節無法滿足應用場景，可以建立派生類，並重寫某個環節的虛方法即可。
/// </summary>
public class FoobarMvcEngineFactory : MvcEngineFactory
  {
    public override IControllerActivator GetControllerActivator()
    {
      return new ControllerExActivator();
    }
  }



#endregion

相關推薦

03依賴注入--01控制反轉、IoC模式

控制反轉Inversion of Control DI和IoC幾乎都是成對出現的，我們在理解依賴注入之前首先要弄明白什麼是IoC，也就是控制反轉，體現的就是控制權的轉移，即控制權原來在A中，現在需要B來接管。那麼在軟體中是如何實現

RESTful日#2:使用Unity容器和載入程式在Web api中使用依賴注入實現控制反轉

下載databasescript.zip - 1 KB 下載PdfArticle.zip - 3 MB 下載WebApiSourceCodeDay1 - 4 MB 下載WebApi.zip source code - 4.4 MB

為什麼使用依賴注入和控制反轉

控制反轉（Inversion of Control，縮寫為IoC），是面向物件程式設計中的一種設計原則，可以用來減低計算機程式碼之間的耦合度。

依賴注入和控制反轉

控制反轉（IOC） Ioc意味著將你設計好的物件交給容器控制，而不是傳統的在你的物件內部直接控制

簡單實現Spring依賴注入以及控制反轉

執行流程 從上一章分析可得，spring建立bean的流程如下所示 獲取class資訊 -> 根據class資訊呼叫構造方法建立物件 -> 判斷成員變數中是否有依賴注入註解並進行注入操作 -> 初始化前(@PostConstruct) ->

控制反轉、依賴注入（IOC、DI）

IOC: Inversion Of Control 控制反轉 DI:Dependency Injection 依賴注入 1.控制反轉 Inversion Of Control 的前世今生

控制反轉（IOC）與依賴注入（DI）--第三方Autofac的.NET IoC框架使用

一、簡介： 1、什麼是控制反轉（IOC） Ioc—Inversion of Control，即“控制反轉”，不是什麼技術，而是一種設計思想。傳統程式設計，我們直接在邏輯層通過new進行建立物件，是程式主動去建立依賴物件；而IoC是有專門

spring——spring——控制反轉（IoC）——依賴注入（DI） （轉載）

IoC 是 Inversion of Control 的簡寫，譯為“控制反轉”，它不是一門技術，而是一種設計思想，是一個重要的面向物件程式設計法則，能夠指導我們如何設計出鬆耦合、更優良的程式。

spring——控制反轉（IoC）—— 與 ——依賴注入（DI）

控制反轉（IoC） 在傳統的 Java 應用中，一個類想要呼叫另一個類中的屬性或方法，通常會先在其程式碼中通過 new Object() 的方式將後者的物件創建出來，然後才能實現屬性或方法的呼叫。

Spring5入門-03-依賴注入和配置的一些細節(bean、陣列、list、map、set、properties)

一、前言 參考視訊：遇見狂神說-Spring5 參考文件：官方文件 使用： IDEA 2019.3 Maven

Spring基礎，控制反轉（IOC），理論堆導，初始beans.xml(使用Spring建立物件)

1，IOC的理論推導（非常重要） 　　前言：ioc是Spring框架的核心思想，不去理解它就去學習Spring，那是不明智的選擇

Spring的控制反轉（IoC）容器 (一）

一、Spring IoC容器和Bean簡介 　　IoC也稱為依賴注入（DI）。在此過程中，物件僅通過建構函式引數，工廠方法的引數或在構造或從工廠方法返回後在物件例項上設定的屬性來定義其依賴項（即，與它們一起使用的其他物件

Spring的控制反轉（IoC）容器 (三）

六、自動裝配 1、介紹 自動裝配是使用spring滿足bean依賴的一種方法 spring會在應用上下文中為某個bean尋找其依賴的bean。

控制反轉（IOC容器）-Autofac入門

注意：本文為原創文章，任何形式的轉載、引用（包括但不限於以上形式）等，須先徵得作者同意，否則一切後果自負。

Spring全解-03-依賴注入

依賴注入（DI，Dependency Injection） 依賴：指Bean物件的建立依賴於容器。 注入：指Bean物件所依賴的資源，由容器來設定和裝配。

PHP控制反轉（IOC）

控制翻轉：IOC（inversion of control）控制反轉模式；控制反轉是將對3類(元件間)的依賴關係從程式內部提到外部來管理；

【專案實踐】依賴注入用得好，設計模式隨便搞

以專案驅動學習，以實踐檢驗真知 前言 設計模式是我們程式設計道路上繞不開的一環，用好了設計模式能夠讓程式碼擁有良好的維護性、可讀性以及擴充套件性，它彷彿就是“優雅”的代名詞，各個框架和庫也都能見到它的

.NET IoC模式依賴反轉(DIP)、控制反轉(Ioc)、依賴注入(DI)

依賴倒置原則(DIP) 依賴倒置(Dependency Inversion Principle,縮寫DIP)是面向物件六大基本原則之一。他是指一種特定的的解耦形式,使得高層次的模組不依賴低層次的模組的實現細節,依賴關係被顛倒（反轉）,從而使得低

Spring5詳解（三）——認識IoC控制反轉/DI依賴注入

1、前言 我們只要提到Spring這個詞，有簡單瞭解過Spring的人基本上都會脫穎而出IOC、DI和AOP這幾個概念。但是對於初學者來說，一下子搞懂IoC和DI的概念還是挺麻煩的。比如之前我自己剛剛學習Spring的時候，只知道IO

控制反轉(IoC,Inverse of Control)和依賴注入(DI,Dependedency Injection)

概念與定義 一、控制反轉 1：類與類的依賴 依賴是面向物件中用來描述類與類之間一種關係的概念。兩個相對獨立的物件，當一個物件負責構造另一個物件的例項，或者依賴另一個物件的服務，這樣的兩個物件之間主要體現為