概念
生活中,容器就是一个存放物品的器具。平时可以把杂乱的东西都放到容器中,要用的时候再去容器中拿。
类似的,Laravel 的服务容器也像一个存放服务的类,通过把要使用的服务绑定到容器中,然后在需要使用的时候从容器中获取(它还可以通过反射自动创建服务依赖的服务)。
Laravel 框架中所有的服务都是通过容器来创建与获取的,这样使得所有的服务都依赖容器而不相互依赖,避免服务之间的过度耦合,让后面服务的变化变得简单。
使用
容器主要包括两种方法:绑定和获取。将需要的服务绑定到容器中,需要的时候再从容器中获取。
服务绑定
下面是容器提供绑定的主要方法:
$app
为容器的实例。
- 简单绑定
bind
方法。绑定的内容可以是闭包函数,类名字符串。
// 绑定闭包
$app->bind('redis.connection', function ($app) {
return $app['redis']->connection();
});
// 绑定类名
$app->bind('database', MySQLDatabase::class);
- 单例绑定
singleton
方法。绑定的内容可以是闭包函数,类名字符串。
$app->singleton('redis', function ($app) {
// ...
return new RedisManager($driver, $config);
});
单例绑定和普通绑定的 区别 是在后面获取绑定内容时,单例绑定的会一直返回同一个对象,而普通绑定的每次获取都会得到一个重新实例化的对象。
- 绑定实例
instance
方法。绑定的内容是现有的对象。
$this->app->instance('HelpSpot\API', new HelpSpot\API(new HttpClient));
- 绑定初始化数据
容器可以通过反射,在初始化的时候获得需要注入的对象,但如果要指定初始化的具体值,可以在绑定的时候单独设置
<?php
// 如果 UserConstroller 类的构造方法如下
public function __construct($variableName) {
// 其他操作 ...
}
// 绑定初始化的数据如下
$app->when('App\Http\Controllers\UserController')
->needs('$variableName')
->give($value);
- 绑定接口到实现
将接口的一个实现绑定到接口,当从容器获取接口的实例时,会返回绑定的实现。这样就可以实现面线接口编程。
bind
、single
方法都可以,与上面的区别是第一个参数是接口名称。
// 项目开始使用极光推送服务
$app->bind(
'App\Contracts\Pusher',
'App\Services\JPusher'
);
// 开始推送
$app->make('App\Contracts\Pusher')->push($message);
// 后面项目改为通过信鸽推送,我们只需要修改绑定的地方,实际推送地方不需要任何修改
$app->bind(
'App\Contracts\Pusher',
'App\Services\XgPusher'
);
- 上下文绑定
有时候可能两个不同的类使用了相同的接口,但是它们需要使用不同的实现类,可以通过下面方法对指定类绑定指定的实现类。
// 在 PhotoController 类中使用 Filesystem 接口时,提供 Storage::disk('local') 的实现
$app->when(PhotoController::class)
->needs(Filesystem::class)
->give(function () {
return Storage::disk('local');
});
服务获取
服务获取指从容器中获取服务的方法。
- 直接
make
、makeWith
获取对象
容器提供$app->make($abstract)
方法获取指定字符串或接口对应的实现。
makeWith()
方法可以在指定对象实例化的参数。 - 全局的
app()
函数
其实app($abstract = null, array $parameters = [])
函数也是调用容器的make
方法去获得对象
app($abstract);
- 通过容器的属性获取对象
因为 Laravel 容器实现了 ArrayAccess 接口,当获取容器没有定义的属性时会调用 ArrayAccess 接口的offsetGet
方法,而offsetGet
方法会调用容器的make
方法来获取对象。
// 获取 $abstract 对应的对象
$app->$abstract;
- 通过依赖注入
注意: 只有由容器创建类或调用方法时,容器会通过反射去自动注入;如果是手动 new 去创建对象,是不会自动依赖注入的。
class AuthController extends Controller
{
// login 是控制器的一个方法,框架路由到这个方法时,
// 会根据 $request 接口类型,自动实例化 $request 对象
public function login(Request $request) {
// 这里的参数 $request 如果不是 login 的入参,需要由用户手动传入
$this->validateLogin($request);
// ...
}
protected function validateLogin(Request $request) {
// ...
}
}
源码阅读
下图是容器主要方法的关系图。
Laravel 在程序入口文件
bootstrap/app
中初始化 Illuminate\Foundation\Application
容器类,然后通过服务提供者将所需要的服务注册到容器中,以供后面使用。下面主要分析
bind
方法(绑定)和 make
方法(获取)。
bind
方法
<?php
/**
* 在容器中添加一个绑定。
*
* @param string|array $abstract 绑定的名称
* @param \Closure|string|null $concrete 绑定的内容
* @param bool $shared 绑定内容是否在容器中共享(单例绑定就是设置的共享)
* @return void
*/
public function bind($abstract, $concrete = null, $shared = false)
{
// 删除之前绑定名称为 $abstract 的实例和别名
$this->dropStaleInstances($abstract);
// 如果 $concrete 为空,则将 $concrete 注册为类名为 $abstract 的类。
if (is_null($concrete)) {
$concrete = $abstract;
}
// 如果 $concrete 是一个类名字符串,而不是闭包。需要将它包装成为一个闭包,
// 方便后面生成绑定实例时的扩展
if (! $concrete instanceof Closure) {
$concrete = $this->getClosure($abstract, $concrete);
}
// 将 concrete、shared 的内容保存到 $this->bindings 数组中
$this->bindings[$abstract] = compact('concrete', 'shared');
// 判断 绑定的名称 在容器中是否已经被实例化过
if ($this->resolved($abstract)) {
// 将 $abstract 名称绑定的对象重新实例化一次。
// 重新实例化后,如果 $abstract 有注册重新实例化通知的回调,会出发重新实例化的回调
$this->rebound($abstract);
}
}
/**
* 对通过绑定名称获取对象的方法包装为一个闭包 Get the Closure to be used when building a type.
*
* @param string $abstract 绑定名称
* @param string $concrete 绑定内容
* @return \Closure
*/
protected function getClosure($abstract, $concrete)
{
// 返回一个匿名函数,入参为容器对象
return function ($container, $parameters = []) use ($abstract, $concrete) {
// 如果绑定名称和绑定内容相同,直接通过反射获取 绑定内容的对象
if ($abstract == $concrete) {
return $container->build($concrete);
}
// 通过 make 方法获取绑定名称为 $concrete 的绑定内容
return $container->makeWith($concrete, $parameters);
};
}
这里以 Laravel 中 bootstrap/app.php
中的内容为例:
<?php
//将类 'App\Http\Kernel' 绑定到接口 'Illuminate\Contracts\Http\Kernel' 上
$app->singleton(
Illuminate\Contracts\Http\Kernel::class,
App\Http\Kernel::class
);
绑定后容器中的内容如下:
容器
$app
中的 bindings
数组对应的键 Illuminate\Contracts\Http\Hernel
为绑定的名称;绑定内容为数组,包含了两个属性:
-
concrete
绑定的内容。这里是一个闭包,第一个参数为this
容器本身,第二个参数为传入的初始化参数。 -
shared
是否为共享。 因为这里是单例绑定,所以是true
。
绑定完成后,继续看 Laravel 是如何从容器中获取对象的。
make
方法
Illuminate\Foundation\Application 文件中的 make
方法:
<?php
/**
* 从容器中解析给定类名,得到对应的对象实例
*
* (重写了 Container 中的 make 方法)
*
* @param string $abstract 给定类名字符串
* @return mixed
*/
public function make($abstract)
{
// 获取 $abstract 类名的别名。
$abstract = $this->getAlias($abstract);
// 如果 $abstract 是延迟服务中定义的服务,则加载服务(让服务在需要的时候再加载)
if (isset($this->deferredServices[$abstract])) {
$this->loadDeferredProvider($abstract);
}
// 调用 Container 中的 make 方法获取 $abstract 类名对应的对象
return parent::make($abstract);
}
从绑定中容器中解析、并获得给定类名对象的实现主要是在 Illuminate\Container\Container 文件:
<?php
// 这里实际是调用 resolve 方法生成、获取给定类型的实例
public function make($abstract)
{
return $this->resolve($abstract);
}
protected function resolve($abstract, $parameters = [])
{
// 获取类名的别名。如果别名存在,会去解析容器中别名对应的类
$abstract = $this->getAlias($abstract);
// 非主要部分,略过...
// 如果类名已经绑定到实例,且类名没有设置上下文绑定,直接返回实例。
if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
return $this->instances[$abstract];
}
// 保存参数内容,
$this->with[] = $parameters;
// 从容器中获取 $abstract 类绑定的内容;如果没有绑定过,直接返回 $abstract 类名
$concrete = $this->getConcrete($abstract);
// 如果绑定的内容可以实例化,调用 build 方法实例化;否则地归去容器解析。
// 可实例化的条件:
// 1. 类名与绑定内容一致
// 2. 绑定的内容是一个闭包
if ($this->isBuildable($concrete, $abstract)) {
$object = $this->build($concrete);
} else {
$object = $this->make($concrete);
}
// ...
return $object;
}
// 构造绑定的内容
public function build($concrete)
{
// 如果绑定的内容 $concrete 是一个闭包,直接传入参数,调用闭包
if ($concrete instanceof Closure) {
return $concrete($this, $this->getLastParameterOverride());
}
// 通过反射获取 $concrete 反射类
$reflector = new ReflectionClass($concrete);
// 如果反射类不可初始化,抛出异常
if (! $reflector->isInstantiable()) {
return $this->notInstantiable($concrete);
}
$this->buildStack[] = $concrete;
// 获取反射类的构造方法
$constructor = $reflector->getConstructor();
// 如果没有构造方法,直接 new 类名
if (is_null($constructor)) {
array_pop($this->buildStack);
return new $concrete;
}
// 获取构造函数的依赖参数
$dependencies = $constructor->getParameters();
// 通过反射获取依赖参数的实例
$instances = $this->resolveDependencies(
$dependencies
);
array_pop($this->buildStack);
// 通过类名实例
return $reflector->newInstanceArgs($instances);
}
build
方法主要使用 PHP 的反射获取类名的实例,反射知识参考Laravel 源码学习 基础知识。
以 Laravel public/index.php
中的内容为例:
<?php
// 获取接口名称 Illuminate\Contracts\Http\Kernel 的实例
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
由上面绑定部分可知,Illuminate\Contracts\Http\Kernel::class
在容器中实际绑定的内容是 App\Http\Kernel::class
类实例化的闭包。
在调用
build
方法之前 $concrete 是下面的闭包函数:
<?php
// 此时 $abstract 为 `Illuminate\Contracts\Http\Kernel::class`,
// $concrete 为 `App\Http\Kernel::class`,
// $app 为容器 $container 。
function ($container, $parameters = []) use ($abstract, $concrete) {
// 如果绑定名称和绑定内容相同,直接通过反射获取 绑定内容的对象
if ($abstract == $concrete) {
return $container->build($concrete);
}
// 通过 make 方法获取绑定名称为 $concrete 的绑定内容
return $container->makeWith($concrete, $parameters);
};
调用 build
方法后,$kernel
得到的内容是:
<?php
$kernel = $app->makeWith(App\Http\Kernel::class);
// 因为 App\Http\Kernal::class 没有别名,通过 resolve 函数后实际为
$kernal = $app->build(App\Http\Kernel::class);
最后 Illuminate\Container\Container 容器中的 build
方法获取 App\Http\Kernel::class
的实例。