PHP程序員如何理解依賴注入容器(dependency injection container)

Coding01 發布于2019-06-27 10:58 / 697人閱讀

摘要：代碼這就是控制反轉模式。是變量有默認值則設置默認值是一個類，遞歸解析有默認值則返回默認值從容器中取得以上代碼的原理參考官方文檔反射，具有完整的反射，添加了對類接口函數方法和擴展進行反向工程的能力。

PHP程序員如何理解依賴注入容器(dependency injection container) 背景知識

傳統的思路是應用程序用到一個Foo類，就會創建Foo類并調用Foo類的方法，假如這個方法內需要一個Bar類，就會創建Bar類并調用Bar類的方法，而這個方法內需要一個Bim類，就會創建Bim類，接著做些其它工作。

    // 代碼【1】
    class Bim
    {
        public function doSomething()
        {
            echo __METHOD__, "|";
        }
    }
    
    class Bar
    {
        public function doSomething()
        {
            $bim = new Bim();
            $bim->doSomething();
            echo __METHOD__, "|";
        }
    }
    
    class Foo
    {
        public function doSomething()
        {
            $bar = new Bar();
            $bar->doSomething();
            echo __METHOD__;
        }
    }
    
    $foo = new Foo();
    $foo->doSomething(); //Bim::doSomething|Bar::doSomething|Foo::doSomething

使用依賴注入的思路是應用程序用到Foo類，Foo類需要Bar類，Bar類需要Bim類，那么先創建Bim類，再創建Bar類并把Bim注入，再創建Foo類，并把Bar類注入，再調用Foo方法，Foo調用Bar方法，接著做些其它工作。

    // 代碼【2】
    class Bim
    {
        public function doSomething()
        {
            echo __METHOD__, "|";
        }
    }
    
    class Bar
    {
        private $bim;
    
        public function __construct(Bim $bim)
        {
            $this->bim = $bim;
        }
    
        public function doSomething()
        {
            $this->bim->doSomething();
            echo __METHOD__, "|";
        }
    }
    
    class Foo
    {
        private $bar;
    
        public function __construct(Bar $bar)
        {
            $this->bar = $bar;
        }
    
        public function doSomething()
        {
            $this->bar->doSomething();
            echo __METHOD__;
        }
    }
    
    $foo = new Foo(new Bar(new Bim()));
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething

這就是控制反轉模式。依賴關系的控制反轉到調用鏈的起點。這樣你可以完全控制依賴關系，通過調整不同的注入對象，來控制程序的行為。例如Foo類用到了memcache，可以在不修改Foo類代碼的情況下，改用redis。

使用依賴注入容器后的思路是應用程序需要到Foo類，就從容器內取得Foo類，容器創建Bim類，再創建Bar類并把Bim注入，再創建Foo類，并把Bar注入，應用程序調用Foo方法，Foo調用Bar方法，接著做些其它工作.

總之容器負責實例化，注入依賴，處理依賴關系等工作。

代碼演示依賴注入容器 (dependency injection container)

通過一個最簡單的容器類來解釋一下，這段代碼來自 Twittee

    class Container
    {
        private $s = array();
    
        function __set($k, $c)
        {
            $this->s[$k] = $c;
        }
    
        function __get($k)
        {
            return $this->s[$k]($this);
        }
    }

這段代碼使用了魔術方法，在給不可訪問屬性賦值時，__set() 會被調用。讀取不可訪問屬性的值時，__get() 會被調用。

    $c = new Container();
    
    $c->bim = function () {
        return new Bim();
    };
    $c->bar = function ($c) {
        return new Bar($c->bim);
    };
    $c->foo = function ($c) {
        return new Foo($c->bar);
    };
    
    // 從容器中取得Foo
    $foo = $c->foo;
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething

這段代碼使用了匿名函數

再來一段簡單的代碼演示一下，容器代碼來自simple di container

    class IoC
    {
        protected static $registry = [];
    
        public static function bind($name, Callable $resolver)
        {
            static::$registry[$name] = $resolver;
        }
    
        public static function make($name)
        {
            if (isset(static::$registry[$name])) {
                $resolver = static::$registry[$name];
                return $resolver();
            }
            throw new Exception("Alias does not exist in the IoC registry.");
        }
    }
    
    IoC::bind("bim", function () {
        return new Bim();
    });
    IoC::bind("bar", function () {
        return new Bar(IoC::make("bim"));
    });
    IoC::bind("foo", function () {
        return new Foo(IoC::make("bar"));
    });
    
    
    // 從容器中取得Foo
    $foo = IoC::make("foo");
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething

這段代碼使用了后期靜態綁定

依賴注入容器 (dependency injection container) 高級功能

真實的dependency injection container會提供更多的特性，如

自動綁定（Autowiring）或自動解析（Automatic Resolution）

注釋解析器（Annotations）

延遲注入（Lazy injection）

下面的代碼在Twittee的基礎上，實現了Autowiring。

    class Bim
    {
        public function doSomething()
        {
            echo __METHOD__, "|";
        }
    }
    
    class Bar
    {
        private $bim;
    
        public function __construct(Bim $bim)
        {
            $this->bim = $bim;
        }
    
        public function doSomething()
        {
            $this->bim->doSomething();
            echo __METHOD__, "|";
        }
    }
    
    class Foo
    {
        private $bar;
    
        public function __construct(Bar $bar)
        {
            $this->bar = $bar;
        }
    
        public function doSomething()
        {
            $this->bar->doSomething();
            echo __METHOD__;
        }
    }
    
    class Container
    {
        private $s = array();
    
        public function __set($k, $c)
        {
            $this->s[$k] = $c;
        }
    
        public function __get($k)
        {
            // return $this->s[$k]($this);
            return $this->build($this->s[$k]);
        }
    
        /**
         * 自動綁定（Autowiring）自動解析（Automatic Resolution）
         *
         * @param string $className
         * @return object
         * @throws Exception
         */
        public function build($className)
        {
            // 如果是匿名函數（Anonymous functions），也叫閉包函數（closures）
            if ($className instanceof Closure) {
                // 執行閉包函數，并將結果
                return $className($this);
            }
    
            /** @var ReflectionClass $reflector */
            $reflector = new ReflectionClass($className);
    
            // 檢查類是否可實例化, 排除抽象類abstract和對象接口interface
            if (!$reflector->isInstantiable()) {
                throw new Exception("Can"t instantiate this.");
            }
    
            /** @var ReflectionMethod $constructor 獲取類的構造函數 */
            $constructor = $reflector->getConstructor();
    
            // 若無構造函數，直接實例化并返回
            if (is_null($constructor)) {
                return new $className;
            }
    
            // 取構造函數參數,通過 ReflectionParameter 數組返回參數列表
            $parameters = $constructor->getParameters();
    
            // 遞歸解析構造函數的參數
            $dependencies = $this->getDependencies($parameters);
    
            // 創建一個類的新實例，給出的參數將傳遞到類的構造函數。
            return $reflector->newInstanceArgs($dependencies);
        }
    
        /**
         * @param array $parameters
         * @return array
         * @throws Exception
         */
        public function getDependencies($parameters)
        {
            $dependencies = [];
    
            /** @var ReflectionParameter $parameter */
            foreach ($parameters as $parameter) {
                /** @var ReflectionClass $dependency */
                $dependency = $parameter->getClass();
    
                if (is_null($dependency)) {
                    // 是變量,有默認值則設置默認值
                    $dependencies[] = $this->resolveNonClass($parameter);
                } else {
                    // 是一個類，遞歸解析
                    $dependencies[] = $this->build($dependency->name);
                }
            }
    
            return $dependencies;
        }
    
        /**
         * @param ReflectionParameter $parameter
         * @return mixed
         * @throws Exception
         */
        public function resolveNonClass($parameter)
        {
            // 有默認值則返回默認值
            if ($parameter->isDefaultValueAvailable()) {
                return $parameter->getDefaultValue();
            }
    
            throw new Exception("I have no idea what to do here.");
        }
    }
    
    // ----
    $c = new Container();
    $c->bar = "Bar";
    $c->foo = function ($c) {
        return new Foo($c->bar);
    };
    // 從容器中取得Foo
    $foo = $c->foo;
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething
    
    // ----
    $di = new Container();
    
    $di->foo = "Foo";
    
    /** @var Foo $foo */
    $foo = $di->foo;
    
    var_dump($foo);
    /*
    Foo#10 (1) {
      private $bar =>
      class Bar#14 (1) {
        private $bim =>
        class Bim#16 (0) {
        }
      }
    }
    */
    
    $foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething

以上代碼的原理參考PHP官方文檔：反射，PHP 5 具有完整的反射 API，添加了對類、接口、函數、方法和擴展進行反向工程的能力。此外，反射 API 提供了方法來取出函數、類和方法中的文檔注釋。

若想進一步提供一個數組訪問接口，如$di->foo可以寫成$di["foo"]，則需用到ArrayAccess（數組式訪問）接口。

一些復雜的容器會有許多特性，下面列出一些相關的github項目，歡迎補充。

參考代碼

Twittee

simple di container

Pimple

PHP-DI

Ding

推薦閱讀

PHP程序員如何理解IoC/DI

PHP之道

PHP最佳實踐

云服務器 GPU云服務器依賴注入依賴注入方式 js依賴注入構造函數依賴注入

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/20882.html

PHP程序員如何理解IoC/DI

摘要：依賴注入容器管理應用程序中的全局對象包括實例化處理依賴關系。為了解決這樣的問題，我們再次回到全局注冊表創建組件。參考文章程序員如何理解依賴注入容器補充很多代碼背后，都是某種哲學思想的體現。思想思想是解決問題的根本思想必須轉換成習慣構建一套完整的思想體系是開發能力成熟的標志——《簡單之美》（前言） . 成功的軟件項目就是那些提交產物達到或超出客戶的預期的項目，而且開發過程符合時間和費...

DataPipeline 2019-06-27 10:59 評論0 收藏0
Laravel Dependency Injection (依賴注入) 概念詳解

摘要：依賴注入并不限于構造函數作為經驗，注入最適合必須的依賴關系，比如示例中的情況注入最適合可選依賴關系，比如緩存一個對象實例。本文翻譯自 Symfony 作者 Fabien Potencier 的《Dependency Injection in general and the implementation of a Dependency Injection Container in P...

Fundebug 2019-06-28 13:55 評論0 收藏0
Yii2中的依賴注入

摘要：構造器注入實現特定參數的構造函數，在新建對象時傳入所依賴類型的對象。基本概念 1.依賴倒置（反轉）原則（DIP）：一種軟件架構設計的原則（抽象概念，是一種思想）在面向對象編程領域中，依賴反轉原則（Dependency inversion principle，DIP）是指一種特定的解耦（傳統的依賴關系創建在高層次上，而具體的策略設置則應用在低層次的模塊上）形式，使得高層次的模塊不依賴于...

harriszh 2019-06-28 13:31 評論0 收藏0
Laravel Container (容器) 概念詳解 (上)

摘要：上文書，創建對象需要先創建對象。創建對象的雜活是嵌入在中的。對象使用來管理依賴關系非常好，但不是必須的。很容易實現，但手工維護各種亂七八糟的對象還是很麻煩。所有文章均已收錄至項目。本文翻譯自 Symfony 作者 Fabien Potencier 的《Dependency Injection in general and the implementation of a Depend...

FullStackDeveloper 2019-06-28 13:54 評論0 收藏0
深入剖析 Laravel 服務容器

摘要：劃下重點，服務容器是用于管理類的依賴和執行依賴注入的工具。類的實例化及其依賴的注入，完全由服務容器自動的去完成。本文首發于深入剖析 Laravel 服務容器，轉載請注明出處。喜歡的朋友不要吝嗇你們的贊同，謝謝。之前在深度挖掘 Laravel 生命周期一文中，我們有去探究 Laravel 究竟是如何接收 HTTP 請求，又是如何生成響應并最終呈現給用戶的工作原理。本章將帶領大...

abson 2019-07-01 10:00 評論0 收藏0