PHP 中的 IoC 容器和反射

在开始之前要明确一个概念，不管是设计模式，还是依赖注入等等，都是为了实现模块化。所谓模块化就是希一个软件是由很多子模块组成的，这些模块之间的依赖程度尽量的低，也就是如果系统中不需要某一个功能，那么只要移除这个功能所对应的模块就可以了.

那么，我们今天要说的服务容器就是为了实现上面的功能。你应该听过，Laravel 中的服务容器其本质上是一个 IoC 容器，但是好像队 IoC 又不是很了解，讲来讲去优点很多，功能很强劲。但是不懂原理怎么用都不踏实啊。所以，这里我们自己来实现一个 IoC 容器，洞察其本质.

在开始之前，先说明一点，阅读本篇文章至少要保证有一下的基础知识:

php 反射用法
闭包的 use 用法

如果不懂上面的内容，请先补充。避免阅读代码时候产生的不适感.

<?php


class Container
{
    public $binding = [];


/**
 * @param $abstract
 * @param null $concrete
 * @param bool $shared  
 */
public function bind($abstract, $concrete = null, $shared = false)
{
    if (!$concrete instanceof Closure) {
        $concrete = $this->getClosure($abstract, $concrete);
    }

    $this->binding[$abstract] = compact('concrete', 'shared');
}



protected function getClosure($abstract, $concrete)
{
    return function ($c) use ($abstract, $concrete) {
        $method = ($abstract == $concrete) ? 'build' : 'make';
        return $c->$method($concrete);
    };
}

/**
 * @param $abstract
 * @return object
 *
 */
public function make($abstract)
{
    $concrete = $this->getConcrete($abstract);

    if ($this->isBuildable($concrete, $abstract)) {
        $object = $this->build($concrete);
    } else {
        $object = $this->make($concrete);
    }
    return $object;
}

/**
 * @param $concrete
 * @param $abstract
 * @return bool
 */
public function isBuildable($concrete, $abstract)
{
    return $concrete === $abstract || $concrete instanceof Closure;
}

/**
 * @param $abstract
 * @return mixed
 */
protected function getConcrete($abstract)
{
    if (!isset($this->binding[$abstract])) {
        return $abstract;
    }
    return $this->binding[$abstract]['concrete'];
}


/**
 * @param $concrete
 * @return object
 */
public function build($concrete) {

    if($concrete instanceof Closure) {
        return $concrete($this);
    }

    //反射...
    $reflector = new ReflectionClass($concrete);
    if(!$reflector->isInstantiable()) {
        echo $message = "Target [$concrete] is not instantiable";
    }
    //获取要实例化对象的构造函数
    $constructor = $reflector->getConstructor();

    //没有定义构造函数,只有默认的构造函数,说明构造函数参数个数为空
    if(is_null($constructor)) {
        return new $concrete;
    }

    //获取构造函数所需要的所有参数
    $dependencies = $constructor->getParameters();
    $instances = $this->getDependencies($dependencies);

    //从给出的数组参数在中实例化对象
    return $reflector->newInstanceArgs($instances);
}

/**
 * @param $paramters
 * @return array
 * 获取构建类所需要的所有依赖,级构造函数所需要的参数 ,
 */
protected function getDependencies($paramters) {
    $dependencies = [];

    foreach ($paramters as $paramter) {
        //获取到参数名称.
        $dep = $paramter->getClass();
        if(is_null($dep)){
            $dependencies = null;
        }else{
            $dependencies[] = $this->resolveClass($paramter);
        }
    }
    return (array)$dependencies;
}

/**
 * @param ReflectionParameter $parameter
 * @return object
 * 实例化 构造函数中所需要的参数.
 */
protected function resolveClass(ReflectionParameter $parameter) {
    $name = $parameter->getClass()->name;
    return $this->make($name);
}

}

这就是一个 IoC 容器的实现代码。乍一看，很麻烦。其实真的蛮麻烦的 =_=, 如果是第一次接触的话，并不是那么好消化，这里再给出使用 IoC 容器的代码

<?php

require __DIR__ . '/Container.php';


interface TrafficTool
{
public function go();
}

class Train implements TrafficTool
{

  public function go()
  {
     echo "train....";
  }
}

class Leg implements TrafficTool
{
  public function go()
  {
    echo "leg..";
  }
}

class Traveller
{
  /**
   * @var Leg|null|Train
   * 旅行工具
   */
  protected $_trafficTool;

  public function __construct(TrafficTool$trafficTool)
  {
    $this->_trafficTool = $trafficTool;
  }

  public function visitTibet()
  {
    $this->_trafficTool->go();
  }
}

//实例化IoC容器
$app = new Container();

//绑定某一功能到IoC
$app->bind('TrafficTool', 'Train');
$app->bind('travellerA', 'Traveller');

// 实例化对象
$tra = $app->make('travellerA');
$tra->visitTibet();

运行例子发现会输出: train.. .

这个例子假设旅行者去青藏旅行，可以坐火车 (train) 或者走路 (leg) 去青藏.

好了，其实这样子本篇文章就可以结束了，因为所有的答案都在 IoC 容器的实现中，但是为了可以更好的理解上面的代码，我们继续往下分析.

首先，希望你可以运行一下上面的代码，虽然简单的运行代码并不会帮助你理解代码，但是一个可以运行的例子会让人比较踏实，能够更有把握的理解代码.

在深入每一行代码之前，我们从整体上来分析，IoC 解决了一个什么问题？简单点说，就是我们再实例化对象的时候不用使用 new 了，有了 IoC 容器之后，我们调用 make 函数就可以实例化出一个对象了。然而，你发现，Traveller 的构造函数是需要一个参数的，可是我们好像并没有提供这个参数？

这就是 IoC 强大之处了，调用 make 实例化对象的时候，容器会使用反射功能，去分析我们要实例化对象的构造函数，获取构造函数所需的每个参数，然后分别去实例化这些参数，如果实例化这些参数也要参数，那么就再去实例化参数的参数…..=_=. 到最后成功实例化我们所需要的 traveller 了。在 Container 的 build 函数就是使用反射来实例化对象.

但是，有一个问题了，IoC 容器怎么知道实例化 Traveller 的时候需要的参数 train, 而不是 leg?

其实，IoC 容器什么都不知道，IoC 会实例化哪些对象都是通过 bind 函数告诉 IoC 的，上面的例子两次调用 bind 函数，就是告诉 Ioc 可以实例化的对象有 Train 和 Traveller . 再通俗讲就是：当需要当我们需要 TrafficTool 这个服务的时候去实例化 Train 这个类，需要一个 travellerA 的旅行者的时候去实例化 Traveller 类。而 Train 这个就是 travellerA 就是去青藏的方式。这样子如果想要走路去青藏的话只要把 $app->bind (‘Visit’, ‘Train’); 改为 $app->bind (‘Visit’, ‘Leg’); 就可以.

可是，这上面的这些有什么意义？直接 $tra = new Traveller ($trafficTool) 来实例化对象好像也没有什么不好的.

使用 new 来实例化对象的时候，会产生依赖。比如上面 $tra = new Traveller ($trafficTool) , 这说明我们要创建一个 Traveller 之前得有一个 $trafficTool , 即 Traveller 依赖于 trafficTool . 当使用 new 来实例化 Traveller 的时候，Traveller 和 trafficTool 之间就产生了耦合。这样，这两个组件就没办法分开了.

而使用 IoC 是怎么解决这个问题的，之前说过，如果想要如果想要走路去青藏的话只要把 $app->bind (‘Visit’, ‘Train’); 改为 $app->bind (‘Visit’, ‘Leg’); 就可以。这样子，使用何种方式去青藏，我们可以自由的选择.

我们站在 Laravel 框架设计者的角度去想，设计者肯定希望一个框架提供的功能越多越好，但是又要保证强大的同时又不会限制使用者。最好可以保证使用者想实现什么奇怪的需求都可以。那么功能强大但是又不局限的最好方法就是什么都不做，提供一个强大的 IoC 容器。所有需要实现的功能都变成一个个服务，需要什么服务就把服务注册 (即调用 bind 函数) 到 IoC 中，然后让 IoC 去管理依赖.

开发者想到一个变态的需求：走路去青藏，那么只要你实现了走路去青藏这个功能，然后把这个功能当做一个服务注册到 IoC 中，以后你需要这个服务的时候 IoC 就帮你实例化这个服务。当开发者回归正常之后觉得还是坐火车去吧，于是不注册走路这个功能，实现坐火车的功能，然后注册这个功能。下次 IoC 实例化的时候就是实例化坐火车这个功能了.

好了，剩下的部分就是一行一行的阅读 Container 的代码了，Laravel 框架中的服务容器代码也是这个样子，只是功能更加强悍。但是核心是一样的，上面的代码懂了以后再使用 Laravel 框架就会更加游刃有余了.

文章虽短。但是内容很多。尤其是代码，虽然可能只是短短的一个例子，但是包含了很多内容。值得好好分析，这里放个彩蛋：Traveller 中构造函数参数类似为 TrafficTool, 是一个接口。但是实例化的是 Train. 这里体现了设计模式的一个原则

面对接口编程，而不是面对实现编程.