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

時間 2021-08-13

標籤 php html ide 函數 post this atom spa code htm 欄目 PHP 简体版

原文原文鏈接

先看一個例子：php

<?php
 
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();
 
?>

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

A類依賴B類和C類ide

也就是說，若是從此開發過程當中，要對B類或者C類修改，一旦涉及函數更名，函數參數數量變更，甚至整個類結構的調整，咱們也要對A類作出相應的調整，A類的獨立性喪失了，這在開發過程當中是很不方便的，也就是咱們說的「牽一髮動全身」，若是兩個類是兩我的分別寫的，矛盾每每就在這個時候產生了。。。函數

萬一真的要改動B類和C類，有沒有辦法，能夠不去改動或者儘可能少改動A類的代碼呢？這裏要用到控制反轉。post

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

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

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

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類裏改就能夠了code

假若有一天，咱們須要擴充B類，作兩個B類的子類htm

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類代碼改成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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變量和

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';
    }
}