详解如何实现Laravel的服务容器的方法示例

1. 容器的本质

// 服务容器$container = [  // 原始值  'text' => '这是一个字符串',  // 自定义服务名  'customname' => new stdclass(),  // 使用类名作为服务名  'stdclass' => new stdclass(),  // 使用接口名作为服务名  'namespace\\stdclassinterface' => new stdclass(),];// ----------- ↓↓↓↓示例代码↓↓↓↓ ----------- //// 绑定服务到容器$container['standard'] = new stdclass();// 获取服务$standard = $container['standard'];var_dump($standard);

2. 封装成类

为了方便维护，我们把上面的数组封装到类里面。

$instances还是上面的容器数组。我们增加两个方法，instance用来绑定服务，get用来从容器中获取服务。

class bacontainer{  // 已绑定的服务  protected $instances = [];  // 绑定服务  public function instance($name, $instance)  {    $this->instances[$name] = $instance;  }  // 获取服务  public function get($name)  {    return ist($this->instances[$name]) ? $this->instances[$name] : null;  }}// ----------- ↓↓↓↓示例代码↓↓↓↓ ----------- //$container = new bacontainer();// 绑定服务$container->instance('stdclass', new stdclass());// 获取服务$stdclass = $container->get('stdclass');var_dump($stdclass);

3. 按需实例化

现在我们在绑定一个对象服务的时候，就必须要先把类实例化，如果绑定的服务没有被用到，那么类就会白白实例化，造成性能浪费。

为了解决这个问题，我们增加一个bind函数，它支持绑定一个回调函数，在回调函数中实例化类。这样一来，我们只有在使用服务时，才回调这个函数，这样就实现了按需实例化。

这时候，我们获取服务时，就不只是从数组中拿到服务并返回了，还需要判断如果是回调函数，就要执行回调函数。所以我们把get方法的名字改成make。意思就是生产一个服务，这个服务可以是已绑定的服务，也可以是已绑定的回调函数，也可以是一个类名，如果是类名，我们就直接实例化该类并返回。

然后，我们增加一个新数组$bindings，用来存储绑定的回调函数。然后我们把bind方法改一下，判断下$instance如果是一个回调函数，就放到$bindings数组，否则就用make方法实例化类。

class defercontainer extend bacontainer{  // 已绑定的回调函数  protected $bindings = [];  // 绑定服务  public function bind($name, $instance)  {    if ($instance instanceof closure) {      // 如果$instance是一个回调函数，就绑定到bindings。      $this->bindings[$name] = $instance;    } el {      // 调用make方法，创建实例      $this->instances[$name] = $this->make($name);    }  }  // 获取服务  public function make($name)  {    if (ist($this->instances[$name])) {      return $this->instances[$name];    }    if (ist($this->bindings[$name])) {      // 执行回调函数并返回      $instance = call_ur_func($this->bindings[$name]);    } el {      // 还没有绑定到容器中，直接new.      $instance = new $name();    }    return $instance;  }}// ----------- ↓↓↓↓示例代码↓↓↓↓ ----------- //$container = new defercontainer();// 绑定服务$container->bind('stdclass', function () {  echo "我被执行了\n";  return new stdclass();});// 获取服务$stdclass = $container->make('stdclass');var_dump($stdclass);

stdclass这个服务绑定的是一个回调函数，在回调函数中才会真正的实例化类。如果没有用到这个服务，那回调函数就不会被执行，类也不会被实例化。

4. 单例

从上面的代码中可以看出，每次调用make方法时，都会执行一次回调函数，并返回一个新的类实例。但是在某些情况下，我们希望这个实例是一个单例，无论make多少次，只实例化一次。

这时候，我们给bind方法增加第三个参数$shared，用来标记是否是单例，默认不是单例。然后把回调函数和这个标记都存到$bindings数组里。

为了方便绑定单例服务，再增加一个新的方法singleton，它直接调用bind，并且$shared参数强制为true。

对于make方法，我们也要做修改。在执行$bindings里的回调函数以后，做一个判断，如果之前绑定时标记的shared是true，就把回调函数返回的结果存储到$instances里。由于我们是先从$instances里找服务，所以这样下次再make的时候就会直接返回，而不会再次执行回调函数。这样就实现了单例的绑定。

class singletoncontainer extends defercontainer{  // 绑定服务  public function bind($name, $instance, $shared = fal)  {    if ($instance instanceof closure) {      // 如果$instance是一个回调函数，就绑定到bindings。      $this->bindings[$name] = [        'callback' => $instance,        // 标记是否单例        'shared' => $shared      ];    } el {      // 调用make方法，创建实例      $this->instances[$name] = $this->make($name);    }  }  // 绑定一个单例  public function singleton($name, $instance)  {    $this->bind($name, $instance, true);  }  // 获取服务  public function make($name)  {    if (ist($this->instances[$name])) {      return $this->instances[$name];    }    if (ist($this->bindings[$name])) {      // 执行回调函数并返回      $instance = call_ur_func($this->bindings[$name]['callback']);      if ($this->bindings[$name]['shared']) {        // 标记为单例时，存储到服务中        $this->instances[$name] = $instance;      }    } el {      // 还没有绑定到容器中，直接new.      $instance = new $name();    }    return $i王维字nstance;  }}// ----------- ↓↓↓↓示例代码↓↓↓↓ ----------- //$container = new singletoncontainer();// 绑定服务$container->singleton('anonymous', function () {  return new class  {    public function __construct()    {      echo "我被实例化了\n";    }  };});// 无论make多少次，只会实例化一次$container->make('anonymous');$container->make('anonymous');// 获取服务$anonymous = $container->make('anonymous');var_dump($anonymous)

上面的代码用singleton绑定了一个名为anonymous的服务，回调函数里返回了一个匿名类的实例。这个匿名类在被实例化时会输出一段文字。无论我们make多少次anonymous，这个回调函数只会被执行一次，匿名类也只会被实例化一次。

5. 自动注入

自动注入是ioc容器的核心，没有自动注入就无法做到控制反转。

自动注入就是指，在实例化一个类时，用反射类来获取__construct所需要的参数，然后根据参数的类型，从容器中找到已绑定的服务。我们只要有了__construct方法所需的所有参数，就能自动实例化该类，实现自动注入。

现在，我们增加一个build方法，它只接收一个参数，就是类名。build方法会用反射类来获取__construct方法所需要的参数，然后返回实例化结果。

另外一点就是，我们之前在调用make方法时，如果传的是一个未绑定的类，我们直接new了这个类。现在我们把未绑定的类交给build方法来构建，因为它支持自动注入。

class injectioncontainer extends singletoncontainer{  // 获取服务  public function make($name)  {    if (ist($this->instances[$name])) {      return $this->instances[$name];    }    if (ist($this->bindings[$name])) {      // 执行回调函数并返回      $instance = call_ur_func($this->bindings[$name]['callback']);      if ($this->bindings[$name]['shared']) {        // 标记为单例时，存储到服务中        $this->instances[$name] = $instance;      }    } el {      // 使用build方法构建此类      $instance = $this->build($name);    }    return $instance;  }  // 构建一个类，并自动注入服务  public function build($class)  {    $reflector = new reflectionclass($class);    $constructor = $reflector->getconstructor();    if (is_null($constructor)) {      // 没有构造函数，直接new      return new $class();    }    $dependencies = [];    // 获取构造函数所需的参数    foreach ($constructor->getparameters() as $dependency) {      if (is_null($dependency->getclass())) {        // 参数类型不是类时，无法从容器中获取依赖        if ($dependency->isdefaultvalueavailable()) {          // 查找参数的默认值，如果有就使用默认值          $dependencies[] = $dependency->getdefaultvalue();        } el {          // 无法提供类所依赖的参数          throw new exception('找不到依赖参数：' . $dependency->getname());        }      } el {        // 参数类型是类时，就用make方法构建该类        $dependencies[] = $this->make($dependency->getclass()->name);      }    }    return $reflector->newinstanceargs($dependencies);  }}// ----------- ↓↓↓↓示例代码↓↓↓↓ ----------- //class redis{}class cache{  protected $redis;  // 构造函数中依赖redis服务  public function __construct(redis $redis)  {    $this->redis = $redis;  }}$container = new injectioncontainer();// 绑定redis服务$container->singleton(redis::class, function () {  return new redis();});// 构建cache类$cache = $container->make(cache::class);var_dump($cache);

6. 自定义依赖参数

现在有个问题，如果类依赖的参数不是类或接口，只是一个普通变量，这时候就无法从容器中获取依赖参数了，也就无法实例化类了。

那么接下来我们就支持一个新功能，在调用make方法时，支持传第二个参数$parameters，这是一个数组，无法从容器中获取的依赖，就从这个数组中找。

当然，make方法是用不到这个参数的，因为它不负责实例化类，它直接传给build方法。在build方法寻找依赖的参数时，就先从$parameters中找。这样就实现了自定义依赖参数。

需要注意的一点是，build方法是按照参数的名字来找依赖的，所以parameters中的键名也必须跟__construct中参数名一致。

class parameterscontainer extends injectioncontainer{  // 获取服务  public function make($name, array $parameters = [])  {    if (ist($this->instances[$name])) {      return $this->instances[$name];    }    if (ist($this->bindings[$name])) {      // 执行回调函数并返回      $instance = call_ur_func($this->bindings[$name]['callback']);      if ($this->bindings[$name]['shared']) {        // 标记为单例时，存储到服务中        $this->instances[$name] = $instance;      }    } el {      // 使用build方法构建此类      $instance = $this->build($name, $parameters);    }    return $instance;  }  // 构建一个类，并自动注入服务  public function build($class, array $parameters = [])  {    $reflector = new reflectionclass($class);    $constructor = $reflector->getconstructor();    if (is_null($constructor)) {      // 没有构造函数，直接new      return new $class();    }    $dependencies = [];    // 获取构造函数所需的参数    foreach ($constructor->getparameters() as $dependency) {      if (ist($parameters[$dependency->getname()])) {        // 先从自定义参数中查找        $dependencies[] = $parameters[$dependency->getname()];        continue;      }      if (is_null($dependency->getclass())) {        // 参数类型不是类或接口时，无法从容器中获取依赖        if ($dependency->isdefaultvalueavailable()) {          // 查找默认值，如果有就使用默认值          $dependencies[] = $dependency->getdefaultvalue();        } el {          // 无法提供类所依赖的参数          throw new exception('找不到依赖参数：' . $dependency->getname());        }      } el {        // 参数类型是类时，就用make方法构建该类        $dependencies[] = $this->make($dependency->getclass()->name);      }    }    return $reflector->newinstanceargs($dependencies);  }}// ----------- ↓↓↓↓示例代码↓↓↓↓ ----------- //class redis{}class cache{  protected $redis;  protected $name;  protected $default;  // 构造函数中依赖redis服务和name参数，name的类型不是类，无法从容器中查找  public function __construct(redis $redis, $name, $default = '默认值')  {    $this->redis = $redis;    $this->name = $name;    $this->default = $default;  }}$container = new parameterscontainer();// 绑定redis服务$container->singleton(redis::class, function () {  return new redis();});// 构建cache类$cache = $container->make(cache::class, ['name' => 'test']);var_dump($cache);

提示：实际上，laravel容器的build方法并没有第二个参数$parameters，它是用类属性来维护自定义参数。原理都是一样的，只是实现方式不一样。这里为了方便理解，不引入过多概念。

7. 服务别名

别名可以理解成小名、外号。服务别名就是给已绑定的服务设置一些外号，使我们通过外号也能找到该服务。

这个就比较简单了，我们增加一个新的数组$alias，用来存储别名。再增加一个方法alias，用来让外部注册别名。

唯一需要我们修改的地方，就是在make时，要先从$alias中找到真实的服务名。

class aliascontainer extends parameterscontainer{  // 服务别名  protected $alias = [];  // 给服务绑定一个别名  public function alias($alias, $name)  {    $this->alias[$alias] = $name;  }  // 获取服务  public function make($name, array $parameters = [])  {    // 先用别名查找真实服务名    $name = ist($this->alias[$name]) ? $this->alias[$name] : $name;    return parent::make($name, $parameters);  }}// ----------- ↓↓↓↓示例代码↓↓↓↓ ----------- //$container = new aliascontainer();// 绑定服务$container->instance('text', '这是一个字符串');// 给服务注册别名$container->alias('string', 'text');$container->alias('content', 'text');var_dump($container->make('string'));var_dump($container->make('content'));

8. 扩展绑定

有时候我们需要给已绑定的服务做一个包装，这时候就用到扩展绑定了。我们先看一个实际的用法，理解它的作用后，才看它是如何实现的。

// 绑定日志服务$container->singleton('log', new log());// 对已绑定的服务再次包装$container->extend('log', function(log $log){  // 返回了一个新服务  return new redislog($log);});

现在我们看它是如何实现的。增加一个$extenders数组，用来存放扩展器。再增加一个extend方法，用来注册扩展器。

然后在make方法返回$instance之前，按顺序依次调用之前注册的扩展器。

class extendcontainer extends aliascontainer{  // 存放扩展器的数组  protected $extenders = [];  // 给服务绑定扩展器  public function extend($name, $extender)  {    if (ist($this->instances[$name])) {      // 已经实例化的服务，直接调用扩展器      $this->instances[$name] = $extender($this->instances[$name]);    } el {      $this->extenders[$name][] = $extender;    }  }  // 获取服务  public function make($name, array $parameters = [])  {    $instance = parent::make($name, $parameters);    if (ist($this->extenders[$name])) {      // 调用扩展器      foreach ($this->extenders[$name] as $extender) {        $instance = $extender($instance);      }    }    return $instance;  }}// ----------- ↓↓↓↓示例代码↓↓↓↓ ----------- //class redis{  public $name;  public function __construct($name = 'default')  {    $this->name = $name;  }  public function tname($name)  {    $this->name = $name;  }}$container = new extendcontainer();// 绑定redis服务$container->singleton(redis::class, function () {  return new redis();});// 给redis服务绑定一个扩展器$container->extend(redis::class, function (redis $redis) {  $redis->tname('扩展器');  return $redis;});$redis = $container->make(redis::class);var_dump($redis->name);

9. 上下文绑定

有时侯我们可能有两个类使用同一个接口，但希望在每个类中注入不同的实现，例如两个控制器，分别为它们注入不同的log服务。

class apicontroller{  public function __construct(log $log)  {  }}class webcontroller{  public function __construct(log $log)  {  }}

最终我们要用以下方式实现：

// 当apicontroller依赖log时，给它一个redislog$container->addcontextualbinding('apicontroller','log',new redislog());// 当webcontroller依赖log时，给它一个filelog$container->addcontextualbinding('webcontroller','log',new filelog());

为了更直观更方便更语义化的使用，我们把这个过程改成链式操作：

$container->when('apicontroller')    ->needs('log')    ->give(new redislog());

我们增加一个$context数组，用来存储上下文。同时增加一个addcontextualbinding方法，用来注册上下文绑定。以apicontroller为例，$context的真实模样是：

$context['apicontroller']['log'] = new redislog();

然后build方法实例化类时，先从上下文中查找依赖参数，就实现了上下文绑定。

接下来，看看链式操作是如何实现的。

首先定义一个类context，这个类有两个方法，needs和give。

然后在容器中，增加一个when方法，它返回一个context对象。在context对象的give方法中，我们已经具备了注册上下文所需要的所有参数，所以就可以在give方法中调用addcontextualbinding来注册上下文了。

class contextcontainer extends extendcontainer{  // 依赖上下文  protected $context = [];  // 构建一个类，并自动注入服务  public function build($class, array $parameters = [])  {    $reflector = new reflectionclass($class);    $constructor = $reflector->getconstructor();    if (is_null($constructor)) {      // 没有构造函数，直接new      return new $class();    }    $dependencies = [];    // 获取构造函数所需的参数    foreach ($constructor->getparameters() as $dependency) {      if (ist($this->context[$class]) && ist($this->context[$class][$dependency->getname()])) {        // 先从上下文中查找        $dependencies[] = $this->context[$class][$dependency->getname()];        continue;      }      if (ist($parameters[$dependency->getname()])) {        // 从自定义参数中查找        $dependencies[] = $parameters[$dependency->getname()];        continue;      }      if (is_null($dependency->getclass())) {        // 参数类型不是类或接口时，无法从容器中获取依赖        if ($dependency->isdefaultvalueavailable()) {          // 查找默认值，如果有就使用默认值          $dependencies[] = $dependency->getdefaultvalue();        } el {          // 无法提供类所依赖的参数          throw new exception('找不到依赖参数：' . $dependency->getname());        }      } el {        // 参数类型是一个类时，就用make方法构建该类        $dependencies[] = $this->make($dependency->getclass()->name);      }    }    return $reflector->newinstanceargs($dependencies);  }  // 绑定上下文  public function addcontextualbinding($when, $needs, $give)  {    $this->context[$when][$needs] = $give;  }  // 支持链式方式绑定上下文  public function when($when)  {    return new context($when, $this);  }}class context{  protected $when;  protected $needs;  protected $container;  public function __construct中国古代朝代表($when, contextcontainer $container)  {    $this->when = $when;    $this->contai苏州大学全国排名ner = $container;  }  public function needs($needs)  {    $this->needs = $needs;    return $this;  }  public function give($give)  {    // 调用容器绑定依赖上下文    $this->container->addcontextualbinding($this->when, $this->needs, $give);  }}// ----------- ↓↓↓↓示例代码↓↓↓↓ ----------- //class dog{  public $name;  public function __construct($name)  {    $this->name = $name;  }}class cat{  public $name;  public function __construct($name)  {    $this->name = $name;  }}$container = new contextcontainer();// 给dog类设置上下文绑定$container->when(dog::class)  ->needs('name')  ->give('小狗');// 给cat类设置上下文绑定$container->when(cat::class)  ->needs('name')  ->give('小猫');$dog = $container->make(dog::class);$cat = $container->make(cat::class);var_dump('dog:' . $dog->name);var_dump('cat:' . $cat->name);

10. 完整代码

class container{  // 已绑定的服务  protected $instances = [];  // 已绑定的回调函数  protected $bindings = [];  // 服务别名  protected $alias = [];  // 存放扩展器的数组  protected $extenders = [];  // 依赖上下文  protected $context = [];  // 绑定服务实例  public function instance($name, $instance)  {    $this->instances[$name] = $instance;  }  // 绑定服务  public function bind($name, $instance, $shared = fal)  {    if ($instance instanceof closure) {      // 如果$instance是一个回调函数，就绑定到bindings。      $this->bindings[$name] = [        'callback' => $instance,        // 标记是否单例        'shared' => $shared      ];    } el {      // 调用make方法，创建实例      $this->instances[$name] = $this->make($name)兔气扬眉;    }  }  // 绑定一个单例  public function singleton($name, $instance)  {    $this->bind($name, $instance, true);  }  // 给服务绑定一个别名  public function alias($alias, $name)  {    $this->alias[$alias] = $name;  }  // 给服务绑定扩展器  public function extend($name, $extender)  {    if (ist($this->instances[$name])) {      // 已经实例化的服务，直接调用扩展器      $this->instances[$name] = $extender($this->instances[$name]);    } el {      $this->extenders[$name][] = $extender;    }  }  // 获取服务  public function make($name, array $parameters = [])  {    // 先用别名查找真实服务名    $name = ist($this->alias[$name]) ? $this->alias[$name] : $name;    if (ist($this->instances[$name])) {      return $this->instances[$name];    }    if (ist($this->bindings[$name])) {      // 执行回调函数并返回      $instance = call_ur_func($this->bindings[$name]['callback']);      if ($this->bindings[$name]['shared']) {        // 标记为单例时，存储到服务中        $this->instances[$name] = $instance;      }    } el {      // 使用build方法构建此类      $instance = $this->build($name, $parameters);    }    if (ist($this->extenders[$name])) {      // 调用扩展器      foreach ($this->extenders[$name] as $extender) {        $instance = $extender($instance);      }    }    return $instance;  }  // 构建一个类，并自动注入服务  public function build($class, array $parameters = [])  {    $reflector = new reflectionclass($class);    $constructor = $reflector->getconstructor();    if (is_null($constructor)) {      // 没有构造函数，直接new      return new $class();    }    $dependencies = [];    // 获取构造函数所需的参数    foreach ($constructor->getparameters() as $dependency) {      if (ist($this->context[$class]) && ist($this->context[$class][$dependency->getname()])) {        // 先从上下文中查找        $dependencies[] = $this->context[$class][$dependency->getname()];        continue;      }      if (ist(电脑音箱有回音$parameters[$dependency->getname()])) {        // 从自定义参数中查找        $dependencies[] = $parameters[$dependency->getname()];        continue;      }      if (is_null($dependency->getclass())) {        // 参数类型不是类或接口时，无法从容器中获取依赖        if ($dependency->isdefaultvalueavailable()) {          // 查找默认值，如果有就使用默认值          $dependencies[] = $dependency->getdefaultvalue();        } el {          // 无法提供类所依赖的参数          throw new exception('找不到依赖参数：' . $dependency->getname());        }      } el {        // 参数类型是一个类时，就用make方法构建该类        $dependencies[] = $this->make($dependency->getclass()->name);      }    }    return $reflector->newinstanceargs($dependencies);  }  // 绑定上下文  public function addcontextualbinding($when, $needs, $give)  {    $this->context[$when][$needs] = $give;  }  // 支持链式方式绑定上下文  public function when($when)  {    return new context($when, $this);  }}class context{  protected $when;  protected $needs;  protected $container;  public function __construct($when, container $container)  {    $this->when = $when;    $this->container = $container;  }  public function needs($needs)  {    $this->needs = $needs;    return $this;  }  public function give($give)  {    // 调用容器绑定依赖上下文    $this->container->addcontextualbinding($this->when, $this->needs, $give);  }}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持www.887551.com。