IoC-控制反转 与 DI-依赖注入

1、IoC-控制反转

Ioc—Inversion of Control，即“控制反转”。IoC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

谁控制谁，控制什么：
我们一般直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

为何是反转，哪些方面反转了：
有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

2、DI-依赖注入

DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。
理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

谁依赖于谁：
当然是应用程序依赖于IoC容器；

为什么需要依赖：
应用程序需要IoC容器来提供对象需要的外部资源；

谁注入谁：
很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；

注入了什么：
就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。

3、代码实现

接下来我们看一下如何从我们平常用对象的方式转化到用IOC和DI。

首先我们看一下平常用对象的方式，请看代码：

<?php
interface Database
{
    public function insert();
}
class Mysql implements Database
{
    public function insert()
    {
        echo 'Mysql insert';
    }
}
class Oracle implements Database
{
    public function insert()
    {
        echo 'Oracle insert';
    }
}
class App
{
    protected $database;

    public function __construct()
    {
        $this->database = new Mysql();
    }
    public function insertLog()
    {
        $this->database->insert();
    }
}
$app = new App();
$app->insertLog();

上面的代码实现了写入数据库日志功能，看起来没什么问题，但是如果我要把Mysql改成Oracle数据库，那就得重新修改App类了。实际上这并没有达到解耦。我们可以稍作修改：

class App
{
    protected $database;
    public function __construct(Database $database)
    {
        $this->database = $database;
    }
    public function insertLog()
    {
        $this->database->insert();
    }
}
$app = new App(new Oracle());
$app->insertLog();

现在通过构造函数传递参数就可以实现修改数据库了，由外部注入依赖对象，App对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了，我们可以称其为控制反转。

那么我们可不可以来实现一个不用new对应class就可以实例化对象的方法呢？有！PHP中有反射机制，我们可以用反射类来实现。下面看代码【注意其中的make()方法】：

class App
{
    protected $database;
    public function __construct(Oracle $database)
    {
        $this->database = $database;
    }
    public function insertLog()
    {
        $this->database->insert();
    }
}
function make($class)
{
    //ReflectionClass这个是PHP内置的反射类，具体请参考PHP手册
    $reflect = new ReflectionClass($class);
    $constructor = $reflect->getConstructor();
    if (is_null($constructor)) {
        return $reflect->newInstance();
    }
    //返回构造函数里的依赖实例
    $instances = getParameters($constructor);
    return $reflect->newInstanceArgs($instances);
}
function getParameters($constructor)
{
    $parameters = $constructor->getParameters();
    $dependencies = [];
    foreach ($parameters as $parameter) {
        //调用make方法递归获取实例
        //$parameter->getClass()->name  获得类型提示类名，比如 function Test(App $app) ，就是App
        $dependencies[] = make($parameter->getClass()->name);
    }
    return $dependencies;
}
$app = make('App');
$app->insertLog();

上面程序里IoC容器自动实例化了Oracle类，并注入到App类里，所以我们不需要手动传入，我们可以称其为依赖注入。

上面的代码还是没有完全达到解偶。如果很多页面的构造里都注入了Mysql，但是有一天要把系统换成Oracle记录日志，那我们岂不是全部页面都要改成Oracle？我们再改造一下，添加一个容器处理类Container：

interface Database
{
    public function insert();
}
class Mysql implements Database
{
    public function insert()
    {
        echo 'Mysql insert';
    }
}
class Oracle implements Database
{
    public function insert()
    {
        echo 'Oracle insert';
    }
}
class App
{
    protected $database;
    public function __construct(Database $database)
    {
        $this->database = $database;
    }
    public function insertLog()
    {
        $this->database->insert();
    }
}
class Container
{
    protected $bind = [];
    /**
     * @param string $abstract 类标识、接口
     * @param string $concrete 要绑定的类
     */
    public function bind($abstract, $concrete)
    {
        $this->bind[$abstract] = $this->build($concrete);
    }
    public function make($abstract)
    {
        if (!isset($this->bind[$abstract])) {
            $this->bind($abstract, $abstract);
        }
        return $this->bind[$abstract];
    }
    //相当于之前的make方法
    public function build($abstract)
    {
        $reflect = new ReflectionClass($abstract);
        $constructor = $reflect->getConstructor();
        if (is_null($constructor)) {
            return $reflect->newInstance();
        }
        $instances = $this->getParameters($constructor);
        return $reflect->newInstanceArgs($instances);
    }
    protected function getParameters($constructor)
    {
        $parameters = $constructor->getParameters();
        $dependencies = [];
        foreach ($parameters as $parameter) {
            $dependencies[] = $this->make($parameter->getClass()->name);
        }
        return $dependencies;
    }
}
$container = new Container();
$container->bind('Database', 'Mysql');
$app = $container->make('App');
$app->insertLog();

我们把 App 构造的类提示从Oracle类改成 Database接口，这样就可以让容器决定注入数据库类了：

public function __construct(Database $database)

怎么让容器决定注入的类？bind方法里，先是把Mysql类实例化，然后映射到Database接口，make解析实例的时候，会把Database换成Mysql实例，注入到参数里。

$container->bind('Database', 'Mysql');

以后需要更换数据库时候，只要在绑定容器的地方，把映射类替换掉，所有页面也都生效了。

$container->bind('Database', 'Oracle');

以上，就是IOC与DI的实现过程。

内容参考自：PHP的反射控制反转和依赖注入、IoC基础