服务容器

介绍
- 零配置解析
- 何时使用容器
绑定
解析
- Make 方法
- 自动注入
方法调用与注入
容器事件
PSR-11

介绍

Laravel 服务容器是一个强大的工具，用于管理类依赖关系和执行依赖注入。依赖注入是一个复杂的术语，基本上意味着：类依赖关系通过构造函数或在某些情况下通过“setter”方法“注入”到类中。

让我们看一个简单的例子：

php

<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Repositories\UserRepository;
use App\Models\User;

class UserController extends Controller
{
    /**
     * 用户仓库实现。
     *
     * @var UserRepository
     */
    protected $users;

    /**
     * 创建一个新的控制器实例。
     *
     * @param  UserRepository  $users
     * @return void
     */
    public function __construct(UserRepository $users)
    {
        $this->users = $users;
    }

    /**
     * 显示给定用户的个人资料。
     *
     * @param  int  $id
     * @return Response
     */
    public function show($id)
    {
        $user = $this->users->find($id);

        return view('user.profile', ['user' => $user]);
    }
}

在这个例子中，UserController 需要从数据源中检索用户。因此，我们将注入一个能够检索用户的服务。在这个上下文中，我们的 UserRepository 很可能使用 Eloquent 从数据库中检索用户信息。然而，由于仓库是被注入的，我们能够轻松地将其替换为另一个实现。我们还能够在测试应用程序时轻松“模拟”或创建 UserRepository 的虚拟实现。

深入理解 Laravel 服务容器对于构建强大且大型的应用程序以及为 Laravel 核心做出贡献至关重要。

零配置解析

如果一个类没有依赖关系或仅依赖于其他具体类（而不是接口），则容器不需要被指示如何解析该类。例如，您可以在 routes/web.php 文件中放置以下代码：

php

<?php

class Service
{
    //
}

Route::get('/', function (Service $service) {
    die(get_class($service));
});

在这个例子中，访问您应用程序的 / 路由将自动解析 Service 类并将其注入到路由的处理程序中。这是一个改变游戏规则的功能。这意味着您可以开发应用程序并利用依赖注入，而无需担心臃肿的配置文件。

幸运的是，您在构建 Laravel 应用程序时编写的许多类会自动通过容器接收其依赖关系，包括控制器、事件监听器、中间件等。此外，您可以在队列作业的 handle 方法中类型提示依赖关系。一旦您体验到自动和零配置依赖注入的强大功能，您会觉得没有它开发是不可想象的。

何时使用容器

得益于零配置解析，您通常会在路由、控制器、事件监听器等地方类型提示依赖关系，而无需手动与容器交互。例如，您可能在路由定义中类型提示 Illuminate\Http\Request 对象，以便轻松访问当前请求。尽管我们在编写此代码时从未与容器交互，但它在后台管理这些依赖关系的注入：

php

use Illuminate\Http\Request;

Route::get('/', function (Request $request) {
    // ...
});

在许多情况下，得益于自动依赖注入和门面，您可以构建 Laravel 应用程序，而从未手动绑定或解析容器中的任何内容。那么，您何时会手动与容器交互呢？ 让我们检查两种情况。

首先，如果您编写一个实现接口的类，并希望在路由或类构造函数中类型提示该接口，则必须告诉容器如何解析该接口。其次，如果您正在编写一个计划与其他 Laravel 开发者共享的 Laravel 包，您可能需要将包的服务绑定到容器中。

绑定

绑定基础

简单绑定

几乎所有的服务容器绑定都将在服务提供者中注册，因此大多数这些示例将在该上下文中演示使用容器。

在服务提供者中，您始终可以通过 $this->app 属性访问容器。我们可以使用 bind 方法注册一个绑定，传递我们希望注册的类或接口名称，以及返回该类实例的闭包：

php

use App\Services\Transistor;
use App\Services\PodcastParser;

$this->app->bind(Transistor::class, function ($app) {
    return new Transistor($app->make(PodcastParser::class));
});

请注意，我们将容器本身作为参数传递给解析器。然后，我们可以使用容器解析我们正在构建的对象的子依赖关系。

如前所述，您通常会在服务提供者中与容器交互；但是，如果您希望在服务提供者之外与容器交互，可以通过 App 门面来实现：

php

use App\Services\Transistor;
use Illuminate\Support\Facades\App;

App::bind(Transistor::class, function ($app) {
    // ...
});

如果类不依赖于任何接口，则无需将类绑定到容器中。容器不需要被指示如何构建这些对象，因为它可以使用反射自动解析这些对象。

绑定单例

singleton 方法将类或接口绑定到容器中，该类或接口只应解析一次。一旦单例绑定被解析，后续对容器的调用将返回相同的对象实例：

php

use App\Services\Transistor;
use App\Services\PodcastParser;

$this->app->singleton(Transistor::class, function ($app) {
    return new Transistor($app->make(PodcastParser::class));
});

绑定作用域单例

scoped 方法将类或接口绑定到容器中，该类或接口只应在给定的 Laravel 请求/作业生命周期内解析一次。虽然此方法与 singleton 方法类似，但使用 scoped 方法注册的实例将在 Laravel 应用程序开始新的“生命周期”时被清除，例如当 Laravel Octane 工作进程处理新的请求或当 Laravel 队列工作进程处理新的作业时：

php

use App\Services\Transistor;
use App\Services\PodcastParser;

$this->app->scoped(Transistor::class, function ($app) {
    return new Transistor($app->make(PodcastParser::class));
});

绑定实例

您还可以使用 instance 方法将现有对象实例绑定到容器中。给定的实例将在后续对容器的调用中始终返回：

php

use App\Services\Transistor;
use App\Services\PodcastParser;

$service = new Transistor(new PodcastParser);

$this->app->instance(Transistor::class, $service);

将接口绑定到实现

服务容器的一个非常强大的功能是它能够将接口绑定到给定的实现。例如，假设我们有一个 EventPusher 接口和一个 RedisEventPusher 实现。一旦我们编写了这个接口的 RedisEventPusher 实现，我们可以像这样将其注册到服务容器中：

php

use App\Contracts\EventPusher;
use App\Services\RedisEventPusher;

$this->app->bind(EventPusher::class, RedisEventPusher::class);

这条语句告诉容器，当一个类需要 EventPusher 的实现时，它应该注入 RedisEventPusher。现在我们可以在由容器解析的类的构造函数中类型提示 EventPusher 接口。请记住，控制器、事件监听器、中间件以及 Laravel 应用程序中的各种其他类型的类始终使用容器解析：

php

use App\Contracts\EventPusher;

/**
 * 创建一个新的类实例。
 *
 * @param  \App\Contracts\EventPusher  $pusher
 * @return void
 */
public function __construct(EventPusher $pusher)
{
    $this->pusher = $pusher;
}

上下文绑定

有时您可能有两个类使用相同的接口，但您希望将不同的实现注入到每个类中。例如，两个控制器可能依赖于 Illuminate\Contracts\Filesystem\Filesystem 契约的不同实现。Laravel 提供了一个简单、流畅的接口来定义这种行为：

php

use App\Http\Controllers\PhotoController;
use App\Http\Controllers\UploadController;
use App\Http\Controllers\VideoController;
use Illuminate\Contracts\Filesystem\Filesystem;
use Illuminate\Support\Facades\Storage;

$this->app->when(PhotoController::class)
          ->needs(Filesystem::class)
          ->give(function () {
              return Storage::disk('local');
          });

$this->app->when([VideoController::class, UploadController::class])
          ->needs(Filesystem::class)
          ->give(function () {
              return Storage::disk('s3');
          });

绑定原始值

有时您可能有一个类接收一些注入的类，但也需要注入一个原始值，例如整数。您可以轻松地使用上下文绑定来注入类可能需要的任何值：

php

use App\Http\Controllers\UserController;

$this->app->when(UserController::class)
          ->needs('$variableName')
          ->give($value);

有时一个类可能依赖于一个标记的实例数组。使用 giveTagged 方法，您可以轻松注入所有带有该标签的容器绑定：

php

$this->app->when(ReportAggregator::class)
    ->needs('$reports')
    ->giveTagged('reports');

如果您需要从应用程序的配置文件中注入一个值，您可以使用 giveConfig 方法：

php

$this->app->when(ReportAggregator::class)
    ->needs('$timezone')
    ->giveConfig('app.timezone');

绑定类型可变参数

偶尔，您可能有一个类接收一个使用可变参数构造函数参数的对象数组：

php

<?php

use App\Models\Filter;
use App\Services\Logger;

class Firewall
{
    /**
     * 日志记录器实例。
     *
     * @var \App\Services\Logger
     */
    protected $logger;

    /**
     * 过滤器实例。
     *
     * @var array
     */
    protected $filters;

    /**
     * 创建一个新的类实例。
     *
     * @param  \App\Services\Logger  $logger
     * @param  array  $filters
     * @return void
     */
    public function __construct(Logger $logger, Filter ...$filters)
    {
        $this->logger = $logger;
        $this->filters = $filters;
    }
}

使用上下文绑定，您可以通过提供 give 方法一个返回 Filter 实例数组的闭包来解析这个依赖关系：

php

$this->app->when(Firewall::class)
          ->needs(Filter::class)
          ->give(function ($app) {
                return [
                    $app->make(NullFilter::class),
                    $app->make(ProfanityFilter::class),
                    $app->make(TooLongFilter::class),
                ];
          });

为了方便起见，您还可以在 Firewall 需要 Filter 实例时提供一个类名数组，让容器解析这些类名：

php

$this->app->when(Firewall::class)
          ->needs(Filter::class)
          ->give([
              NullFilter::class,
              ProfanityFilter::class,
              TooLongFilter::class,
          ]);

可变参数标签依赖

有时一个类可能有一个类型提示为给定类的可变参数依赖（Report ...$reports）。使用 needs 和 giveTagged 方法，您可以轻松注入所有带有该标签的容器绑定：

php

$this->app->when(ReportAggregator::class)
    ->needs(Report::class)
    ->giveTagged('reports');

标记

有时，您可能需要解析某个“类别”绑定的所有内容。例如，也许您正在构建一个报告分析器，该分析器接收许多不同的 Report 接口实现的数组。在注册 Report 实现后，您可以使用 tag 方法为它们分配一个标签：

php

$this->app->bind(CpuReport::class, function () {
    //
});

$this->app->bind(MemoryReport::class, function () {
    //
});

$this->app->tag([CpuReport::class, MemoryReport::class], 'reports');

一旦服务被标记，您可以通过容器的 tagged 方法轻松解析它们：

php

$this->app->bind(ReportAnalyzer::class, function ($app) {
    return new ReportAnalyzer($app->tagged('reports'));
});

扩展绑定

extend 方法允许修改解析的服务。例如，当服务被解析时，您可以运行额外的代码来装饰或配置服务。extend 方法接受两个参数：您要扩展的服务类和一个应返回修改后的服务的闭包。闭包接收正在解析的服务和容器实例：

php

$this->app->extend(Service::class, function ($service, $app) {
    return new DecoratedService($service);
});

解析

Make 方法

您可以使用 make 方法从容器解析类实例。make 方法接受您希望解析的类或接口的名称：

php

use App\Services\Transistor;

$transistor = $this->app->make(Transistor::class);

如果您的类的某些依赖关系无法通过容器解析，您可以通过将它们作为关联数组传递给 makeWith 方法来注入它们。例如，我们可以手动传递 Transistor 服务所需的 $id 构造函数参数：

php

use App\Services\Transistor;

$transistor = $this->app->makeWith(Transistor::class, ['id' => 1]);

如果您在没有访问 $app 变量的代码位置，您可以使用 App 门面或 app 助手从容器解析类实例：

php

use App\Services\Transistor;
use Illuminate\Support\Facades\App;

$transistor = App::make(Transistor::class);

$transistor = app(Transistor::class);

如果您希望将 Laravel 容器实例注入到由容器解析的类中，您可以在类的构造函数中类型提示 Illuminate\Container\Container 类：

php

use Illuminate\Container\Container;

/**
 * 创建一个新的类实例。
 *
 * @param  \Illuminate\Container\Container  $container
 * @return void
 */
public function __construct(Container $container)
{
    $this->container = $container;
}

自动注入

或者，更重要的是，您可以在由容器解析的类的构造函数中类型提示依赖关系，包括控制器、事件监听器、中间件等。此外，您可以在队列作业的 handle 方法中类型提示依赖关系。在实践中，这就是您大多数对象应该通过容器解析的方式。

例如，您可以在控制器的构造函数中类型提示应用程序定义的仓库。该仓库将自动被解析并注入到类中：

php

<?php

namespace App\Http\Controllers;

use App\Repositories\UserRepository;

class UserController extends Controller
{
    /**
     * 用户仓库实例。
     *
     * @var \App\Repositories\UserRepository
     */
    protected $users;

    /**
     * 创建一个新的控制器实例。
     *
     * @param  \App\Repositories\UserRepository  $users
     * @return void
     */
    public function __construct(UserRepository $users)
    {
        $this->users = $users;
    }

    /**
     * 显示具有给定 ID 的用户。
     *
     * @param  int  $id
     * @return \Illuminate\Http\Response
     */
    public function show($id)
    {
        //
    }
}

方法调用与注入

有时您可能希望在对象实例上调用一个方法，同时允许容器自动注入该方法的依赖关系。例如，给定以下类：

php

<?php

namespace App;

use App\Repositories\UserRepository;

class UserReport
{
    /**
     * 生成新的用户报告。
     *
     * @param  \App\Repositories\UserRepository  $repository
     * @return array
     */
    public function generate(UserRepository $repository)
    {
        // ...
    }
}

您可以通过容器像这样调用 generate 方法：

php

use App\UserReport;
use Illuminate\Support\Facades\App;

$report = App::call([new UserReport, 'generate']);

call 方法接受任何 PHP 可调用对象。容器的 call 方法甚至可以用于调用一个闭包，同时自动注入其依赖关系：

php

use App\Repositories\UserRepository;
use Illuminate\Support\Facades\App;

$result = App::call(function (UserRepository $repository) {
    // ...
});

容器事件

服务容器在每次解析对象时都会触发一个事件。您可以使用 resolving 方法监听此事件：

php

use App\Services\Transistor;

$this->app->resolving(Transistor::class, function ($transistor, $app) {
    // 当容器解析 "Transistor" 类型的对象时调用...
});

$this->app->resolving(function ($object, $app) {
    // 当容器解析任何类型的对象时调用...
});

如您所见，被解析的对象将被传递给回调，允许您在对象被提供给其消费者之前设置任何附加属性。

PSR-11

Laravel 的服务容器实现了 PSR-11 接口。因此，您可以类型提示 PSR-11 容器接口以获取 Laravel 容器的实例：

php

use App\Services\Transistor;
use Psr\Container\ContainerInterface;

Route::get('/', function (ContainerInterface $container) {
    $service = $container->get(Transistor::class);

    //
});

如果给定的标识符无法解析，将抛出异常。如果标识符从未绑定，则异常将是 Psr\Container\NotFoundExceptionInterface 的实例。如果标识符已绑定但无法解析，则将抛出 Psr\Container\ContainerExceptionInterface 的实例。

服务容器 ​

介绍 ​

零配置解析 ​

何时使用容器 ​

绑定 ​

绑定基础 ​

简单绑定 ​

绑定单例 ​

绑定作用域单例 ​

绑定实例 ​

将接口绑定到实现 ​

上下文绑定 ​

绑定原始值 ​

绑定类型可变参数 ​

可变参数标签依赖 ​

标记 ​

扩展绑定 ​

解析 ​

Make 方法 ​

自动注入 ​

方法调用与注入 ​

容器事件 ​

PSR-11 ​

服务容器

介绍

零配置解析

何时使用容器

绑定

绑定基础

简单绑定

绑定单例

绑定作用域单例

绑定实例

将接口绑定到实现

上下文绑定

绑定原始值

绑定类型可变参数

可变参数标签依赖

标记

扩展绑定

解析

Make 方法

自动注入

方法调用与注入

容器事件

PSR-11