推荐一篇介绍依赖注入的基础文章依赖注入基础讲解

    说白了, 依赖注入就是不直接在使用类的内部创建对象， 而是将对象作为调用类的一个属性, 这样能够降低类与类之间的耦合, 使程序更加的灵活可变。还是举个简单的例子吧。
    先来定义三个文件分别是 IGun.php , PistolGun.php, Soldier.php

    1. //IGun.php
    2. interface IGun
    3. {
    4.     public function getName();
    6.     public function shoot();
    8. }
    10. // PistoGun.php
    11. class PistolGun implements IGun
    12. {
    13.     private $name = 'Pisto';
    15.     public function getName()
    16.     {
    17.         return $this->name;
    18.     }
    20.     public function shoot()
    21.     {
    22.         echo 'Pisto shoot' . PHP_EOL;
    23.     }
    24. }
    26. // Soldier.php
    27. // 士兵使用枪射杀敌人
    28. class Soldier
    29. {
    30.     private $gun;
    32.     public function __construct()
    33.     {
    34.         $this->gun = new PistolGun();
    35.     }
    37.     public function shoot()
    38.     {
    39.         echo 'soldier use ' . $this->gun->shoot();
    40.     }
    42.     public function getGunName()
    43.     {
    44.         echo $this->gun->getName();
    45.     }
    46. }

    这样的代码应该是很容易写出来的， 现在问题来了， 为了增强士兵的杀敌能力和自保能力， 政府决定每人一把加特林。为了更改我们必须修改这个类，但是在下一次战争中可能是游击战， 为了灵活又要使用手枪了， 这种事情虽然不可能出现， 但在编程世界里应该随时都可能发生， 为了能够使这个类更加灵活， 于是就引入了依赖注入一说， 现在我们增加一个类， 并且使用依赖注入的写法。

    1. // Gatling.php
    2. class Gatling implements IGun
    3. {
    4.     private $name = 'Gatling';
    5.     public function shoot()
    6.     {
    7.         echo $this->name . 'shoot' . PHP_EOL;
    8.     }
    10.     public function getName()
    11.     {
    12.         return $this->name;
    13.     }
    14. }

    // 依赖注入的写法

    1. // Soldier.php
    2. // 士兵使用枪射杀敌人
    3. class Soldier
    4. {
    5.     private $gun;
    7.     public function __construct(IGun $_gun)
    8.     {
    9.         $this->gun = $_gun;
    10.     }
    12.     public function shoot()
    13.     {
    14.         echo 'soldier use ' . $this->gun->shoot();
    15.     }
    17.     public function getGunName()
    18.     {
    19.         echo $this->gun->getName();
    20.     }
    22. }
    24. (new Soldier(new Gatling())) -> shoot();  //使用加特林的士兵射击
    25. (new Soldier(new PistolGun())) -> shoot();  // 使用手枪的士兵射击

    依赖注入就是通过注入不同的对象来实现灵活性， 但是我们需要使用约束（接口和抽象）以保证程序的正常运行(总不能随便一个类我就用吧)
    除了通过构造函数，也可以使用setter方法注入依赖。

    1. // 在Solder中
    2. public function setGun(IGun $_gun) {
    3.     $this->gun = $_gun;
    4. }

    如果使用setter方法， 或许需要加点检测， 以防止没有调用setter方法， 就开始上阵杀敌。试想下， 你上战场了， 但是忘了带枪了（这样我想起了一部电影—血战钢锯岭, 但我觉得不是每个人都有那样的运气。）这基本和故意送人头没区别了， 是要被举报的。