Laravel源码解析 — 服务容器-662P.COM

前言

本文对将系统的对 Laravel 框架知识点进行总结，如果错误的还望指出

阅读书籍

《Laravel框架关键技术解析》陈昊

学习课程

Laravel5.4快速开发简书网站轩脉刃
Laravel重构企业级电商项目檀梵

服务容器

1.什么是IoC

IOC 模式，不是一种技术，而是一种设计思想。在应用程序开发中，IoC 意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制，也是一种面向接口编程的思想。

当我们以面向接口编程的时候，程序中实例之间的耦合将上升到接口层次，而不是代码实现层次，使用配置文件来实现类的耦合。

容器的作用很简单，将在代码中使用像（new object）这样语法进行耦合的方式，改为配置文件来管理耦合，通过这种改变，从而保证系统重构或者业务逻辑改变时，不会发生“牵一发而动全身”的效果，从而有更好的可扩展性、可维护性。

总结：借助于“第三方”实现具有依赖关系的对象之间的解耦。

举个栗子

在日常开发应用中，我们要实现一个功能，在用户处理模块中调用获取用户信息Model，通常是使用像（new object）这样的语法，在用户处理模块中将对象创造出来，这时代码依赖耦合就出现了，在获取用户信息 Model时则需要修改用户处理模块里的代码。

而调用 IoC 容器则将依赖耦合上升到接口层次，只需要修改容器注册时所绑定的服务即可。

其中涉及到 依赖注入、控制反转、反射 的思想

2.控制反转

控制反转是将组件间的依赖关系从程序内部提到外部容器来管理，那么就会出现，谁控制谁？反转是什么？有正转吗？

上述流程图中

应用程序自身调用
用户处理模块 创建了 获取用户信息Model ，那么 用户处理模块 控制了 获取用户信息Model ，这种创建过程称为正转
IoC 模式调用
创建权 交给了 IoC容器，由 Ioc 容器去创建 获取用户信息Model ，那么 Ioc 容器控制了 获取用户信息Model ，这种创建过程称为反转

正转：由程序本身在对象中主动控制去直接获取依赖对象

反转：由容器来帮忙建立及注入依赖对象

3.依赖注入（DI）

理解依赖注入我们需要先理解什么是依赖，再理解依赖注入

依赖

在应用程序开发中由于某客户类依赖于某个服务类称为依赖

例：

// 实现不同交通工具类
// 腿着
class Leg
{
    public function go()
    {
        echo 'walk to Tibet！！！';
    }
}

// 开车
class Car
{
    public function go()
    {
        echo 'drive car to Tibet！！！';
    }
}

// 列车
class Train
{
    public function go()
    {
        echo 'go to Tibet！！！';
    }
}

// 设计旅游者类，该类在实现游西藏的功能时要依赖交通工具类
class Traveller
{
    private $trafficTool;

    public function __construct()
    {
        $this->trafficTool = new Leg();
    }

    public function viisitTibet()
    {
        $this->trafficTool->go();
    }
}

$app = new Traveller();
$app->viisitTibet();

上述实例就是一个依赖的过程，当创建一个 Traveller 实例的时候，构造函数中获取了（new Object）其中一个交通工具服务类，这时依赖就产生了，客户类（Traveller）依赖于服务类（Leg），在实际开发中需求经常改动，那么如果直接修改客户类的代码就非常繁琐并且不利于维护。

依赖注入

动态的向某个对象提供它所需要的其他对象，指组件的依赖通过外部以参数或其他形式注入，不在客户类里面用（new object）的方式去实例化服务类而转由外部来负责，并且面向接口编程，将参数转为接口类，而不是具体的某个实现类，拓展性更强。

例：

// 设计公共接口
interface Visit
{
    public function go();
}
// 实现不同交通工具类
// 腿着
class Leg implements Visit
{
    public function go()
    {
        echo 'walk to Tibet！！！';
    }
}
// 开车
class Car implements Visit
{
    public function go()
    {
        echo 'drive car to Tibet！！！';
    }
}
// 列车
class Train implements Visit
{
    public function go()
    {
        echo 'go to Tibet！！！';
    }
}
// 设计旅游者类，该类在实现游西藏的功能时要依赖交通工具类
class Traveller
{
    private $trafficTool;

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

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

// 生成的交通工具依赖
$trafficTool = new Leg();
// 依赖注入的方式解决依赖问题
$app = new Traveller($trafficTool);
$app->visitTibet();

上述实例就是一个依赖注入的过程，当创建一个 Traveller 实例的时候，构造函数依赖一个外部的具有 Visit 接口的实例，我们传递一个 Leg 实例，即通过依赖注入的方式解决依赖问题。

这里要注意的是，依赖注入需要通过接口来限制，不能随意开放，这也体现了设计模式的另一个原则——针对接口编程，而不是针对实现编程。

4.反射

什么是反射

PHP 反射机制是指在程序运行状态中，动态获取信息以及动态调用对象。

这种动态获取信息以及动态调用对象的方法的功能称为反射 API。

PHP 中获取实例的信息是通过 Reflection 实现

反射作用

为什么要使用反射机制？直接创建（new）对象不就可以了吗？

先理解动态调用对象与静态调用对象的区别

动态调用对象

通过类的路径或别名获取关于类、方法、属性、参数等详细信息，包括注释，就算类成员定义为 private 也可以在外部访问。

静态调用对象

通过使用（new Object）的方式获取类的实例。

代码灵活性

而编译性语言区别更为明显，静态调用对象在编译时确定实例的类型，绑定对象，动态调用对象则是在运行时确定实例的类型，提高了编译性语言的灵活性，降低类之间的耦合

为什么要使用反射机制

这样就可以把调用一个实例的行为写成一个类的方法或者创建函数，然后统一接口调用创建函数来创建实例对象，有点像工厂方法模式+面向接口编程的思想，这个类的方法和创建函数则是 IoC 容器

举个栗子

<?php

class B
{

}

class A
{

    public function __construct(B $args)
    {
    }

    public function demo()
    {
        echo 'Hello world';
    }
}

//建立class A 的反射
$reflectionClass = new ReflectionClass('A');

$b = new B();

// 创建 class A 的实例
$instance = $reflectionClass->newInstanceArgs([$b]);
// 执行实例中的方法，输出 ‘Hellow World’
$instance->demo();
// 获取class A 的构造函数相关信息
$constructor = $reflectionClass->getConstructor();
/**
 * 获取class A 构造函数参数的相关信息
 * 参数数组
 */
$dependencies = $constructor->getParameters();
foreach ($dependencies as $dependencie) {
    var_dump($dependencie->getClass());
    die;
}
// 获取class A 的构造函数
var_dump($constructor);
// 获取class A 的构造函数相关信息
var_dump($dependencies);

5.再看IoC容器

我们再来看一下 IoC 容器的概念在日常开发应用中，我们在A服务中调用B服务要实现一个功能，或者要调用一个对象时都要使用像（new object）这样的语法，将对象创造出来，这时你需要关心这个对象是什么，在哪里，如何创建，然后再创建，这时就出现了代码耦合，而IoC 容器就好比 ”大象放进冰箱，大象取进冰箱，需要几步“，需要三步

把冰箱门打开 2. 把大象放进去 3. 把冰箱门关上
把冰箱门打开 2. 把大象取出来 3. 把冰箱门关上

你不需要关心大象在哪，具体哪个大象，如何放进去，如何取出来，你只需要做到放和取这个动作就行了，这样就避免了代码耦合，而

放大象，则需要将大象放到或者注册到（bind）容器里

取大象，则需要将大象取出（make）就可以

服务容器可以理解为进阶版的工厂模式，更是一种面向接口编程的思想。

工厂模式的大量应用降低了代码重复量以及利用率，但是依然还需要调用者去定位工厂。

最理想的情况是，调用者无需关心调用者的实现，也无需定位工厂，而面向接口配置化。

6.IoC容器代码

来看一段 IoC 容器代码，下面这段代码对 Laravel 的设计方法进行了简化，不是 Laravel 的源码，而是来自一本书《laravel 框架关键技术解析》，这段代码很好的还原了 laravel 的服务容器的核心思想，代码有点长，可以尝试运行调试一下，这样易于理解：

// 设计容器类，容器类装实例或提供实例的回调函数
class Container
{
    // 容器绑定数组
    // 用于装提供实例的回调函数，真正的容器还会装实例等其他内容，从而实现单例等高级功能
    protected $bindings = [];

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

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

    // 默认生成实例的回调函数
    public function getClosure($abstract, $concrete)
    {
        // 生成实例的回调函数，$c 一般为 IoC 容器对象，在调用回调生成实例时提供
        // 即 build 函数中的 $concrete($this)
        return function ($c) use ($abstract, $concrete) {
            $method = ($abstract == $concrete) ? 'build' : 'make';
            // 调用的是容器的 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)
    {
        if ($concrete instanceof Closure) {
            return $concrete($this);
        }
        // ReflectionClass 类报告了一个类的有关信息
        $reflector = new ReflectionClass($concrete);
        // 检查类是否可实例化 return bool|false
        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);
    }

    protected function getDependencies($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);
    }
}

上面的代码就生成了一个容器，下面是如何使用容器

// 实例化 IoC 容器
$app = new Container();
// 完成容器的填充
$app->bind("traveller", "Traveller");
$app->bind("Visit", "Train");

// 通过容器实现依赖注入，完成类的实例化
$tra = $app->make("traveller");
$tra->visitTibet();
$tra = $app->make("Visit");
$tra->go();

代码解析

当实例化一个容器类（Container）后，向容器中填充服务

$app->bind("traveller", "Traveller");
$app->bind("Visit", "Train");

绑定完成后，查看容器 $bindings 绑定的值

array(2) {
  ["traveller"]=>
  array(2) {
    ["concrete"]=>
    object(Closure)#2 (3) {
      ["static"]=>
      array(2) {
        ["abstract"]=>
        string(9) "traveller"
        ["concrete"]=>
        string(9) "Traveller"
      }
      ["this"]=>
      object(Container)#1 (1) {
        ["bindings":protected]=>
        array(2) {
          ["traveller"]=>
          *RECURSION*
          ["Visit"]=>
          array(2) {
            ["concrete"]=>
            object(Closure)#3 (3) {
              ["static"]=>
              array(2) {
                ["abstract"]=>
                string(5) "Visit"
                ["concrete"]=>
                string(5) "Train"
              }
              ["this"]=>
              *RECURSION*
              ["parameter"]=>
              array(1) {
                ["$c"]=>
                string(10) "<required>"
              }
            }
            ["shared"]=>
            bool(false)
          }
        }
      }
      ["parameter"]=>
      array(1) {
        ["$c"]=>
        string(10) "<required>"
      }
    }
    ["shared"]=>
    bool(false)
  }
  ["Visit"]=>
  array(2) {
    ["concrete"]=>
    object(Closure)#3 (3) {
      ["static"]=>
      array(2) {
        ["abstract"]=>
        string(5) "Visit"
        ["concrete"]=>
        string(5) "Train"
      }
      ["this"]=>
      object(Container)#1 (1) {
        ["bindings":protected]=>
        array(2) {
          ["traveller"]=>
          array(2) {
            ["concrete"]=>
            object(Closure)#2 (3) {
              ["static"]=>
              array(2) {
                ["abstract"]=>
                string(9) "traveller"
                ["concrete"]=>
                string(9) "Traveller"
              }
              ["this"]=>
              *RECURSION*
              ["parameter"]=>
              array(1) {
                ["$c"]=>
                string(10) "<required>"
              }
            }
            ["shared"]=>
            bool(false)
          }
          ["Visit"]=>
          *RECURSION*
        }
      }
      ["parameter"]=>
      array(1) {
        ["$c"]=>
        string(10) "<required>"
      }
    }
    ["shared"]=>
    bool(false)
  }
}

当执行 $tra = $app->make("traveller"); 时，程序就会用调用 make 方法，判断是否已经绑定实例，若已绑定好则调用 build 获取已经绑定好的闭包函数，开始解析，闭包函数在 build 方法中会执行 return $concrete($this) 将当前类作为参数为闭包函数传参，最终又会执行到 build 方法，类似于递归调用，最后执行的 build 方法中 $concrete的值为字符串 Traveller，通过反射获取 class Traveller 的类有关信息，再进行下一步

$reflector->isInstantiable() // 检查类是否可实例化 return bool|false，

$reflector->getConstructor(); //获取类的构造函数

$constructor->getParameters(); // 获取类构造函数的参数

再获取构造函数中每个参数是否含依赖，$this->getDependencies($dependencies)，这个方法知道了 class Traveller 含有依赖类 Visit ，我们要做的就是解决这个依赖

// $dependency
object(ReflectionClass)#7 (1) {
  ["name"]=>
  string(5) "Visit"
}

通过 getDependencies ($parameters) 中的 $parameter->getClass() 获取到依赖类 Visit，再调用 resolveClass (ReflectionParameter $parameter) 就会发现之前的为什么要 bind 接口类，而不用具体实现类的原因了，因为通过接口类的名称，在容易中获得实例，会获取到所对应的具体实现类，$app->bind("Visit", "Train");

最后我们通过 return $reflector->newInstanceArgs($instances); 获取到了 Train 的具体实现类。

array(1) {
  [0]=>
  object(Train)#9 (0) {
  }
}

到这里 IoC 的流程就结束了，这就是其中控制反转、依赖注入，闭包，反射等概念的关系及应用。

lavarel

前言