理解PHP依賴注入|LaravelIoC容器-php教程-PHP中文網

　Laravel框架的依賴注入確實很強大，並且透過容器實現依賴注入可以有選擇性的加載需要的服務，減少初始化框架的開銷，下面是我在網上看到的一個帖子，寫的很好拿來與大家分享，文章從開始按照傳統的類別設計資料庫連接一直到透過容器載入服務這個高度解耦的設計展示了依賴注入的強大之處，值得我們借鑒和學習。

------------------------------------------------ -----------分割線下面是大牛的原文------------------------------- ---------------------------

　　首先，我們假設，我們要開發一個元件命名為SomeComponent。這個元件中現在將要注入一個資料庫連線。在這個例子中，資料庫連接在component中被創建，這種方法是不切實際的，這樣做的話，我們將不能改變資料庫連接參數及資料庫類型等一些參數。

1 <?php 
2  
3 class SomeComponent 
4 { 
5  
6     PRotected $_connection; 
7  
8     /** 
9      * Sets the connection externally
10      */
11     public function setConnection($connection)
12     {
13         $this->_connection = $connection;
14     }
15 
16     public function someDbTask()
17     {
18         $connection = $this->_connection;
19 
20         // ...
21     }
22
23 }
24 
25 $some = new SomeComponent();
26 
27 //Create the connection
28 $connection = new Connection(array(
29     "host" => "localhost",
30     "username" => "root",
31     "password" => "secret",
32     "dbname" => "invo"
33 ));
34 
35 //Inject the connection in the component
36 $some->setConnection($connection);
37 
38 $some->someDbTask();

登入後複製

　現在我們來考慮一個問題，我們在應用程式中的不同地方使用此元件，將多次建立資料庫連線。使用一種類似全域註冊表的方式，從這獲得一個資料庫連線實例，而不是使用一次就建立一次。

1 <?php 
2  
3 class Registry 
4 { 
5  
6     /** 
7      * Returns the connection 
8      */ 
9     public static function getConnection()
10     {
11        return new Connection(array(
12             "host" => "localhost",
13             "username" => "root",
14             "password" => "secret",
15             "dbname" => "invo"
16         ));
17     }
18 
19 }
20 
21 class SomeComponent
22 {
23 
24     protected $_connection;
25 
26     /**
27      * Sets the connection externally
28      */
29     public function setConnection($connection){
30         $this->_connection = $connection;
31     }
32 
33     public function someDbTask()
34     {
35         $connection = $this->_connection;
36 
37         // ...
38     }
39 
40 }
41 
42 $some = new SomeComponent();
43 
44 //Pass the connection defined in the registry
45 $some->setConnection(Registry::getConnection());
46 
47 $some->someDbTask();

登入後複製

現在，讓我們來想像一下，我們必須在組件中實現兩個方法，首先需要創建一個新的數據庫連接，第二個總是獲得一個共享連接：

1 <?php 
2  
3 class Registry 
4 { 
5  
6     protected static $_connection; 
7  
8     /** 
9      * Creates a connection
10      */
11     protected static function _createConnection()
12     {
13         return new Connection(array(
14             "host" => "localhost",
15             "username" => "root",
16             "password" => "secret",
17             "dbname" => "invo"
18         ));
19     }
20 
21     /**
22      * Creates a connection only once and returns it
23      */
24     public static function getSharedConnection()
25     {
26         if (self::$_connection===null){
27             $connection = self::_createConnection();
28             self::$_connection = $connection;
29         }
30         return self::$_connection;
31     }
32 
33     /**
34      * Always returns a new connection
35      */
36     public static function getNewConnection()
37     {
38         return self::_createConnection();
39     }
40 
41 }
42 
43 class SomeComponent
44 {
45 
46     protected $_connection;
47 
48     /**
49      * Sets the connection externally
50      */
51     public function setConnection($connection){
52         $this->_connection = $connection;
53     }
54 
55     /**
56      * This method always needs the shared connection
57      */
58     public function someDbTask()
59     {
60         $connection = $this->_connection;
61 
62         // ...
63     }
64
65     /**
66      * This method always needs a new connection
67      */
68     public function someOtherDbTask($connection)
69     {
70 
71     }
72 
73 }
74 
75 $some = new SomeComponent();
76 
77 //This injects the shared connection
78 $some->setConnection(Registry::getSharedConnection());
79 
80 $some->someDbTask();
81 
82 //Here, we always pass a new connection as parameter
83 $some->someOtherDbTask(Registry::getConnection());

登入後複製

　到此為止，我們已經看到瞭如何使用依賴注入來解決我們的問題。不是在程式碼內部創建依賴關係，而是讓其作為一個參數傳遞，這使得我們的程式更容易維護，降低程式碼的耦合度，實現一種鬆散耦合。但從長遠來看，這種形式的依賴注入也有一些缺點。

　　例如，如果元件中有較多的依賴關係，我們需要建立多個setter方法傳遞，或建立建構函式進行傳遞。另外，每次使用元件時，都需要建立依賴元件，讓程式碼維護不太易，我們寫的程式碼可能像這樣：

1 <?php 
2  
3 //Create the dependencies or retrieve them from the registry 
4 $connection = new Connection(); 
5 $session = new Session(); 
6 $fileSystem = new FileSystem(); 
7 $filter = new Filter(); 
8 $selector = new Selector(); 
9 
10 //Pass them as constructor parameters
11 $some = new SomeComponent($connection, $session, $fileSystem, $filter, $selector);
12 
13 // ... or using setters
14 
15 $some->setConnection($connection);
16 $some->setSession($session);
17 $some->setFileSystem($fileSystem);
18 $some->setFilter($filter);
19 $some->setSelector($selector);

登入後複製

　我想，我們不得不在應用程式的許多地方建立這個物件。如果你不需要依賴的元件後，我們又要去程式碼注入部分移除建構函式中的參數或是setter方法。為了解決這個問題，我們再次回到使用一個全域註冊表來建立元件。但是，在創建物件之前，它增加了一個新的抽象層：

 1 <?php 
 2  
 3 class SomeComponent 
 4 { 
 5  
 6     // ... 
 7  
 8     /** 
 9      * Define a factory method to create SomeComponent instances injecting its dependencies
 10      */
 11     public static function factory()
 12     {
 13 
 14         $connection = new Connection();
 15         $session = new Session();
 16         $fileSystem = new FileSystem();
 17         $filter = new Filter();
 18         $selector = new Selector();
 19 
 20         return new self($connection, $session, $fileSystem, $filter, $selector);
 21     }
 22 
 23 }

登入後複製

　這一刻，我們好像回到了問題的開始，我們正在創建組件內部的依賴，我們每次都在修改以及尋找一種解決問題的辦法，但這都不是很好的做法。

　　一種實用和優雅的來解決這些問題，是使用容器的依賴注入，像我們在前面看到的，容器作為全局註冊表，使用容器的依賴注入做為一種橋樑來解決依賴可以使我們的程式碼耦合度更低，很好的降低了元件的複雜性：

 1 <?php 
 2  
 3 class SomeComponent 
 4 { 
 5  
 6     protected $_di; 
 7  
 8     public function __construct($di) 
 9     {
 10         $this->_di = $di;
 11     }
 12 
 13     public function someDbTask()
 14     {
 15 
 16         // Get the connection service
 17         // Always returns a new connection
 18         $connection = $this->_di->get(&#39;db&#39;);
 19 
 20     }
 21 
 22     public function someOtherDbTask()
 23     {
 24 
 25         // Get a shared connection service,
 26         // this will return the same connection everytime
 27         $connection = $this->_di->getShared(&#39;db&#39;);
 28 
 29         //This method also requires a input filtering service
 30         $filter = $this->_db->get(&#39;filter&#39;);
 31 
 32     }
 33 
 34 }
 35 
 36 $di = new Phalcon\DI();
 37 
 38 //Register a "db" service in the container
 39 $di->set(&#39;db&#39;, function(){
 40     return new Connection(array(
 41         "host" => "localhost",
 42         "username" => "root",
 43         "password" => "secret",
 44         "dbname" => "invo"
 45     ));
 46 });
 47 
 48 //Register a "filter" service in the container
 49 $di->set(&#39;filter&#39;, function(){
 50     return new Filter();
 51 });
 52 
 53 //Register a "session" service in the container
 54 $di->set(&#39;session&#39;, function(){
 55     return new Session();
 56 });
 57 
 58 //Pass the service container as unique parameter59 $some = new SomeComponent($di);
 60 
 61 $some->someTask();

登入後複製

現在，該元件只有存取某種service的時候才需要它，如果它不需要，它甚至不初始化，以節約資源。該組件是高度解耦。他們的行為，或者說他們的任何其他方面都不會影響到組件本身。
我們的實作辦法¶

PhalconDI 是一個實現了服務的依賴注入功能的元件，它本身也是一個容器。

由於Phalcon高度解耦，PhalconDI 是框架用來整合其他元件的必不可少的部分，開發人員也可以使用這個元件依賴注入和管理應用程式中不同類別檔案的實例。

基本上，這個元件實作了 Inversion of Control 模式。基於此，物件不再以建構函式接收參數或使用setter的方式來實現注入，而是直接請求服務的依賴注入。這就大大降低了整體程序的複雜性，因為只有一個方法可以用以獲得所需的一個元件的依賴關係。

此外，這種模式增強了程式碼的可測試性，從而使它不容易出錯。
在容器中註冊服務¶

框架本身或開發人員都可以註冊服務。當一個元件A要求呼叫元件B（或它的類別的一個實例），可以從容器中請求呼叫元件B，而不是建立元件B的一個實例。

這種工作方式為我們提供了許多優點：

我們可以更換一個組件，從他們本身或第三方輕鬆創建。
在元件發布之前，我們可以充分的控制物件的初始化，並對物件進行各種設定。
我們可以使用統一的方式從組件得到一個結構化的全局實例

服務可以通過以下幾種方式註入到容器：

 1 <?php 
 2  
 3 //Create the Dependency Injector Container 
 4 $di = new Phalcon\DI(); 
 5  
 6 //By its class name 
 7 $di->set("request", &#39;Phalcon\Http\Request&#39;); 
 8  
 9 //Using an anonymous function, the instance will lazy loaded
 10 $di->set("request", function(){
 11     return new Phalcon\Http\Request();
 12 });
 13 
 14 //Registering directly an instance
 15 $di->set("request", new Phalcon\Http\Request());
 16 
 17 //Using an array definition
 18 $di->set("request", array(
 19     "className" => &#39;Phalcon\Http\Request&#39;
 20 ));

登入後複製

在上面的例子中，當向框架請求訪問一個請求數據時，它將首先確定容器中是否存在這個”reqeust」名稱的服務。

容器會反回一個請求資料的實例，開發人員最後得到他們想要的元件。

在上面範例中的每一種方法都有優缺點，具體使用哪一種，由開發過程中的特定場景來決定的。

用一个字符串来设定一个服务非常简单，但缺少灵活性。设置服务时，使用数组则提供了更多的灵活性，而且可以使用较复杂的代码。lambda函数是两者之间一个很好的平衡，但也可能导致更多的维护管理成本。

Phalcon\DI 提供服务的延迟加载。除非开发人员在注入服务的时候直接实例化一个对象，然后存存储到容器中。在容器中，通过数组，字符串等方式存储的服务都将被延迟加载，即只有在请求对象的时候才被初始化。

 1 <?php 
 2  
 3 //Register a service "db" with a class name and its parameters 
 4 $di->set("db", array( 
 5     "className" => "Phalcon\Db\Adapter\Pdo\MySQL", 
 6     "parameters" => array( 
 7           "parameter" => array( 
 8                "host" => "localhost", 
 9                "username" => "root",
 10                "password" => "secret",
 11                "dbname" => "blog"
 12           )
 13     )
 14 ));
 15 
 16 //Using an anonymous function
 17 $di->set("db", function(){
 18     return new Phalcon\Db\Adapter\Pdo\Mysql(array(
 19          "host" => "localhost",
 20          "username" => "root",
 21          "password" => "secret",
 22          "dbname" => "blog"
 23     ));
 24 });

登入後複製

以上这两种服务的注册方式产生相同的结果。然后，通过数组定义的，在后面需要的时候，你可以修改服务参数：

1 <?php
2 
3 $di->setParameter("db", 0, array(
4     "host" => "localhost",
5     "username" => "root",
6     "password" => "secret"
7 ));

登入後複製

从容器中获得服务的最简单方式就是使用”get”方法，它将从容器中返回一个新的实例：

1 <?php
2      $request = $di->get("request")

登入後複製

或者通过下面这种魔术方法的形式调用：

1 <?php
2 
3 $request = $di->getRequest();
4 
5 Phalcon\DI 同时允许服务重用，为了得到一个已经实例化过的服务，可以使用 getShared() 方法的形式;

登入後複製

具体的 Phalcon\Http\Request 请求示例：

1 <?php
2 
3 $request = $di->getShared("request");

登入後複製

参数还可以在请求的时候通过将一个数组参数传递给构造函数的方式：

1 <?php
2 
3 $component = $di->get("MyComponent", array("some-parameter", "other"))

登入後複製

理解PHP依赖注入|LaravelIoC容器