对PHP依赖注入的理解实例分析

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了对PHP依赖注入的理解实例分析，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9814字，纯文字阅读大概需要15分钟。

内容图文

本文实例讲述了对PHP依赖注入的理解。分享给大家供大家参考，具体如下：

看Laravel的IoC容器文档只是介绍实例，但是没有说原理，之前用MVC框架都没有在意这个概念，无意中在phalcon的文档中看到这个详细的介绍，感觉豁然开朗，复制粘贴过来，主要是好久没有写东西了，现在确实很懒变得！

首先，我们假设，我们要开发一个组件命名为SomeComponent。这个组件中现在将要注入一个数据库连接。

在这个例子中，数据库连接在component中被创建，这种方法是不切实际的，这样做的话，我们将不能改变数据库连接参数及数据库类型等一些参数。

class SomeComponent {
  /**
   * The instantiation of the connection is hardcoded inside
   * the component so is difficult to replace it externally
   * or change its behavior
   */
  public function someDbTask()
  {
    $connection = new Connection(array(
      "host" => "localhost",
      "username" => "root",
      "password" => "secret",
      "dbname" => "invo"
    ));
    // ...
  }
}
$some = new SomeComponent();
$some->someDbTask();

为了解决上面所说的问题，我们需要在使用前创建一个外部连接，并注入到容器中。就目前而言，这看起来是一个很好的解决方案：

class SomeComponent {
  protected $_connection;
  /**
   * Sets the connection externally
   */
  public function setConnection($connection)
  {
    $this->_connection = $connection;
  }
  public function someDbTask()
  {
    $connection = $this->_connection;
    // ...
  }
}
$some = new SomeComponent();
//Create the connection
$connection = new Connection(array(
  "host" => "localhost",
  "username" => "root",
  "password" => "secret",
  "dbname" => "invo"
));
//Inject the connection in the component
$some->setConnection($connection);
$some->someDbTask();

现在我们来考虑一个问题，我们在应用程序中的不同地方使用此组件，将多次创建数据库连接。使用一种类似全局注册表的方式，从这获得一个数据库连接实例，而不是使用一次就创建一次。

class Registry
{
  /**
   * Returns the connection
   */
  public static function getConnection()
  {
    return new Connection(array(
      "host" => "localhost",
      "username" => "root",
      "password" => "secret",
      "dbname" => "invo"
    ));
  }
}
class SomeComponent
{
  protected $_connection;
  /**
   * Sets the connection externally
   */
  public function setConnection($connection){
    $this->_connection = $connection;
  }
  public function someDbTask()
  {
    $connection = $this->_connection;
    // ...
  }
}
$some = new SomeComponent();
//Pass the connection defined in the registry
$some->setConnection(Registry::getConnection());
$some->someDbTask();

现在，让我们来想像一下，我们必须在组件中实现两个方法，首先需要创建一个新的数据库连接，第二个总是获得一个共享连接：

class Registry
{
  protected static $_connection;
  /**
   * Creates a connection
   */
  protected static function _createConnection()
  {
    return new Connection(array(
      "host" => "localhost",
      "username" => "root",
      "password" => "secret",
      "dbname" => "invo"
    ));
  }
  /**
   * Creates a connection only once and returns it
   */
  public static function getSharedConnection()
  {
    if (self::$_connection===null){
      $connection = self::_createConnection();
      self::$_connection = $connection;
    }
    return self::$_connection;
  }
  /**
   * Always returns a new connection
   */
  public static function getNewConnection()
  {
    return self::_createConnection();
  }
}
class SomeComponent
{
  protected $_connection;
  /**
   * Sets the connection externally
   */
  public function setConnection($connection){
    $this->_connection = $connection;
  }
  /**
   * This method always needs the shared connection
   */
  public function someDbTask()
  {
    $connection = $this->_connection;
    // ...
  }
  /**
   * This method always needs a new connection
   */
  public function someOtherDbTask($connection)
  {
  }
}
$some = new SomeComponent();
//This injects the shared connection
$some->setConnection(Registry::getSharedConnection());
$some->someDbTask();
//Here, we always pass a new connection as parameter
$some->someOtherDbTask(Registry::getConnection());

到此为止，我们已经看到了如何使用依赖注入解决我们的问题。不是在代码内部创建依赖关系，而是让其作为一个参数传递，这使得我们的程序更容易维护，降低程序代码的耦合度，实现一种松耦合。但是从长远来看，这种形式的依赖注入也有一些缺点。

例如，如果组件中有较多的依赖关系，我们需要创建多个setter方法传递，或创建构造函数进行传递。另外，每次使用组件时，都需要创建依赖组件，使代码维护不太易，我们编写的代码可能像这样：

//Create the dependencies or retrieve them from the registry
$connection = new Connection();
$session = new Session();
$fileSystem = new FileSystem();
$filter = new Filter();
$selector = new Selector();
//Pass them as constructor parameters
$some = new SomeComponent($connection, $session, $fileSystem, $filter, $selector);
// ... or using setters
$some->setConnection($connection);
$some->setSession($session);
$some->setFileSystem($fileSystem);
$some->setFilter($filter);
$some->setSelector($selector);

我想，我们不得不在应用程序的许多地方创建这个对象。如果你不需要依赖的组件后，我们又要去代码注入部分移除构造函数中的参数或者是setter方法。为了解决这个问题，我们再次返回去使用一个全局注册表来创建组件。但是，在创建对象之前，它增加了一个新的抽象层：

class SomeComponent
{
  // ...
  /**
   * Define a factory method to create SomeComponent instances injecting its dependencies
   */
  public static function factory()
  {
    $connection = new Connection();
    $session = new Session();
    $fileSystem = new FileSystem();
    $filter = new Filter();
    $selector = new Selector();
    return new self($connection, $session, $fileSystem, $filter, $selector);
  }
}

这一刻，我们好像回到了问题的开始，我们正在创建组件内部的依赖，我们每次都在修改以及找寻一种解决问题的办法，但这都不是很好的做法。

一种实用和优雅的来解决这些问题，是使用容器的依赖注入，像我们在前面看到的，容器作为全局注册表，使用容器的依赖注入做为一种桥梁来解决依赖可以使我们的代码耦合度更低，很好的降低了组件的复杂性：

class SomeComponent
{
  protected $_di;
  public function __construct($di)
  {
    $this->_di = $di;
  }
  public function someDbTask()
  {
    // Get the connection service
    // Always returns a new connection
    $connection = $this->_di->get('db');
  }
  public function someOtherDbTask()
  {
    // Get a shared connection service,
    // this will return the same connection everytime
    $connection = $this->_di->getShared('db');
    //This method also requires a input filtering service
    $filter = $this->_db->get('filter');
  }
}
$di = new Phalcon\DI();
//Register a "db" service in the container
$di->set('db', function(){
  return new Connection(array(
    "host" => "localhost",
    "username" => "root",
    "password" => "secret",
    "dbname" => "invo"
  ));
});
//Register a "filter" service in the container
$di->set('filter', function(){
  return new Filter();
});
//Register a "session" service in the container
$di->set('session', function(){
  return new Session();
});
//Pass the service container as unique parameter
$some = new SomeComponent($di);
$some->someTask();

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

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

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

基本上，这个组件实现了 Inversion of Control 模式。基于此，对象不再以构造函数接收参数或者使用setter的方式来实现注入，而是直接请求服务的依赖注入。这就大大降低了整体程序的复杂性，因为只有一个方法用以获得所需要的一个组件的依赖关系。
此外，这种模式增强了代码的可测试性，从而使它不容易出错。
在容器中注册服务

框架本身或开发人员都可以注册服务。当一个组件A要求调用组件B（或它的类的一个实例），可以从容器中请求调用组件B，而不是创建组件B的一个实例。

这种工作方式为我们提供了许多优点：

我们可以更换一个组件，从他们本身或者第三方轻松创建。
在组件发布之前，我们可以充分的控制对象的初始化，并对对象进行各种设置。

我们可以使用统一的方式从组件得到一个结构化的全局实例
服务可以通过以下几种方式注入到容器：

//Create the Dependency Injector Container
$di = new Phalcon\DI();
//By its class name
$di->set("request", 'Phalcon\Http\Request');
//Using an anonymous function, the instance will lazy loaded
$di->set("request", function(){
  return new Phalcon\Http\Request();
});
//Registering directly an instance
$di->set("request", new Phalcon\Http\Request());
//Using an array definition
$di->set("request", array(
  "className" => 'Phalcon\Http\Request'
));

在上面的例子中，当向框架请求访问一个请求数据时，它将首先确定容器中是否存在这个”reqeust”名称的服务。

容器会反回一个请求数据的实例，开发人员最终得到他们想要的组件。
在上面示例中的每一种方法都有优缺点，具体使用哪一种，由开发过程中的特定场景来决定的。

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

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

//Register a service "db" with a class name and its parameters
$di->set("db", array(
  "className" => "Phalcon\Db\Adapter\Pdo\Mysql",
  "parameters" => array(
     "parameter" => array(
        "host" => "localhost",
        "username" => "root",
        "password" => "secret",
        "dbname" => "blog"
     )
  )
));
//Using an anonymous function
$di->set("db", function(){
  return new Phalcon\Db\Adapter\Pdo\Mysql(array(
     "host" => "localhost",
     "username" => "root",
     "password" => "secret",
     "dbname" => "blog"
  ));
});

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

$di->setParameter("db", 0, array(
  "host" => "localhost",
  "username" => "root",
  "password" => "secret"
));

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

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

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

$request = $di->getRequest();

Phalcon\DI 同时允许服务重用，为了得到一个已经实例化过的服务，可以使用 getShared() 方法的形式来获得服务。
具体的 Phalcon\Http\Request 请求示例：

$request = $di->getShared("request");

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

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

希望本文所述对大家PHP程序设计有所帮助。

更多对PHP依赖注入的理解实例分析相关文章请关注PHP中文网！

内容总结

以上是互联网集市为您收集整理的对PHP依赖注入的理解实例分析全部内容，希望文章能够帮你解决对PHP依赖注入的理解实例分析所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/147984.html

来源：【匿名】

【上一篇】PHP学习路线以及10个PHP优化技巧【下一篇】PHP 5 数据对象 (PDO) 抽象层与 Oracle

更多 ►

【对PHP依赖注入的理解实例分析】教程文章相关的互联网学习教程文章

PHP实现事件机制实例分析内置了事件机制的语言不多，php也没有提供这种功能。事件(Event)说简单了就是一个Observer模式。实现起来非常easy。可是有所不同的是，事件的监听者谁都能够加，可是仅仅能由直接包括它的对象触发。这就有一点点难度了。php有一个debug_backtrace函数，能够得到当前的调用栈，由此能够找到推断调用事件触发函数的对象是不是直接包括它的对象的办法。<?php /** * 事件 * @edit http://www.lai18.com * @au...

php抽象类用法实例分析【代码】

本文实例讲述了php抽象类用法。分享给大家供大家参考。具体如下： <?php /** abstract* 抽象类：* 1、至少有一个抽象方法（没有具体实现的方法）* 2、不能被实例化，可以被继承* 3、抽象类可以有子抽象类* 相对于接口：* 1、可以有属性* 2、一个子类只能继承一个抽象类，但是可以实现多个接口* * * */abstract class qian {abstract function getfirst();function gettwo() {echo "I am gettwo";}}abstract class jj extends qian ...

THINKPHP项目开发中的日志记录实例分析

本文实例讲述了THINKPHP项目开发中的日志记录用法。分享给大家供大家参考。具体方法如下：1、建立日志表复制代码代码如下:CREATE TABLE `logs` ( `id` int(11) NOT NULL auto_increment, `guid` varchar(100) character set utf8 NOT NULL, `addtime` timestamp NOT NULL default CURRENT_TIMESTAMP, `account` varchar(100) character set utf8 NOT NULL, `nickname` varchar(100) character set utf8 NOT N...

php跨站攻击实例分析

本文实例讲述了php跨站攻击的原理与防范技巧。分享给大家供大家参考。具体方法分析如下：跨站攻击就是利用程序上的一些细节或bug问题进行的，那么我们要如何耿防止跨站攻击呢？下面就以一个防止跨站攻击例子来说明，希望对各位有帮助。复制代码代码如下:<?php #demo for prevent csrf /** * enc */ function encrypt($token_time) { return md5(‘!@##$@$$#%43‘ . $token_time); } $token_time = time(); $token = encrypt($toke...

php常用字符串处理函数实例分析

本文实例讲述了php常用字符串处理函数。分享给大家供大家参考。具体分析如下：这里只提供几个简单常用的函数： chop执行去除空格处理,get_html_translation_table返回转化列表到变量,定义包括HTML编码的字符串htmlentities,htmlspecialchars_decode 定义包含HTML特殊字符的字符串,nl2br quotemeta rtrim等.定义和用法:chop() 函数从字符串的末端开始删除空白字符或其他预定义字符,该函数的 rtrim() 函数的别名.语法:chop(string,ch...

thinkphp连贯操作实例分析

本文实例分析了thinkphp连贯操作用法。分享给大家供大家参考。具体分析如下：一、常用连贯操作,可以接连使用但没前后顺序之分,后面一定要有方法select,updata,delete,find1.where:帮助我们设置查询条件2.order:对结果进行排序复制代码代码如下:$arr=$m->order(‘id desc‘)->select();//字符串方法,默认是asc升序排列，加desc改为降序排列 $arr=$m->order(array(‘id‘=>‘desc‘,‘sex‘=>‘asc‘))->select(); //数组方法 3.l...

PHP贪婪算法解决0-1背包问题实例分析【代码】

本文实例讲述了PHP贪婪算法解决0-1背包问题的方法。分享给大家供大家参考。具体分析如下：贪心算法解决0-1背包问题，全局最优解通过局部最优解来获得！比动态规划解决背包问题更灵活！ //0-1背包贪心算法问题 class tanxin{public $weight;public $price;public function __construct($weight=0,$price=0){$this->weight=$weight;$this->price=$price;} } //生成数据 $n=10; for($i=1;$i<=$n;$i++){$weight=rand(1,20);$price=rand...

php设计模式之单例模式实例分析

本文实例讲述了php设计模式之单例模式。分享给大家供大家参考。具体分析如下：单例模式（职责模式）：简单的说，一个对象（在学习设计模式之前，需要比较了解面向对象思想）只负责一个特定的任务；单例类： 1、构造函数需要标记为private（访问控制：防止外部代码使用new操作符创建对象），单例类不能在其他类中实例化，只能被其自身实例化； 2、拥有一个保存类的实例的静态成员变量 3、拥有一个访问这个实例的公共的静态方法（...

PHP设计模式之工厂方法设计模式实例分析

本文实例讲述了PHP设计模式之工厂方法设计模式。分享给大家供大家参考，具体如下：一、什么是工厂方法模式作为一种创建型设计模式，工厂方法模式就是要创建“某种东西”。对于工厂方法，要创建的“东西”是一个产品，这个产品与创建它的类之间不存在绑定。实际上，为了保持这种松耦合，客户会通过一个工厂发出请求，再由工厂创建所请求的产品。利用工厂方法模式，请求者只发出请求，而不具体创建产品。二、什么时候使用工厂方法...

PHP耦合设计模式实例分析

本文实例分析了PHP耦合设计模式。分享给大家供大家参考，具体如下：一个软件，它具有许多类，类与类之间需要互相调用，一旦某个类与另一个类具有紧密耦合关系的时候，这个软件的重用性就会大大降低。所以一个软件的重用性的高低就取决于它的耦合程度的高低。耦合度：程序模块之间的关联、依赖程度。在设计过程中提出：当设计这个软件的体系结构的时候，就发现了这个软件的逻辑运行部分（SimpleRouter类）和输出部分（SimpleRout...

PHP设计模式之策略模式原理与用法实例分析

本文实例讲述了PHP设计模式之策略模式原理与用法。分享给大家供大家参考，具体如下：策略模式(Strategy Pattern) 策略模式是对象的行为模式，用意是对一组算法的封装。动态的选择需要的算法并使用。策略模式指的是程序中涉及决策控制的一种模式。策略模式功能非常强大，因为这个设计模式本身的核心思想就是面向对象编程的多形性思想。策略模式的三个角色： 1. 抽象策略角色 2. 具体策略角色 3. 环境角色（对抽象策略角色的引用）...

PHP设计模式之简单工厂和工厂模式实例分析

本文实例讲述了PHP设计模式之简单工厂和工厂模式。分享给大家供大家参考，具体如下：工厂模式是创建型模式的一种，分为简单工厂模式，工厂模式，抽象工厂模式，简单工厂可以称之为工厂模式的一个特例先用一段简单的代码说明一下，现在假设我们是顾客，需要苹果味饮料和香蕉味饮料 <?php class AppleDrink{function getDrinkName(){echo 苹果饮料;} } class BananaDrink{function getDrinkName(){echo 香蕉饮料;} } //顾客1 $appl...

首页 / PHP / 对PHP依赖注入的理解实例分析

对PHP依赖注入的理解实例分析

内容导读

内容图文

内容总结

内容备注

内容手机端

【对PHP依赖注入的理解实例分析】教程文章相关的互联网学习教程文章

PHP实现事件机制实例分析【代码】

php抽象类用法实例分析【代码】

THINKPHP项目开发中的日志记录实例分析

php跨站攻击实例分析

php常用字符串处理函数实例分析

thinkphp连贯操作实例分析

PHP贪婪算法解决0-1背包问题实例分析【代码】

php设计模式之单例模式实例分析

PHP设计模式之工厂方法设计模式实例分析

PHP耦合设计模式实例分析

PHP设计模式之策略模式原理与用法实例分析

PHP设计模式之简单工厂和工厂模式实例分析

PHP设计模式之抽象工厂模式实例分析

php设计模式之单例模式实例分析_PHP

php设计模式之单例模式实例分析_php技巧

PHP - 相关标签

实例 - 相关标签

PHP - 技术教程分类

PHP - 最新教程

PHP - 最热教程