浅析 Laravel IOC 容器

简介

Laravel 的核心是一个 IOC 容器，文档上称为服务容器；服务容器提供整个框架的一系列服务，如Route、DB等服务，都是存储在容器中的；接下来将结合Container.php源码举例讲解 IOC 容器。

IOC

IOC 是(Inversion of controller)的缩写，叫做控制反转，如何理解控制反转？看下面的这段解析：

控制反转是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection, DI）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

也就是说，这个调控系统中存放一些对象的实体，或者对象的描述，在对象创建的时候将对象所依赖的对象的引用传递过去。在 Laravel 中Service Container是一个高效的调控系统，实现了依赖对象的自动注入。接下来看看 Laravel 是如何实现自动依赖注入的。

依赖注入

Laravel 中实现的依赖注入都是通过Service Container服务容器来统一管理的，实现依赖注入的方式可以是在构造函数中或者setter方法中；但是服务容器只存储了对象的描述，那究竟如何把所有的依赖函数注入进来呢？查看Container.php的源码，在build方法中找到了答案，方法的源码如下：

public function build($concrete, array $parameters = [])
{
    // If the concrete type is actually a Closure, we will just execute it and
    // hand back the results of the functions, which allows functions to be
    // used as resolvers for more fine-tuned resolution of these objects.
    if ($concrete instanceof Closure) {
        return $concrete($this, $parameters);
    }

    $reflector = new ReflectionClass($concrete);

    // If the type is not instantiable, the developer is attempting to resolve
    // an abstract type such as an Interface of Abstract Class and there is
    // no binding registered for the abstractions so we need to bail out.
    if (! $reflector->isInstantiable()) {
        if (! empty($this->buildStack)) {
            $previous = implode(', ', $this->buildStack);

            $message = "Target [$concrete] is not instantiable while building [$previous].";
        } else {
            $message = "Target [$concrete] is not instantiable.";
        }

        throw new BindingResolutionException($message);
    }

    $this->buildStack[] = $concrete;

    $constructor = $reflector->getConstructor();

    // If there are no constructors, that means there are no dependencies then
    // we can just resolve the instances of the objects right away, without
    // resolving any other types or dependencies out of these containers.
    if (is_null($constructor)) {
        array_pop($this->buildStack);

        return new $concrete;
    }

    $dependencies = $constructor->getParameters();

    // Once we have all the constructor's parameters we can create each of the
    // dependency instances and then use the reflection instances to make a
    // new instance of this class, injecting the created dependencies in.
    $parameters = $this->keyParametersByArgument(
        $dependencies, $parameters
    );

    $instances = $this->getDependencies(
        $dependencies, $parameters
    );

    array_pop($this->buildStack);

    return $reflector->newInstanceArgs($instances);
}

在第10行代码中会看到，用到了 PHP 的ReflectionClass反射类，反射解析如下：

反射它指在PHP运行状态中，扩展分析PHP程序，导出或提取出关于类、方法、属性、参数等的详细信息，包括注释。这种动态获取的信息以及动态调用对象的方法的功能称为反射API。反射是操纵面向对象范型中元模型的API，其功能十分强大，可帮助我们构建复杂，可扩展的应用。其用途如：自动加载插件，自动生成文档，甚至可用来扩充PHP语言

更多反射的理解，可以查看官方文档。通过反射机制去解析一个类，能够获取一个类里面的属性、方法、构造函数、以及构造函数需要的参数。

查看这个方法，可以知道，通过反射获取到构造函数所依赖的类，使用到了getDependencies方法来获取所有依赖，最后通过newInstanceArgs实例化所有的依赖类。

到这里，我们知道了服务容器是通过反射机制来自动注入所有的依赖关系，这也是 Laravel 服务容器强大之处。接下来将结合Container.php源码举例说明。

IOC 容器举例

下面的服务容器代码是简写版的，方便调试使用，基本实现了 Laravel 容器的核心思想，再结合例子讲解。容器源码和案例在 github 上 [laravel-container]。

<?php
/**
 * User: MinHow
 * Date: 2017/1/23
 */
//容器类，简写版的Laravel的容器类，方便测试
class Container implements ArrayAccess
{
    //用于存储提供实例的回调函数
    protected $bindings = [];

    //绑定接口和生成相应实例的回调函数
    public function bind($abstract, $concrete = null, $shared = false)
    {
        //如果提供的参数不是回调函数，则产生默认的回调函数
        if (! $concrete instanceof Closure) {
            $concrete = $this->getClosure($abstract, $concrete);
        }

        //将返回的 $concrete 赋值到 $bindings[$abstract] 上
        $this->bindings[$abstract] = compact('concrete', 'shared');
    }

    //默认生成实例的回调函数
    protected function getClosure($abstract, $concrete)
    {
        return function ($c) use ($abstract, $concrete) {
            $method = ($abstract == $concrete) ? 'build' : 'make';

            return $c->$method($concrete);
        };
    }
    //从容器中解析函数
    public function make($abstract)
    {
        $concrete = $this->getConcrete($abstract);

        //判断是否能实例化
        if ($this->isBuildable($concrete, $abstract)) {
            $object = $this->build($concrete);
        } else {
            $object = $this->make($concrete);
        }

        return $object;
    }
    //是否能实例化
    protected function isBuildable($concrete, $abstract)
    {
        return $concrete === $abstract || $concrete instanceof Closure;
    }

    //获取绑定的回调函数
    protected function getConcrete($abstract)
    {
        if (! isset($this->bindings[$abstract])) {
            return $abstract;
        }

        return $this->bindings[$abstract]['concrete'];
    }

    //实例化对象
    public function build($concrete)
    {
        //当 $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);
        //返回实例化传入类实体的实体对象 (即 $concrete)
        return $reflector->newInstanceArgs($instances);
    }

    //解决通过反射机制实例化对象时的依赖
    protected function getDependencies(array $parameters)
    {
        $dependencies = [];
        foreach ($parameters as $parameter) {
            $dependency = $parameter->getClass();
            if (is_null($dependency)) {
                $dependencies[] = NULL;
            } else {
                $dependencies[] = $this->resolveClass($parameter);
            }
        }

        return (array) $dependencies;
    }

    //解析依赖类
    protected function resolveClass(ReflectionParameter $parameter)
    {
        return $this->make($parameter->getClass()->name);
    }

    //判断 bindings[$key] 是否存在，例：isset($container['data'])
    public function offsetExists($key)
    {
        return isset($this->bindings[$key]);
    }

    //取得实例化对象，调用 make() 方法，例：$container['data']
    public function offsetGet($key)
    {
        return $this->make($key);
    }

    //设置对象，例：$container['data'] = $value
    public function offsetSet($key, $value)
    {
        // 如果 $value 不是闭包函数，就先将 $value 重新赋值为一个闭包
        if (! $value instanceof Closure) {
            $value = function () use ($value) {
                return $value;
            };
        }
        // 如果 $value 是一个闭包函数，就直接绑定
        $this->bind($key, $value);
    }

    //释放 bindings[$key]，例：unset($container['data'])
    public function offsetUnset($key)
    {
        unset($this->bindings[$key]);
    }
}

上面是服务容器的源码，下面是调用容器的案例：

<?php
/**
 * User: MinHow
 * Date: 2017/12/2
 *
 * 运行 php test.php
 */
//注册自动加载
spl_autoload_register('autoload');

function autoload($class)
{
    require './' . $class . '.php';
}
//引入Container容器类
require '../Container.php';

$app = new Container();//实例化容器
$app->bind('Car', 'Benz');//Car 是接口，Benz 是 Benz 类
$app->bind('driver', 'Driver');//driver 是 Driver 类的别名

$driver = $app->make('driver');//通过解析，得到了 Driver 类的实例

$driver->driveCar();//因为之前已经把 Car 接口绑定了 Benz，所以调用 driveCar 方法，会显示 'Driving Benz!'

案例是一个工厂模式的例子，分别定义了Benz、Bmw两个类，都实现了汽车类的接口；最后调用Driver驾驶员类的driveCar方法。
在18行实例化容器后，向$app容器中注入需要测试的类：

1 2	$app->bind('Car', 'Benz');//Car 是接口，Benz 是 Benz 类 $app->bind('driver', 'Driver');//driver 是 Driver 类的别名

当执行完上述两行代码后，输出$app容器如下：

object(Container)#1 (1) {
  ["bindings":protected]=>
  array(2) {
    ["Car"]=>
    array(2) {
      ["concrete"]=>
      object(Closure)#2 (3) {
        ["static"]=>
        array(2) {
          ["abstract"]=>
          string(3) "Car"
          ["concrete"]=>
          string(4) "Benz"
        }
        ["this"]=>
        *RECURSION*
        ["parameter"]=>
        array(1) {
          ["$c"]=>
          string(10) "<required>"
        }
      }
      ["shared"]=>
      bool(false)
    }
    ["driver"]=>
    array(2) {
      ["concrete"]=>
      object(Closure)#3 (3) {
        ["static"]=>
        array(2) {
          ["abstract"]=>
          string(6) "driver"
          ["concrete"]=>
          string(6) "Driver"
        }
        ["this"]=>
        *RECURSION*
        ["parameter"]=>
        array(1) {
          ["$c"]=>
          string(10) "<required>"
        }
      }
      ["shared"]=>
      bool(false)
    }
  }
}

可以看到，容器里的bindings已经绑定了Car和driver两个数组，当执行$driver = $app->make('driver');这段代码的
时候，就通过容器类的make方法，通过闭包函数回调解析依赖的类，大概流程如下：

解析driver的时候，根据容器类的driver，获取到Driver的字符串。
递归将Driver传入build方法，这里的Driver就是class Driver，然后通过反射方法new ReflectionClass('Driver')，实例化了Driver类。
通过getConstructor和getParameters方法，知道class Driver和接口Car存在依赖关系。
再通过getDependencies方法循环实例化构造函数所有的依赖，就得到了Benz的实例。
$instances的存放的就是Benz的实例，最后通过$reflector->newInstanceArgs($instances)方法得到了Driver的实例。