懂得 PHP 依赖注入 | Laravel IoC容器

 1 php 2  3 class Registry 4 { 5  6     protected static $_connection; 7  8     /** 9      * Creates a connection10      */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 it23      */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 connection35      */36     public static function getNewConnection()37     {38         return self::_createConnection();39     }40 41 }42 43 class SomeComponent44 {45 46     protected $_connection;47 48     /**49      * Sets the connection externally50      */51     public function setConnection($connection){52         $this->_connection = $connection;53     }54 55     /**56      * This method always needs the shared connection57      */58     public function someDbTask()59     {60         $connection = $this->_connection;61 62         // ...63     }64 65     /**66      * This method always needs a new connection67      */68     public function someOtherDbTask($connection)69     {70 71     }72 73 }74 75 $some = new SomeComponent();76 77 //This injects the shared connection78 $some->setConnection(Registry::getSharedConnection());79 80 $some->someDbTask();81 82 //Here, we always pass a new connection as parameter83 $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 parameters11 $some = new SomeComponent($connection, $session, $fileSystem, $filter, $selector);12 13 // ... or using setters14 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 dependencies10      */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 service17         // Always returns a new connection18         $connection = $this->_di->get('db');19 20     }21 22     public function someOtherDbTask()23     {24 25         // Get a shared connection service,26         // this will return the same connection everytime27         $connection = $this->_di->getShared('db');28 29         //This method also requires a input filtering service30         $filter = $this->_db->get('filter');31 32     }33 34 }35 36 $di = new Phalcon\DI();37 38 //Register a "db" service in the container39 $di->set('db', 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 container49 $di->set('filter', function(){50     return new Filter();51 });52 53 //Register a "session" service in the container54 $di->set('session', function(){55     return new Session();56 });57 58 //Pass the service container as unique parameter59 $some = new SomeComponent($di);60 61 $some->someTask();

现在，该组件只有访问某种service的时候才需要它，如果它不需要，它甚至不初始化，以节约资源。该组件是高度解耦。他们的行为，或者说他们的任何其他方面都不会影响到组件本身。
我们的实现办法¶

Phalcon\DI 是一个实现了服务的依赖注入功能的组件，它本身也是一个容器。

由于Phalcon高度解耦，Phalcon\DI 是框架用来集成其他组件的必不可少的部分，开发人员也可以使用这个组件依赖注入和管理应用程序中不同类文件的实例。

基本上，这个组件实现了 Inversion of Control 模式。基于此，对象不再以构造函数接收参数或者使用setter的方式来实现注入，而是直接请求服务的依赖注入。这就大大降低了整体程序的复杂性，因为只有一个方法用以获得所需要的一个组件的依赖关系。

此外，这种模式增强了代码的可测试性，从而使它不容易出错。
在容器中注册服务¶

依赖注入容器的PHP库

依赖注入容器的PHP库

下载

框架本身或开发人员都可以注册服务。当一个组件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", 'Phalcon\Http\Request'); 8  9 //Using an anonymous function, the instance will lazy loaded10 $di->set("request", function(){11     return new Phalcon\Http\Request();12 });13 14 //Registering directly an instance15 $di->set("request", new Phalcon\Http\Request());16 17 //Using an array definition18 $di->set("request", array(19     "className" => 'Phalcon\Http\Request'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 function17 $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 php2 3 $di->setParameter("db", 0, array(4     "host" => "localhost",5     "username" => "root",6     "password" => "secret"7 ));

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

1 php2      $request = $di->get("request");

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

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

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

1 php2 3 $request = $di->getShared("request");

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

1 php2 3 $component = $di->get("MyComponent", array("some-parameter", "other"))