后盾人

Appearance

服务容器 ​

Introduction ​

Laravel 服务容器是用于管理类依赖项和执行依赖项注入的强大工具。依赖注入是一个花哨的短语，其本质是这样的:类依赖通过构造函数或在某些情况下的“setter”方法“注入”到类中。

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

php
    <?php

    namespace App\Http\Controllers;

    use App\Services\AppleMusic;
    use Illuminate\View\View;

    class PodcastController extends Controller
    {
        /**
         * 创建一个新的控制器实例
         */
        public function __construct(
            protected AppleMusic $apple,
        ) {}

        /**
         * 显示有关给定播客的信息
         */
        public function show(string $id): View
        {
            return view('podcasts.show', [
                'podcast' => $this->apple->findPodcast($id)
            ]);
        }
    }

在此示例中，PodcastController 需要从 Apple Music 等数据源检索播客。因此，我们将注入一个能够检索播客的服务。由于该服务是注入的，因此在测试我们的应用程序时，我们能够轻松地“模拟”或创建 AppleMusic 服务的虚拟实现。

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

零配置解析 ​

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

php
    <?php

    class Service
    {
        // ...
    }

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

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

值得庆幸的是，您在构建 Laravel 应用程序时将编写的许多类都会通过容器自动接收它们的依赖项，包括控制器、事件侦听器、中间件等。此外，你可以在排队作业的 handle 方法中键入提示依赖项。一旦您尝到了自动和零配置依赖注入的强大功能，就感觉没有它就无法开发。

何时使用容器 ​

由于零配置解析，您通常会对路由、控制器、事件侦听器和其他地方进行类型提示依赖项，而无需手动与容器交互。例如，您可以在路由定义上对 Illuminate\Http\Request 对象进行类型提示，以便可以轻松访问当前请求。尽管我们永远不必与容器交互来编写此代码，但它在幕后管理这些依赖项的注入:

php
    use Illuminate\Http\Request;

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

在许多情况下，由于自动依赖项注入和 Facades，您可以构建 Laravel 应用程序，而无需手动绑定或解析容器中的任何内容。**那么，您何时会手动与容器交互呢？**让我们来看看两种情况。

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

绑定 ​

绑定基础知识 ​

Simple Bindings ​

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

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

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

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

如前所述，您通常会与服务提供商中的容器进行交互;但是，如果您想在服务提供商之外与容器交互，您可以通过 AppFacade 进行交互:

php
    use App\Services\Transistor;
    use Illuminate\Contracts\Foundation\Application;
    use Illuminate\Support\Facades\App;

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

仅当尚未为给定类型注册绑定时，才能使用 bindIf 方法注册容器绑定:

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

NOTE

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

绑定单例 ​

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

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

仅当尚未为给定类型注册绑定时，才能使用 singletonIf 方法注册单例容器绑定:

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

绑定范围的单例 ​

scoped 方法将类或接口绑定到容器中，该容器在给定的 Laravel 请求/作业生命周期内只能解析一次。虽然此方法类似于单例方法，但每当 Laravel 应用程序启动新的“生命周期”时，例如当 Laravel Octane worker 处理新请求或 Laravel 队列 worker 处理新作业时，将使用 scoped 方法注册的实例刷新:

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

绑定实例 ​

您还可以使用 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;

    /**
     * 创建一个新的类实例
     */
    public function __construct(
        protected EventPusher $pusher
    ) {}

上下文绑定 ​

有时你可能有两个使用相同接口的类，但你希望将不同的实现注入每个类。例如，两个控制器可能依赖于 Contract 的不同 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 array
         */
        protected $filters;

        /**
         * 创建一个新的类实例
         */
        public function __construct(
            protected Logger $logger,
            Filter ...$filters,
        ) {
            $this->filters = $filters;
        }
    }

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

php
    $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),
                    ];
              });

为方便起见，您也可以只提供一个类名数组，以便在 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 Analyzer，它接收许多不同 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 (Application $app) {
        return new ReportAnalyzer($app->tagged('reports'));
    });

扩展绑定 ​

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

php
    $this->app->extend(Service::class, function (Service $service, Application $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]);

bound 方法可用于确定容器中是否已显式绑定类或接口:

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

如果您位于服务提供商之外的代码位置，而该位置无权访问 $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;

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

自动注入 ​

或者，重要的是，您可以在容器解析的类的构造函数中对依赖项进行类型提示，包括控制器、事件侦听器、中间件等。此外，你可以在排队作业的 handle 方法中键入提示依赖项。在实践中，这就是容器应该如何解析大多数对象。

例如，您可以在控制器的构造函数中对应用程序定义的服务进行类型提示。该服务将自动解析并注入到类中:

php
    <?php

    namespace App\Http\Controllers;

    use App\Services\AppleMusic;

    class PodcastController extends Controller
    {
        /**
         * 创建一个新的控制器实例
         */
        public function __construct(
            protected AppleMusic $apple,
        ) {}

        /**
         * 显示有关给定播客的信息
         */
        public function show(string $id): Podcast
        {
            return $this->apple->findPodcast($id);
        }
    }

方法调用和注入 ​

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

php
    <?php

    namespace App;

    use App\Services\AppleMusic;

    class PodcastStats
    {
        /**
         * 生成新的播客统计报告
         */
        public function generate(AppleMusic $apple): array
        {
            return [
                // ...
            ];
        }
    }

您可以通过容器调用 generate 方法，如下所示:

php
    use App\PodcastStats;
    use Illuminate\Support\Facades\App;

    $stats = App::call([new PodcastStats, 'generate']);

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

php
    use App\Services\AppleMusic;
    use Illuminate\Support\Facades\App;

    $result = App::call(function (AppleMusic $apple) {
        // ...
    });

容器事件 ​

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

php
    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 容器的实例:

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

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

        // ...
    });

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

后盾人版权所有 © 2018-2024 创作不易请尊重他人劳动成果，未经授权禁止转载！