服务容器

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

简介

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

让我们看一个简单的例子

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Services\AppleMusic;
 6use Illuminate\View\View;
 7 
 8class PodcastController extends Controller
 9{
10    /**
11     * Create a new controller instance.
12     */
13    public function __construct(
14        protected AppleMusic $apple,
15    ) {}
16 
17    /**
18     * Show information about the given podcast.
19     */
20    public function show(string $id): View
21    {
22        return view('podcasts.show', [
23            'podcast' => $this->apple->findPodcast($id)
24        ]);
25    }
26}

<?php

namespace App\Http\Controllers;

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

class PodcastController extends Controller
{
    /**
     * Create a new controller instance.
     */
    public function __construct(
        protected AppleMusic $apple,
    ) {}

    /**
     * Show information about the given podcast.
     */
    public function show(string $id): View
    {
        return view('podcasts.show', [
            'podcast' => $this->apple->findPodcast($id)
        ]);
    }
}

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

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

零配置解析

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

 1<?php
 2 
 3class Service
 4{
 5    // ...
 6}
 7 
 8Route::get('/', function (Service $service) {
 9    die($service::class);
10});

<?php

class Service
{
    // ...
}

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

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

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

何时使用容器

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

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

use Illuminate\Http\Request;

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

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

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

绑定

绑定基础

简单绑定

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

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

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

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

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

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

1use App\Services\Transistor;
2use Illuminate\Contracts\Foundation\Application;
3use Illuminate\Support\Facades\App;
4 
5App::bind(Transistor::class, function (Application $app) {
6    // ...
7});

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

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

您可以仅在尚未为给定类型注册绑定时使用 bindIf 方法注册容器绑定

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

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

为方便起见，您可以省略提供要注册为单独参数的类或接口名称，而是允许 Laravel 从您提供给 bind 方法的闭包的返回类型推断类型

1App::bind(function (Application $app): Transistor {
2    return new Transistor($app->make(PodcastParser::class));
3});

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

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

绑定单例

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

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

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 方法注册单例容器绑定

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

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

绑定作用域单例

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

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

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

您可以仅在尚未为给定类型注册绑定时使用 scopedIf 方法注册作用域容器绑定

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

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

绑定实例

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

1use App\Services\Transistor;
2use App\Services\PodcastParser;
3 
4$service = new Transistor(new PodcastParser);
5 
6$this->app->instance(Transistor::class, $service);

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

$service = new Transistor(new PodcastParser);

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

将接口绑定到实现

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

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

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

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

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

1use App\Contracts\EventPusher;
2 
3/**
4 * Create a new class instance.
5 */
6public function __construct(
7    protected EventPusher $pusher,
8) {}

use App\Contracts\EventPusher;

/**
 * Create a new class instance.
 */
public function __construct(
    protected EventPusher $pusher,
) {}

上下文绑定

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

 1use App\Http\Controllers\PhotoController;
 2use App\Http\Controllers\UploadController;
 3use App\Http\Controllers\VideoController;
 4use Illuminate\Contracts\Filesystem\Filesystem;
 5use Illuminate\Support\Facades\Storage;
 6 
 7$this->app->when(PhotoController::class)
 8    ->needs(Filesystem::class)
 9    ->give(function () {
10        return Storage::disk('local');
11    });
12 
13$this->app->when([VideoController::class, UploadController::class])
14    ->needs(Filesystem::class)
15    ->give(function () {
16        return Storage::disk('s3');
17    });

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

上下文属性

由于上下文绑定通常用于注入驱动程序或配置值的实现，因此 Laravel 提供了各种上下文绑定属性，允许注入这些类型的值，而无需在服务提供者中手动定义上下文绑定。

例如，Storage 属性可用于注入特定的存储磁盘

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use Illuminate\Container\Attributes\Storage;
 6use Illuminate\Contracts\Filesystem\Filesystem;
 7 
 8class PhotoController extends Controller
 9{
10    public function __construct(
11        #[Storage('local')] protected Filesystem $filesystem
12    )
13    {
14        // ...
15    }
16}

<?php

namespace App\Http\Controllers;

use Illuminate\Container\Attributes\Storage;
use Illuminate\Contracts\Filesystem\Filesystem;

class PhotoController extends Controller
{
    public function __construct(
        #[Storage('local')] protected Filesystem $filesystem
    )
    {
        // ...
    }
}

除了 Storage 属性之外，Laravel 还提供了 Auth、Cache、Config、DB、Log、RouteParameter 和 Tag 属性

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Models\Photo;
 6use Illuminate\Container\Attributes\Auth;
 7use Illuminate\Container\Attributes\Cache;
 8use Illuminate\Container\Attributes\Config;
 9use Illuminate\Container\Attributes\DB;
10use Illuminate\Container\Attributes\Log;
11use Illuminate\Container\Attributes\RouteParameter;
12use Illuminate\Container\Attributes\Tag;
13use Illuminate\Contracts\Auth\Guard;
14use Illuminate\Contracts\Cache\Repository;
15use Illuminate\Database\Connection;
16use Psr\Log\LoggerInterface;
17 
18class PhotoController extends Controller
19{
20    public function __construct(
21        #[Auth('web')] protected Guard $auth,
22        #[Cache('redis')] protected Repository $cache,
23        #[Config('app.timezone')] protected string $timezone,
24        #[DB('mysql')] protected Connection $connection,
25        #[Log('daily')] protected LoggerInterface $log,
26        #[RouteParameter('photo')] protected Photo $photo,
27        #[Tag('reports')] protected iterable $reports,
28    )
29    {
30        // ...
31    }
32}

<?php

namespace App\Http\Controllers;

use App\Models\Photo;
use Illuminate\Container\Attributes\Auth;
use Illuminate\Container\Attributes\Cache;
use Illuminate\Container\Attributes\Config;
use Illuminate\Container\Attributes\DB;
use Illuminate\Container\Attributes\Log;
use Illuminate\Container\Attributes\RouteParameter;
use Illuminate\Container\Attributes\Tag;
use Illuminate\Contracts\Auth\Guard;
use Illuminate\Contracts\Cache\Repository;
use Illuminate\Database\Connection;
use Psr\Log\LoggerInterface;

class PhotoController extends Controller
{
    public function __construct(
        #[Auth('web')] protected Guard $auth,
        #[Cache('redis')] protected Repository $cache,
        #[Config('app.timezone')] protected string $timezone,
        #[DB('mysql')] protected Connection $connection,
        #[Log('daily')] protected LoggerInterface $log,
        #[RouteParameter('photo')] protected Photo $photo,
        #[Tag('reports')] protected iterable $reports,
    )
    {
        // ...
    }
}

此外，Laravel 还提供了一个 CurrentUser 属性，用于将当前经过身份验证的用户注入到给定的路由或类中

1use App\Models\User;
2use Illuminate\Container\Attributes\CurrentUser;
3 
4Route::get('/user', function (#[CurrentUser] User $user) {
5    return $user;
6})->middleware('auth');

use App\Models\User;
use Illuminate\Container\Attributes\CurrentUser;

Route::get('/user', function (#[CurrentUser] User $user) {
    return $user;
})->middleware('auth');

定义自定义属性

您可以通过实现 Illuminate\Contracts\Container\ContextualAttribute 契约来创建自己的上下文属性。容器将调用您的属性的 resolve 方法，该方法应解析应注入到使用该属性的类中的值。在下面的示例中，我们将重新实现 Laravel 内置的 Config 属性

 1<?php
 2 
 3namespace App\Attributes;
 4 
 5use Illuminate\Contracts\Container\ContextualAttribute;
 6 
 7#[Attribute(Attribute::TARGET_PARAMETER)]
 8class Config implements ContextualAttribute
 9{
10    /**
11     * Create a new attribute instance.
12     */
13    public function __construct(public string $key, public mixed $default = null)
14    {
15    }
16 
17    /**
18     * Resolve the configuration value.
19     *
20     * @param  self  $attribute
21     * @param  \Illuminate\Contracts\Container\Container  $container
22     * @return mixed
23     */
24    public static function resolve(self $attribute, Container $container)
25    {
26        return $container->make('config')->get($attribute->key, $attribute->default);
27    }
28}

<?php

namespace App\Attributes;

use Illuminate\Contracts\Container\ContextualAttribute;

#[Attribute(Attribute::TARGET_PARAMETER)]
class Config implements ContextualAttribute
{
    /**
     * Create a new attribute instance.
     */
    public function __construct(public string $key, public mixed $default = null)
    {
    }

    /**
     * Resolve the configuration value.
     *
     * @param  self  $attribute
     * @param  \Illuminate\Contracts\Container\Container  $container
     * @return mixed
     */
    public static function resolve(self $attribute, Container $container)
    {
        return $container->make('config')->get($attribute->key, $attribute->default);
    }
}

绑定原始类型

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

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

use App\Http\Controllers\UserController;

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

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

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

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

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

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

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

绑定类型化的可变参数

有时，您可能有一个类，它使用可变参数构造函数参数接收类型化对象的数组

 1<?php
 2 
 3use App\Models\Filter;
 4use App\Services\Logger;
 5 
 6class Firewall
 7{
 8    /**
 9     * The filter instances.
10     *
11     * @var array
12     */
13    protected $filters;
14 
15    /**
16     * Create a new class instance.
17     */
18    public function __construct(
19        protected Logger $logger,
20        Filter ...$filters,
21    ) {
22        $this->filters = $filters;
23    }
24}

<?php

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

class Firewall
{
    /**
     * The filter instances.
     *
     * @var array
     */
    protected $filters;

    /**
     * Create a new class instance.
     */
    public function __construct(
        protected Logger $logger,
        Filter ...$filters,
    ) {
        $this->filters = $filters;
    }
}

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

1$this->app->when(Firewall::class)
2    ->needs(Filter::class)
3    ->give(function (Application $app) {
4          return [
5              $app->make(NullFilter::class),
6              $app->make(ProfanityFilter::class),
7              $app->make(TooLongFilter::class),
8          ];
9    });

$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 实例时由容器解析

1$this->app->when(Firewall::class)
2    ->needs(Filter::class)
3    ->give([
4        NullFilter::class,
5        ProfanityFilter::class,
6        TooLongFilter::class,
7    ]);

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

可变参数标记依赖

有时，一个类可能具有可变参数依赖项，该依赖项被类型提示为给定的类 (Report ...$reports)。使用 needs 和 giveTagged 方法，您可以轻松地为给定的依赖项注入具有该标记的所有容器绑定

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

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

标记

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

1$this->app->bind(CpuReport::class, function () {
2    // ...
3});
4 
5$this->app->bind(MemoryReport::class, function () {
6    // ...
7});
8 
9$this->app->tag([CpuReport::class, MemoryReport::class], 'reports');

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

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

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

一旦服务被标记，您就可以通过容器的 tagged 方法轻松解析所有服务

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

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

扩展绑定

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

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

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

解析

`make` 方法

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

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

use App\Services\Transistor;

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

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

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

use App\Services\Transistor;

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

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

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

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

如果您在代码中无法访问 $app 变量的服务提供者外部位置，您可以使用 App Facade 或 app 助手函数从容器中解析类实例

1use App\Services\Transistor;
2use Illuminate\Support\Facades\App;
3 
4$transistor = App::make(Transistor::class);
5 
6$transistor = app(Transistor::class);

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

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

$transistor = app(Transistor::class);

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

1use Illuminate\Container\Container;
2 
3/**
4 * Create a new class instance.
5 */
6public function __construct(
7    protected Container $container,
8) {}

use Illuminate\Container\Container;

/**
 * Create a new class instance.
 */
public function __construct(
    protected Container $container,
) {}

自动注入

或者，更重要的是，您可以在由容器解析的类的构造函数中类型提示依赖项，包括控制器、事件监听器、中间件等等。此外，您可以在队列任务的 handle 方法中进行依赖类型提示。在实践中，这是您的大多数对象应该如何被容器解析的。

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

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use App\Services\AppleMusic;
 6 
 7class PodcastController extends Controller
 8{
 9    /**
10     * Create a new controller instance.
11     */
12    public function __construct(
13        protected AppleMusic $apple,
14    ) {}
15 
16    /**
17     * Show information about the given podcast.
18     */
19    public function show(string $id): Podcast
20    {
21        return $this->apple->findPodcast($id);
22    }
23}

<?php

namespace App\Http\Controllers;

use App\Services\AppleMusic;

class PodcastController extends Controller
{
    /**
     * Create a new controller instance.
     */
    public function __construct(
        protected AppleMusic $apple,
    ) {}

    /**
     * Show information about the given podcast.
     */
    public function show(string $id): Podcast
    {
        return $this->apple->findPodcast($id);
    }
}

方法调用和注入

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

 1<?php
 2 
 3namespace App;
 4 
 5use App\Services\AppleMusic;
 6 
 7class PodcastStats
 8{
 9    /**
10     * Generate a new podcast stats report.
11     */
12    public function generate(AppleMusic $apple): array
13    {
14        return [
15            // ...
16        ];
17    }
18}

<?php

namespace App;

use App\Services\AppleMusic;

class PodcastStats
{
    /**
     * Generate a new podcast stats report.
     */
    public function generate(AppleMusic $apple): array
    {
        return [
            // ...
        ];
    }
}

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

1use App\PodcastStats;
2use Illuminate\Support\Facades\App;
3 
4$stats = App::call([new PodcastStats, 'generate']);

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

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

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

1use App\Services\AppleMusic;
2use Illuminate\Support\Facades\App;
3 
4$result = App::call(function (AppleMusic $apple) {
5    // ...
6});

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

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

容器事件

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

 1use App\Services\Transistor;
 2use Illuminate\Contracts\Foundation\Application;
 3 
 4$this->app->resolving(Transistor::class, function (Transistor $transistor, Application $app) {
 5    // Called when container resolves objects of type "Transistor"...
 6});
 7 
 8$this->app->resolving(function (mixed $object, Application $app) {
 9    // Called when container resolves object of any type...
10});

use App\Services\Transistor;
use Illuminate\Contracts\Foundation\Application;

$this->app->resolving(Transistor::class, function (Transistor $transistor, Application $app) {
    // Called when container resolves objects of type "Transistor"...
});

$this->app->resolving(function (mixed $object, Application $app) {
    // Called when container resolves object of any type...
});

如您所见，正在解析的对象将传递给回调，允许您在将对象提供给其使用者之前在其上设置任何其他属性。

重新绑定

rebinding 方法允许您监听服务何时重新绑定到容器，这意味着它在初始绑定后再次注册或覆盖。当您需要更新依赖项或每次特定绑定更新时修改行为时，这可能很有用

 1use App\Contracts\PodcastPublisher;
 2use App\Services\SpotifyPublisher;
 3use App\Services\TransistorPublisher;
 4use Illuminate\Contracts\Foundation\Application;
 5 
 6$this->app->bind(PodcastPublisher::class, SpotifyPublisher::class);
 7 
 8$this->app->rebinding(
 9    PodcastPublisher::class,
10    function (Application $app, PodcastPublisher $newInstance) {
11        //
12    },
13);
14 
15// New binding will trigger rebinding closure...
16$this->app->bind(PodcastPublisher::class, TransistorPublisher::class);

use App\Contracts\PodcastPublisher;
use App\Services\SpotifyPublisher;
use App\Services\TransistorPublisher;
use Illuminate\Contracts\Foundation\Application;

$this->app->bind(PodcastPublisher::class, SpotifyPublisher::class);

$this->app->rebinding(
    PodcastPublisher::class,
    function (Application $app, PodcastPublisher $newInstance) {
        //
    },
);

// New binding will trigger rebinding closure...
$this->app->bind(PodcastPublisher::class, TransistorPublisher::class);

PSR-11

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

1use App\Services\Transistor;
2use Psr\Container\ContainerInterface;
3 
4Route::get('/', function (ContainerInterface $container) {
5    $service = $container->get(Transistor::class);
6 
7    // ...
8});

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

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

    // ...
});

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

序言

快速入门

架构概念

基础知识

深入探究

安全性

数据库

Eloquent ORM

测试

扩展包

服务容器

简介

零配置解析

何时使用容器

绑定

绑定基础

简单绑定

绑定单例

绑定作用域单例

绑定实例

将接口绑定到实现

上下文绑定

上下文属性

定义自定义属性

绑定原始类型

绑定类型化的可变参数

可变参数标记依赖

标记

扩展绑定

解析

`make` 方法

自动注入

方法调用和注入

容器事件

重新绑定

PSR-11

产品

扩展包

资源