如何理解 Laravel 的 Ioc 容器

時間  2019-11-08
標籤 如何 理解 laravel ioc 容器 简体版
原文   原文鏈接

學習laravel快小一年了，到如今纔去研究laravel 的核心 '容器 IOC' 這些概念. 寫項目的時候有大概看看關於IOC 文章， 可是沒有深刻理解，只是有個概念,趕着寫代碼， 雖然代碼也寫的很菜 · - ·php

這幾天花了點時間研究了一下laravel 的核心 ‘服務容器’ 而後理解了一下關於IOC 的概念. 不敢說百分百掌握了，可是比以前是有必定加深. 因此決定把本身理解的分享一下, 把本身的第一次博文獻給laravel. 理解不到位的還請各位大牛多多指正.laravel

1.依賴

IOC( inversion of controller )叫作控制反轉模式，也能夠稱爲(dependency injection ) 依賴注入模式。要理解依賴注入的概念咱們先理解下什麼依賴c#

//支付寶支付
class Alipay {
      public function __construct(){}

      public function pay()
      {
          echo 'pay bill by alipay';
      }
}
//微信支付
class Wechatpay {
      public function __construct(){}

      public function pay()
      {
          echo 'pay bill by wechatpay';
      }
}
//銀聯支付
class Unionpay{
      public function __construct(){}

      public function pay()
      {
          echo 'pay bill by unionpay';
      }
}

//支付帳單
class PayBill {

      private $payMethod；

      public function __construct( )
      {
          $this->payMethod= new Alipay ();
      }

      public function  payMyBill()
      {
           $this->payMethod->pay();
      }
}


$pb = new PayBill ();
$pb->payMyBill();

經過上面的代碼咱們知道,當咱們建立一個class PayBill 的實例的時候, PayBill 的構造函數裏面有{ $this->payMethod= new Alipay (); }, 也就是實例化了一個class Alipay . 這個時候依賴就產生了, 這裏能夠理解爲當我想用支付寶支付的時候, 那我首先要獲取到一個支付寶的實例,或者理解爲獲取支付寶的功能支持. 當用咱們完 new 關鍵字的時候, 依賴其實已經解決了，由於咱們獲取了Alipay 的實例. 數組

其實在我知道ioc概念以前，個人代碼中大部分都是這種模式 ~ _ ~ . 這種有什麼問題呢， 簡單來講， 好比當我想用的不是支付寶而是微信的時候怎麼辦， 你能作的就是修改Payment 的構造函數的代碼,實例化一個微信支付Wechatpay. 微信

若是咱們的程序不是很大的時候可能還感受不出什麼，可是當你的代碼很是複雜，龐大的時候，若是咱們的需求常常改變，那麼修改代碼就變的很是麻煩了。因此ioc 的思想就是不要在 class Payment 裏面用new 的方式去實例化解決依賴， 並且轉爲由外部來負責，簡單一點就是內部沒有new 的這個步驟，經過依賴注入的方式一樣的能獲取到支付的實例.閉包

2.依賴注入

依賴咱們知道了是什麼意思，那依賴注入又是什麼意思呢，咱們把上面的代碼拓展一下app

//支付類接口
interface Pay
{
    public function pay();
}


//支付寶支付
class Alipay implements Pay {
      public function __construct(){}

      public function pay()
      {
          echo 'pay bill by alipay';
      }
}
//微信支付
class Wechatpay implements Pay  {
      public function __construct(){}

      public function pay()
      {
          echo 'pay bill by wechatpay';
      }
}
//銀聯支付
class Unionpay implements Pay  {
      public function __construct(){}

      public function pay()
      {
          echo 'pay bill by unionpay';
      }
}

//付款
class PayBill {

      private $payMethod;

      public function __construct( Pay $payMethod)
      {
          $this->payMethod= $payMethod;
      }

      public function  payMyBill()
      {
           $this->payMethod->pay();
      }
}

//生成依賴
$payMethod =  new Alipay();
//注入依賴
$pb = new PayBill( $payMethod );
$pb->payMyBill();

上面的代碼中，跟以前的比較的話，咱們加入一個Pay 接口， 而後全部的支付方式都繼承了這個接口而且實現了pay 這個功能. 可能你們會問爲何要用接口，這個咱們稍後會講到.框架

當咱們實例化PayBill的以前， 咱們首先是實例化了一個Alipay，這個步驟就是生成了依賴了，而後咱們須要把這個依賴注入到PayBill 的實例當中，經過代碼咱們能夠看到 { $pb = new PayBill( payMethod ); }, 咱們是經過了構造函數把這個依賴注入了PayBill 裏面. 這樣一來 $pb 這個PayBill 的實例就有了支付寶支付的能力了. 函數

把class Alipay 的實例經過constructor注入的方式去實例化一個 class PayBill. 在這裏咱們的注入是手動注入, 不是自動的. 而Laravel 框架實現則是自動注入.學習

3.反射

在介紹IOC 的容器以前咱們先來理解下反射的概念(reflection)，由於IOC 容器也是要經過反射來實現的.從網上抄了一段來解釋反射是什麼意思

"反射它指在PHP運行狀態中，擴展分析PHP程序，導出或提取出關於類、方法、屬性、參數等的詳細信息，包括註釋。這種動態獲取的信息以及動態調用對象的方法的功能稱爲反射API。反射是操縱面向對象範型中元模型的API，其功能十分強大，可幫助咱們構建複雜，可擴展的應用。其用途如：自動加載插件，自動生成文檔，甚至可用來擴充PHP語言"

舉個簡單的例子

class B{

}


class A {

    public function __construct(B $args)
    {
    }

    public function dosomething()
    {
        echo 'Hello world';
    }
}

//創建class A 的反射
$reflection = new ReflectionClass('A');

$b = new B();

//獲取class A 的實例
$instance = $reflection ->newInstanceArgs( [ $b ]);

$instance->dosomething(); //輸出 ‘Hellow World’

$constructor = $reflection->getConstructor();//獲取class A 的構造函數

$dependencies = $constructor->getParameters();//獲取class A 的依賴類

dump($constructor);

dump($dependencies);

dump 的獲得的$constructor 和 $dependencies 結果以下

//constructor
ReflectionMethod {#351 ▼
        +name: "__construct" 
        +class: "A" 
        parameters: array:1 [▶] 
        extra: array:3 [▶] 
        modifiers: "public"
}

//$dependencies
array:1 [▼
        0 => ReflectionParameter {#352 ▼
         +name: "args"
          position: 0
          typeHint: "B"
      }
]

經過上面的代碼咱們能夠獲取到 class A 的構造函數，還有構造函數依賴的類，這個地方咱們依賴一個名字爲 'args' 的量，並且經過TypeHint能夠知道他是類型爲 Class B; 反射機制可讓我去解析一個類，能過獲取一個類裏面的屬性，方法 ，構造函數， 構造函數須要的參數。 有個了這個才能實現Laravel 的IOC 容器.

4.IOC容器

接下來介紹一下Laravel 的IOC服務容器概念. 在laravel框架中， 服務容器是整個laravel的核心，它提供了整個系統功能及服務的配置, 調用. 容器按照字面上的理解就是裝東西的東西，好比冰箱， 當咱們須要冰箱裏面的東西的時候直接從裏面拿就好了. 服務容器也能夠這樣理解， 當程序開始運行的時候，咱們把咱們須要的一些服務放到或者註冊到(bind)到容器裏面，當我須要的時候直接取出來(make)就好了. 上面提到的 bind 和 make 就是註冊 和 取出的 兩個動做.

5. IOC 容器代碼

好了，說了這麼多，下面要上一段容器的代碼了. 下面這段代碼不是laravel 的源碼， 而是來自一本書《laravel 框架關鍵技術解析》. 這段代碼很好的還原了laravel 的服務容器的核心思想. 代碼有點長， 小夥伴們要耐心看. 固然小夥伴徹底能夠試着運行一下這段代碼，而後調試一下，這樣會更有助於理解.

<?php 

//容器類裝實例或提供實例的回調函數
class Container {

    //用於裝提供實例的回調函數，真正的容器還會裝實例等其餘內容
    //從而實現單例等高級功能
    protected $bindings = [];

    //綁定接口和生成相應實例的回調函數
    public function bind($abstract, $concrete=null, $shared=false) {
        
        //若是提供的參數不是回調函數，則產生默認的回調函數
        if(!$concrete instanceof Closure) {
            $concrete = $this->getClosure($abstract, $concrete);
        }
        
        $this->bindings[$abstract] = compact('concrete', 'shared');
    }

    //默認生成實例的回調函數
    protected function getClosure($abstract, $concrete) {
        
        return function($c) use ($abstract, $concrete) {
            $method = ($abstract == $concrete) ? 'build' : 'make';
            return $c->$method($concrete);
        };
        
    }

    public function make($abstract) {
        $concrete = $this->getConcrete($abstract);

        if($this->isBuildable($concrete, $abstract)) {
            $object = $this->build($concrete);
        } else {
            $object = $this->make($concrete);
        }
        
        return $object;
    }

    protected function isBuildable($concrete, $abstract) {
        return $concrete === $abstract || $concrete instanceof Closure;
    }

    //獲取綁定的回調函數
    protected function getConcrete($abstract) {
        if(!isset($this->bindings[$abstract])) {
            return $abstract;
        }

        return $this->bindings[$abstract]['concrete'];
    }

    //實例化對象
    public function build($concrete) {

        if($concrete instanceof Closure) {
            return $concrete($this);
        }

        $reflector = new ReflectionClass($concrete);
        if(!$reflector->isInstantiable()) {
            echo $message = "Target [$concrete] is not instantiable";
        }

        $constructor = $reflector->getConstructor();
        if(is_null($constructor)) {
            return new $concrete;
        }

        $dependencies = $constructor->getParameters();
        $instances = $this->getDependencies($dependencies);

        return $reflector->newInstanceArgs($instances);
    }

    //解決經過反射機制實例化對象時的依賴
    protected function getDependencies($parameters) {
        $dependencies = [];
        foreach($parameters as $parameter) {
            $dependency = $parameter->getClass();
            if(is_null($dependency)) {
                $dependencies[] = NULL;
            } else {
                $dependencies[] = $this->resolveClass($parameter);
            }
        }

        return (array)$dependencies;
    }

    protected function resolveClass(ReflectionParameter $parameter) {
        return $this->make($parameter->getClass()->name);
    }

}

上面的代碼就生成了一個容器,下面是如何使用容器

$app = new Container();
$app->bind("Pay", "Alipay");//Pay 爲接口， Alipay 是 class Alipay
$app->bind("tryToPayMyBill", "PayBill"); //tryToPayMyBill能夠當作是Class PayBill 的服務別名

//經過字符解析，或獲得了Class PayBill 的實例
$paybill = $app->make("tryToPayMyBill"); 

//由於以前已經把Pay 接口綁定爲了 Alipay，因此調用pay 方法的話會顯示 'pay bill by alipay '
$paybill->payMyBill();

當咱們實例化一個Container獲得 $app 後， 咱們就能夠向其中填充東西了

$app->bind("Pay", "Alipay");
$app->bind("tryToPayMyBill", "PayBill");

當執行完這兩行綁定碼後, $app 裏面的屬性 $bindings 就已經有了array 值，是啥樣的呢，咱們來看下

array:2 [▼
 "App\Http\Controllers\Pay" => array:2 [▼
     "concrete" => Closure {#355 ▼
       class: "App\Http\Controllers\Container" 
       this:Container{[#354](http://127.0.0.4/ioc#sf-dump-254248394-ref2354) …} 
       parameters: array:1 [▼
         "$c" => []
       ] 
       use: array:2 [▼
         "$abstract" => "App\Http\Controllers\Pay"
        "$concrete" => "App\Http\Controllers\Alipay"
       ] 
       file: "C:\project\test\app\Http\Controllers\IOCController.php" line:       "119 to 122"
   } 
   "shared" => false 
 ]

"tryToPayMyBill" => array:2 [▼
     "concrete" => Closure {#359 ▼
         class: "App\Http\Controllers\Container" 
         this:Container{[#354](http://127.0.0.4/ioc#sf-dump-254248394-ref2354) …} 
         parameters: array:1 [▼
               "$c" => []
         ] 
         use: array:2 [▼
               "$abstract" => "tryToPayMyBill" 
               "$concrete" => "\App\Http\Controllers\PayBill"
         ] 
         file: "C:\project\test\app\Http\Controllers\IOCController.php" line: "119 to 122"
   } 
     "shared" => false 
 ]
]

當執行 $paybill = $app->make("tryToPayMyBill"); 的時候, 程序就會用make方法經過閉包函數的回調開始解析了.

解析'tryToPayBill' 這個字符串， 程序經過閉包函數 和build方法會獲得 'PayBill' 這個字符串，該字符串保存在$concrete 上. 這個是第一步. 而後程序還會以相似於遞歸方式 將$concrete 傳入 build() 方法. 這個時候build裏面就獲取了$concrete = 'PayBill'. 這個時候反射就派上了用場， 你們有沒有發現，PayBill 不就是 class PayBill 嗎? 而後在經過反射的方法ReflectionClass('PayBill') 獲取PayBill 的實例. 以後經過getConstructor()，和getParameters() 等方法知道了 Class PayBill 和 接口Pay 存在依賴

//$constructor = $reflector->getConstructor();
ReflectionMethod {#374 ▼
    +name: "__construct" 
    +class: "App\Http\Controllers\PayBill" 
    parameters: array:1 [▼
          "$payMethod" => ReflectionParameter {#371 ▼
              +name: "payMethod" 
              position: 0 typeHint: "App\Http\Controllers\Pay"
          }
    ]
     extra: array:3 [▼
          "file" => "C:\project\test\app\Http\Controllers\IOCController.php"
          "line" => "83 to 86" 
          "isUserDefined" => true 
      ] 
    modifiers: "public"
}


//$dependencies = $constructor->getParameters();
array:1 [▼
    0 => ReflectionParameter {#370 ▼
        +name: "payMethod" 
        position: 0 
        typeHint: "App\Http\Controllers\Pay"
        }
]

接着，咱們知道了有'Pay'這個依賴以後呢，咱們要作的就是解決這個依賴，經過 getDependencies($parameters)， 和 resolveClass(ReflectionParameter $parameter) ，還有以前的綁定$app->bind("Pay", "Alipay"); 在build 一次的時候，經過 return new $concrete;到這裏咱們獲得了這個Alipay 的實例

if(is_null($constructor)) {
            return new $concrete;
        }

到這裏咱們總算結局了這個依賴， 這個依賴的結果就是實例化了一個 Alipay. 到這裏還沒結束

$instances = $this->getDependencies($dependencies);

上面的$instances 數組只有一個element 那就是 Alipay 實例

array:1 [▼0 =>Alipay
      {#380}
 ]

最終經過 newInstanceArgs() 方法， 咱們獲取到了 PayBill 的實例。

return $reflector->newInstanceArgs($instances);

到這裏整個流程就結束了， 咱們經過 bind 方式綁定了一些依賴關係， 而後經過make 方法 獲取到到咱們想要的實例. 在make中有牽扯到了閉包函數，反射等概念.

好了，當咱們把容器的概念理解了以後，咱們就能夠理解下爲何要用接口這個問題了. 若是說我不想用支付寶支付，我要用微信支付怎麼辦，too easy.

$app->bind("Pay", "Wechatpay");
$app->bind("tryToPayMyBill", "PayBill");
$paybill = $app->make("tryToPayMyBill"); 
$paybill->payMyBill();

是否是很簡單呢， 只要把綁定從'Alipay' 改爲 'Wechatpay' 就好了，其餘的都不用改. 這就是爲何咱們要用接口. 只要你的支付方式繼承了pay 這個接口，而且實現pay 這個方法，咱們就可以經過綁定正常的使用. 這樣咱們的程序就很是容易被拓展，由於之後可能會出現成百上千種的支付方式.

好了，到這裏不知道小夥伴有沒有理解呢，我建議你們能夠試着運行下這些代碼, 這樣理解起來會更快.同時推薦你們去看看 《laravel 框架關鍵技術解析》這本書,寫的仍是不錯的.

轉載請註明：做者[[哎喲個人巴扎黑]

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程