在线免费观看日韩中文字幕,四虎亚洲精品高清在线观看,顶级嫩模一区二区三区

摘要：在深入細節之前，需要確保我們理解"IOC控制反轉"和"DI依賴注入"是什么，能夠解決什么問題，這些在維基百科中有非常清晰的說明。控制反轉（Inversion of Control，縮寫為IoC）：是面向對象編程中的一種設計原則，可以用來減低計算機代碼之間的耦合度..

在深入細節之前，需要確保我們理解"IOC控制反轉"和"DI依賴注入"是什么，能夠解決什么問題，這些在維基百科中有非常清晰的說明。

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

依賴注入（Dependency Injection，簡稱DI）：DI是IOC的一種實現，表現為：在類A的實例創建過程中即創建了依賴的B對象，通過類型或名稱來判斷將不同的對象注入到不同的屬性中。

依賴注入和控制反轉說的實際上是同一個東西，它們是一種設計模式，這種設計模式用來減少程序間的耦合，依賴注入是從應用程序的角度在描述，可以把依賴注入，即：應用程序依賴容器創建并注入它所需要的外部資源，

而控制反轉是從容器的角度在描述，即：容器控制應用程序，由容器反向的向應用程序注入應用程序所需要的外部資源。

優勢（為什么使用）

使用依賴注入，最重要的一點好處就是有效的分離了對象和它所需要的外部資源，使得它們松散耦合，有利于功能復用，更重要的是使得程序的整個體系結構變得非常靈活。

看個例子：

class A
{
    public $b;
    public $c;
    public function A()
    {
        //TODO
    }
    public function Method()
    {
        $this->b=new B();
        $this->c=new C();
         
        $this->b->Method();
        $this->c->Method();
         
        //TODO
    }
}
 
class B
{
    public function B()
    {
        //TODO
    }
    public function Method()
    {
        //TODO
        echo 'b';
    }
}
 
class C
{
    public function C()
    {
        //TODO
    }
    public function Method()
    {
        //TODO
        echo 'c';
    }
}
 
$a=new A();
$a->Method();

上面代碼，我們很容易理解一句話：

A類依賴B類和C類

也就是說，如果今后開發過程中，要對B類或者C類修改，一旦涉及函數改名，函數參數數量變動，甚至整個類結構的調整，我們也要對A類做出相應的調整，A類的獨立性喪失了，這在開發過程中是很不方便的，也就是我們說的“牽一發動全身”，如果兩個類是兩個人分別寫的，矛盾往往就在這個時候產生了。。。

萬一真的要改動B類和C類，有沒有辦法，可以不去改動或者盡量少改動A類的代碼呢？這里要用到控制反轉。

高層模塊不應該依賴于底層模塊，兩個都應該依賴抽象。

控制反轉（IOC）是一種思想，依賴注入（DI）是實施這種思想的方法。

第一種方法叫做：構造器注入（這種方法也不推薦用，但比不用要好）

class A
{
    public $b;
    public $c;
    public function A($b,$c)
    {
        $this->b=$b;
        $this->c=$c;
    }
    public function Method()
    {
        $this->b->Method();
        $this->c->Method();
    }
}

客戶端類這樣寫：

$a=new A(new B(),new C());
$a->Method();

A類的構造器依賴B類和C類，通過構造器的參數傳入，至少實現了一點，就是B類對象b和C類對象c的創建都移至了A類外，所以一旦B類和C類發生改動，A類無需做修改，只要在client類里改就可以了

假如有一天，我們需要擴充B類，做兩個B類的子類:

class B
{
    public function B()
    {
        //TODO
    }
    public function Method()
    {
        //TODO
        echo 'b';
    }
}
class B1 extends B
{
    public function B1()
    {
        //TODO
    }
    public function Method()
    {
        echo 'b1';
    }
}
class B2 extends B
{
    public function B2()
    {
        //TODO
    }
    public function Method()
    {
        echo 'b2';
    }
}

也很簡單，客戶端類這么寫：

$a=new A(new B2(),new C());
$a->Method();

所以A類是不用關心B類到底有哪些個子類的，只要在客戶端類關心就可以了。

第二種方法叫做：工廠模式注入（推薦使用）

class Factory
{
    public function Factory()
    {
        //TODO
    }
    public function create($s)
    {
        switch($s)
        {
            case 'B':
            {
                return new B();
                break;
            }
            case 'C':
            {
                return new C();
                break;
            }
            default:
            {
                return null;
                break;
            }
        }
    }
}

我們A類代碼改為：

class A
{
    public $b;
    public $c;
    public function A()
    {
        //TODO
    }
    public function Method()
    {
        $f=new Factory();
        $this->b=$f->create('B');
        $this->c=$f->create('C');
         
        $this->b->Method();
        $this->c->Method();
         
        //TODO
    }
}

其實已經解耦了一小部分，至少如果B類和C類的構造函數要是發生變化，比如修改函數參數等，我們只需要改Factory類就可以了。

抽象不應該依賴于細節，細節應該依賴于抽象。

把B類和C類中的方法再抽象出來，做一個接口：

interface IMethod
{
    public function Method();
}

這樣，A類中的b變量和b變量和c變量就不再是一個具體的變量了，而是一個抽象類型的變量，不到運行那一刻，不知道他們的Method方式是怎么實現的。

class B implements IMethod
{
    public function B()
    {
        //TODO
    }
    public function Method()
    {
        //TODO
        echo 'b';
    }
}
 
class C implements IMethod
{
    public function C()
    {
        //TODO
    }
    public function Method()
    {
        //TODO
        echo 'c';
    }
}