前言
服务容器是 Laravel 框架实现模块化解耦的核心。模块化即是将系统拆成多个子模块，子模块间的耦合程度尽可能的低，代码中尽可能的避免直接调用。这样才能提高系统的代码重用性、可维护性、扩展性。
下边出行例子有火车、飞机两种出行方式，对应给出了 3 种耦合度越来越低的实现：高度耦合实现、工厂模式解耦、IOC 模式解耦。
高度耦合实现
代码实现
定义 TrafficTool 接口并用 Train、Plane 实现，最后在 Traveler 中实例化出行工具后说走就走。代码十分简洁：
<?php
// 定义交通工具接口
interface TrafficTool
{
public function go();
}
class Train implements TrafficTool
{
public function go() {
echo '[Travel By]: train', PHP_EOL;
}
}
class Plane implements TrafficTool
{
public function go() {
echo '[Travel By]: plane', PHP_EOL;
}
}
// 旅游者类，使用火车出行
class Traveler
{
protected $trafficTool;
public function __construct() {
// 直接 new 对象，在 Traveler 与 Train 两个类之间产生了依赖
// 如果程序内部要修改出行方式，必须修改 Traveler 的 __construct()
// 代码高度耦合，可维护性低
$this->travelTool = new Train();
}
public function travel() {
$this->travelTool->go();
}
}
$me = new Traveler();
$me->travel();运行：
$ php normal.php
[Travel By]: train优点
代码十分简洁：一个接口两个类最后直接调用。
缺点
在第 32 行，Traveler 与 Train 两个组件发生了耦合。以后想坐飞机出行，必须修改 __construct() 的内部实现：$this->travelTool = new Plane();
重用性和可维护性都很差：在实际的软件开发中，代码会根据业务需求的变化而不断修改。如果组件之间直接相互调用，那组件的代码就不能轻易修改，以免调用它的地方出现错误。
工厂模式解耦
工厂模式
分离代码中不变和变的部分，使得在不同条件下创建不同的对象。
代码实现
...
class TrafficToolFactory
{
public function create($name) {
switch ($name) {
case 'train':
return new Train();
case 'plane':
return new Plane();
default:
exit('[No Traffic Tool] :' . $name);
}
}
}
// 旅游者类，使用火车出行
class Traveler
{
protected $trafficTool;
public function __construct($toolName) {
// 使用工厂类实例化需要的交通工具
$factory = new TrafficToolFactory();
$this->travelTool = $factory->create($toolName);
}
public function travel() {
$this->travelTool->go();
}
}
// 传入指定的方式
$me = new Traveler('train');
$me->travel();运行：
$ php factory.php
[Travel By]: train优点
提取了代码中变化的部分：更换交通工具，坐飞机出行直接修改 $me = new Traveler('plane') 即可。适用于需求简单的情况。
缺点
依旧没有彻底解决依赖：现在 Traveler 与 TrafficToolFactory 发生了依赖。当需求增多后，工厂的 switch...case 等代码也不易维护。
IOC 模式解耦
IOC 是 Inversion Of Controll 的缩写，即控制反转。这里的“反转”可理解为将组件间依赖关系提到外部管理。
简单的依赖注入
依赖注入是 IOC 的一种实现方式，是指组件间的依赖通过外部参数（interface）形式直接注入。比如对上边的工厂模式进一步解耦：
<?php
interface TrafficTool
{
public function go();
}
class Train implements TrafficTool
{
public function go() {
echo '[Travel By]: train', PHP_EOL;
}
}
class Plane implements TrafficTool
{
public function go() {
echo '[Travel By]: plane', PHP_EOL;
}
}
class Traveler
{
protected $trafficTool;
// 参数 $tool 就是控制反转要反转部分，将依赖的对象直接传入即可
// 以后再有 Car, GetWay ... 等新增工具也是实例化后传参直接调用
public function __construct(TrafficTool $tool) {
$this->trafficTool = $tool;
}
public function travel() {
$this->trafficTool->go();
}
}
$train = new Train();
$me = new Traveler($train); // 将依赖直接以参数的形式注入
$me->travel();运行：
$ php simple_ioc.php
[Travel By]: train高级依赖注入
简单注入的问题
如果三个人分别自驾游、坐飞机、高铁出去玩，那你的代码可能是这样的：
$train = new Train();
$plane = new Plane();
$car = new Car();
$a = new Traveler($car);
$b = new Traveler($plane);
$c = new Traveler($train);
$a->travel();
$b->travel();
$c->travel();看起来就两个字：蓝瘦。上边简单的依赖注入相比工厂模式已经解耦挺多了，参考 Laravel 中服务容器的概念，还能继续解耦。将会使用到 PHP 反射和匿名函数，参考：Laravel 框架中常用的 PHP 语法
IOC 容器
高级依赖注入 = 简单依赖注入 + IOC 容器
<?php
# advanced_ioc.php
...
class Container
{
protected $binds = [];
protected $instances = [];
/**
* 绑定：将回调函数绑定到字符指令上
*
* @param $abstract 字符指令，如 'train'
* @param $concrete 用于实例化组件的回调函数，如 function() { return new Train(); }
*/
public function bind($abstract, $concrete) {
if ($concrete instanceof Closure) {
// 向容器中添加可以执行的回调函数
$this->binds[$abstract] = $concrete;
} else {
$this->instances[$abstract] = $concrete;
}
}
/**
* 生产：执行回调函数
*
* @param $abstract 字符指令
* @param array $params 回调函数所需参数
* @return mixed 回调函数的返回值
*/
public function make($abstract, $params = []) {
if (isset($this->instances[$abstract])) {
return $this->instances[$abstract];
}
// 此时 $this 是有 2 个元素的数组
// Array (
// [0] => Container Object (
// [binds] => Array ( ... )
// [instances] => Array()
// )
// [1] => "train"
// )
array_unshift($params, $this);
// 将参数传递给回调函数
return call_user_func_array($this->binds[$abstract], $params);
}
}
$container = new Container();
$container->bind('traveler', function ($container, $trafficTool) {
return new Traveler($container->make($trafficTool));
});
$container->bind('train', function ($container) {
return new Train();
});
$container->bind('plane', function ($container) {
return new Plane();
});
$me = $container->make('traveler', ['train']);
$me->travel();运行：
$ php advanced_ioc.php
[Travel By]: train简化并解耦后的代码
那三个人再出去玩，代码将简化为：
$a = $container->make('traveler', ['car']);
$b = $container->make('traveler', ['train']);
$c = $container->make('traveler', ['plane']);
$a->travel();
$b->travel();
$c->travel();更多参考：神奇的服务容器
Laravel 的服务容器
Laravel 自己的服务容器是一个更加高级的 IOC 容器，它的简化代码如下：
<?php
# laravel_ioc.php
...
class Container
{
// 绑定回调函数
public $binds = [];
// 绑定接口 $abstract 与回调函数
public function bind($abstract, $concrete = null, $shared = false) {
if (!$concrete instanceof Closure) {
$concrete = $this->getClosure($abstract, $concrete);
}
$this->binds[$abstract] = compact('concrete', 'shared');
}
// 获取回调函数
public function getClosure($abstract, $concrete) {
return function ($container) use ($abstract, $concrete) {
$method = ($abstract == $concrete) ? 'build' : 'make';
return $container->$method($concrete);
};
}
protected function getConcrete($abstract) {
if (!isset($this->binds[$abstract])) {
return $abstract;
}
return $this->binds[$abstract]['concrete'];
}
// 生成实例对象
public function make($abstract) {
$concrete = $this->getConcrete($abstract);
if ($this->isBuildable($abstract, $concrete)) {
$obj = $this->build($concrete);
} else {
$obj = $this->make($concrete);
}
return $obj;
}
// 判断是否要用反射来实例化
protected function isBuildable($abstract, $concrete) {
return $concrete == $abstract || $concrete instanceof Closure;
}
// 通过反射来实例化 $concrete 的对象
public function build($concrete) {
if ($concrete instanceof Closure) {
return $concrete($this);
}
$reflector = new ReflectionClass($concrete);
if (!$reflector->isInstantiable()) {
echo "[can't instantiable]: " . $concrete;
}
$constructor = $reflector->getConstructor();
// 使用默认的构造函数
if (is_null($constructor)) {
return new $concrete;
}
$refParams = $constructor->getParameters();
$instances = $this->getDependencies($refParams);
return $reflector->newInstanceArgs($instances);
}
// 获取实例化对象时所需的参数
public function getDependencies($refParams) {
$deps = [];
foreach ($refParams as $refParam) {
$dep = $refParam->getClass();
if (is_null($dep)) {
$deps[] = null;
} else {
$deps[] = $this->resolveClass($refParam);
}
}
return (array)$deps;
}
// 获取参数的类型类名字
public function resolveClass(ReflectionParameter $refParam) {
return $this->make($refParam->getClass()->name);
}
}
$container = new Container();
// 将 traveller 对接到 Train
$container->bind('TrafficTool', 'Train');
$container->bind('traveller', 'Traveller');
// 创建 traveller 实例
$me = $container->make('traveller');
$me->travel();运行：
$ php laravel_ioc.php
[Travel By]: trainTrain 类要能被实例化，需要先注册到容器，这就涉及到 Laravel 中服务提供者（Service Provider）的概念了。至于服务提供者是怎么注册类、注册之后如何实例化、实例化后如何调用的… 下节详细分析。
总结
本文用一个旅游出行的 demo，引出了高度耦合的直接实现、工厂模式解耦和 IOC 模式解耦共计三种实现方式，越往后代码量越多还有些绕，但类（模块）之间的耦合度越来越低，最后实现了简化版的 Laravel 服务容器。
Laravel 的优美得益于开发的组件式解耦，这与服务容器和服务提供者的理念是离不开的，下篇将用 Laravel 框架 laravel/framework/src/Illuminate/Container.php 中 Container 类来梳理 Laravel 服务容器的工作流程。
