简介

Laravel 服务容器是一个用于管理类依赖以及实现依赖注入的强有力工具。依赖注入这个名词表面看起来花哨，实质上是指：通过构造函数，或者某些情况下通过「setter」方法将类依赖「注入」到类中。

我们来看一个简单的例子:

<?php
namespace App\Http\Controllers;
use App\Repositories\UserRepository;
use Illuminate\View\View;
class UserController extends Controller
{
    /**
     * 创建一个新的控制器实例
     */
    public function __construct(
        protected UserRepository $users,
    ) {}
    /**
     * 展示给定用户的信息
     */
    public function show(string $id): View
    {
        $user = $this->users->find($id);
        return view('user.profile', ['user' => $user]);
    }
}

在此示例中，php UserController 需要从数据源中检索用户。 因此，我们将 注入 一个能够检索用户的服务。 在这种情况下，我们的 php UserRepository 很可能使用 Eloquent 从数据库中检索用户信息。 然而，由于存储库是注入的，我们可以很容易地用另一个实现替换它。 这种方式的便利之处也体现在：当需要为应用编写测试的时候，我们也可以很轻松地 「模拟」 或者创建一个 php UserRepository 的伪实现来操作。

深入理解 Laravel 服务容器，对于构建一个强大的、大型的应用，以及对 Laravel 核心本身的贡献都是至关重要的。

零配置解决方案

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

<?php
class Service
{
    // ...
}
Route::get('/', function (Service $service) {
    die($service::class);
});

在这个例子中，点击应用程序的 php / 路由将自动解析 php Service 类并将其注入到路由的处理程序中。 这是一个有趣的改变。 这意味着你可以开发应用程序并利用依赖注入，而不必担心臃肿的配置文件。

值得庆幸的是，在构建 Laravel 应用程序时，你将要编写的许多类都可以通过容器自动接收它们的依赖关系，包括 控制器、 事件监听器、 中间件 等等。 此外，你可以在 队列任务 的 php handle 方法中键入提示依赖项。 一旦你尝到了自动和零配置依赖注入的力量，你就会觉得没有它是不可以开发的。

何时使用容器

得益于零配置解决方案，通常情况下，你只需要在路由、控制器、事件监听器和其他地方键入提示依赖项，而不必手动与容器打交道。例如，你可以在路由定义中键入 php Illuminate\Http\Request 对象，以便轻松访问当前的请求对象。尽管我们不必与容器交互来编写此代码，但它在幕后管理着这些依赖项的注入：

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

在许多情况下，多亏了自动依赖注入和 facades ，你在构建 Laravel 应用程序时，无需手动绑定或解析容器中的任何内容。 那么，什么时候你才会手动与容器打交道呢？ 让我们来看看下面两种情况。

第一种情况，如果你编写了一个实现接口的类，并希望在路由或类的构造函数中键入该接口的提示，则必须 告诉容器如何解析该接口。第二种情况，如果你正在 编写一个 Laravel 包 并计划与其他 Laravel 开发人员共享，那么你可能需要将包的服务绑定到容器中。

绑定

绑定基础

简单绑定
几乎所有的服务容器绑定都会在 服务提供者 中注册，下面大部分示例将演示如何在上下文中使用容器。

在服务提供者中，你总是可以通过 php $this->app 属性访问容器。我们可以使用 php bind 方法注册一个绑定，将我们希望注册的类或接口名称与返回类实例的闭包一起传递:

use App\Services\Transistor;
use App\Services\PodcastParser;
use Illuminate\Contracts\Foundation\Application;
$this->app->bind(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

注意，我们接受容器本身作为解析器的参数。然后，我们可以使用容器来解析正在构建的对象的子依赖。

如前所述，你通常会在服务提供者内部与容器进行交互；但是，如果你希望在服务提供者外部与容器进行交互，则可以通过 php App facade 进行:

use App\Services\Transistor;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Support\Facades\App;
App::bind(Transistor::class, function (Application $app) {
    // ...
});

只有在绑定没有注册为指定的类型时，你才可以使用 php bindIf 方法注册容器绑定：

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

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

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

use App\Services\Transistor;
use App\Services\PodcastParser;
use Illuminate\Contracts\Foundation\Application;
$this->app->singleton(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

只有在绑定没有注册为指定的类型时，你才可以使用 php singletonIf 方法注册单例容器绑定：

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

绑定作用域单例
php scoped 方法将一个类或接口绑定到容器中，该容器只应在给定的 Laravel 请求 / 作业生命周期内解析一次。虽然该方法与 php singleton 方法类似，但是当 Laravel 应用程序开始一个新的「生命周期」时， 使用 php scoped 方法注册的实例 将被刷新，例如当 Laravel Octane 工作者处理新请求或 Laravel 队列系统处理新作业时：

use App\Services\Transistor;
use App\Services\PodcastParser;
use Illuminate\Contracts\Foundation\Application;
$this->app->scoped(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

绑定实例
你也可以使用 php instance 方法将一个现有的对象实例绑定到容器中。给定的实例总会在后续对容器的调用中返回：

use App\Services\Transistor;
use App\Services\PodcastParser;
$service = new Transistor(new PodcastParser);
$this->app->instance(Transistor::class, $service);

将接口绑定实例

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

use App\Contracts\EventPusher;
use App\Services\RedisEventPusher;
$this->app->bind(EventPusher::class, RedisEventPusher::class);

这条语句告诉容器，当类需要 php EventPusher 的实例时，它应该注入 php RedisEventPusher。现在我们可以在由容器解析的类的构造函数中输入 php EventPusher 接口。Laravel 应用程序中的控制器、事件侦听器、中间件和各种其他类型的类始终使用容器进行解析：

use App\Contracts\EventPusher;
/**
 * 创建一个新的类实例。
 */
public function __construct(
    protected EventPusher $pusher
) {}

上下文绑定

译者注：所谓「上下文绑定」就是根据上下文进行动态的绑定，指依赖的上下文关系。

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

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');
          });

绑定基本类型

有时你可能有一个类接收了一些注入的类，但也需要一个注入的基本类型，如整数。你可以很容易地使用上下文绑定来注入类可能需要的任何值：

use App\Http\Controllers\UserController;
$this->app->when(UserController::class)
          ->needs('$variableName')
          ->give($value);

有时一个类可能依赖于 标签 实例的数组。使用 php giveTagged 方法，你可以很容易地注入所有带有该标签的容器绑定：

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

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

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

绑定类型化的可变参数

有时候，你可能会有一个类，它通过可变构造函数参数接收一个类型化对象数组：

<?php
use App\Models\Filter;
use App\Services\Logger;
class Firewall
{
    /**
     * 过滤器实例数组。
     *
     * @var array
     */
    protected $filters;
    /**
     * 创建一个新的类实例。
     */
    public function __construct(
        protected Logger $logger,
        Filter ...$filters,
    ) {
        $this->filters = $filters;
    }
}

使用上下文绑定，你可以通过提供一个返回解析的 php Filter 实例数组的闭包来解决这个依赖：

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

为了方便，你也可以直接提供一个类名数组，让容器在 php Firewall 需要 php Filter 实例时进行解析：

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

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

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

标签

偶尔，你可能需要解析某个「类别」的所有绑定。例如，你可能正在构建一个接收许多不同 php Report 接口实现的报告分析器。在注册 php Report 实现后，你可以使用 php tag 方法为它们分配一个标签：

$this->app->bind(CpuReport::class, function () {
    // ...
});
$this->app->bind(MemoryReport::class, function () {
    // ...
});
$this->app->tag([CpuReport::class, MemoryReport::class], 'reports');

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

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

扩展绑定

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

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

解析

make 方法

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

use App\Services\Transistor;
$transistor = $this->app->make(Transistor::class);

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

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

可以使用 php bound 方法来确定一个类或接口是否已在容器中明确绑定：

if ($this->app->bound(Transistor::class)) {
    // ...
}

如果你在代码中的一个位置，不在服务提供者内部，且没有访问 php $app 变量的权限，你可以使用 php App facade 或 php app helper 来从容器中解析一个类实例：

use App\Services\Transistor;
use Illuminate\Support\Facades\App;
$transistor = App::make(Transistor::class);
$transistor = app(Transistor::class);

如果你希望在由容器解析的类中注入 Laravel 容器实例本身，你可以在类的构造函数中对 php Illuminate\Container\Container 类进行类型提示：

use Illuminate\Container\Container;
/**
 * 创建一个新的类实例。
 */
public function __construct(
    protected Container $container
) {}

自动注入

此外，你也可以在容器解析的类的构造函数中对依赖进行类型提示，包括控制器、事件监听器、中间件等等。此外，你还可以在队列作业的 php handle 方法中对依赖进行类型提示。实际上，这是大多数对象应该通过容器解析的方式。

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

<?php
namespace App\Http\Controllers;
use App\Repositories\UserRepository;
use App\Models\User;
class UserController extends Controller
{
    /**
     * 创建一个新的控制器实例。
     */
    public function __construct(
        protected UserRepository $users,
    ) {}
    /**
     * 显示给定 ID 的用户。
     */
    public function show(string $id): User
    {
        $user = $this->users->findOrFail($id);
        return $user;
    }
}

方法调用和注入

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

<?php
namespace App;
use App\Repositories\UserRepository;
class UserReport
{
    /**
     * 生成一个新的用户报告。
     */
    public function generate(UserRepository $repository): array
    {
        return [
            // ...
        ];
    }
}

你可以通过容器调用 php generate 方法，如下所示：

use App\UserReport;
use Illuminate\Support\Facades\App;
$report = App::call([new UserReport, 'generate']);

php call 方法接受任何可调用的 PHP 函数。容器的 php call 方法甚至可以用于调用闭包，同时自动注入其依赖项：

use App\Repositories\UserRepository;
use Illuminate\Support\Facades\App;
$result = App::call(function (UserRepository $repository) {
    // ...
});

容器事件

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

use App\Services\Transistor;
use Illuminate\Contracts\Foundation\Application;
$this->app->resolving(Transistor::class, function (Transistor $transistor, Application $app) {
    // 当容器解析「Transistor」类型的对象时调用...
});
$this->app->resolving(function (mixed $object, Application $app) {
    // 当容器解析任何类型的对象时调用...
});

正如你所看到的，被解析的对象将被传递给回调，这允许你先设置对象的任何附加属性，再将对象提供给其使用者。

PSR-11

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

use App\Services\Transistor;
use Psr\Container\ContainerInterface;
Route::get('/', function (ContainerInterface $container) {
    $service = $container->get(Transistor::class);
    // ...
});

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