服務容器

簡介
- 零配置解析
- 何時使用容器
繫結
解析
- 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）檢索播客。因此，我們將注入一個能夠檢索播客的服務。由於服務是注入的，我們在測試應用程式時可以輕鬆地“模擬”（mock）或建立一個 AppleMusic 服務的虛擬實現。

深入瞭解 Laravel 服務容器對於構建強大的大型應用程式以及為 Laravel 核心本身做出貢獻至關重要。

零配置解析

如果一個類沒有依賴項，或者僅依賴於其他具體類（而非介面），則無需指示容器如何解析該類。例如，您可以將以下程式碼放在 routes/web.php 檔案中

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

<?php

class Service
{
    // ...
}

Route::get('/', function (Service $service) {
    dd($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));
});

Singleton 屬性

或者，您可以使用 #[Singleton] 屬性標記介面或類，以向容器指示它應該被解析一次。

 1<?php
 2 
 3namespace App\Services;
 4 
 5use Illuminate\Container\Attributes\Singleton;
 6 
 7#[Singleton]
 8class Transistor
 9{
10    // ...
11}

<?php

namespace App\Services;

use Illuminate\Container\Attributes\Singleton;

#[Singleton]
class Transistor
{
    // ...
}

繫結作用域單例

scoped 方法將類或介面繫結到容器中，該類或介面僅應在給定的 Laravel 請求/任務生命週期內被解析一次。雖然此方法與 singleton 方法類似，但使用 scoped 方法註冊的例項將在 Laravel 應用程式啟動新“生命週期”時被清除，例如當 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));
});

Scoped 屬性

或者，您可以使用 #[Scoped] 屬性標記介面或類，以向容器指示它應該在給定的 Laravel 請求/任務生命週期內被解析一次。

 1<?php
 2 
 3namespace App\Services;
 4 
 5use Illuminate\Container\Attributes\Scoped;
 6 
 7#[Scoped]
 8class Transistor
 9{
10    // ...
11}

<?php

namespace App\Services;

use Illuminate\Container\Attributes\Scoped;

#[Scoped]
class Transistor
{
    // ...
}

繫結例項

您還可以使用 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,
) {}

Bind 屬性

為了更加方便，Laravel 還提供了 Bind 屬性。您可以將此屬性應用於任何介面，以告知 Laravel 每當請求該介面時應自動注入哪個實現。使用 Bind 屬性時，無需在應用程式的服務提供者中執行任何額外的服務註冊。

此外，可以在介面上放置多個 Bind 屬性，以便為特定的環境集配置應注入的不同實現。

 1<?php
 2 
 3namespace App\Contracts;
 4 
 5use App\Services\FakeEventPusher;
 6use App\Services\RedisEventPusher;
 7use Illuminate\Container\Attributes\Bind;
 8 
 9#[Bind(RedisEventPusher::class)]
10#[Bind(FakeEventPusher::class, environments: ['local', 'testing'])]
11interface EventPusher
12{
13    // ...
14}

<?php

namespace App\Contracts;

use App\Services\FakeEventPusher;
use App\Services\RedisEventPusher;
use Illuminate\Container\Attributes\Bind;

#[Bind(RedisEventPusher::class)]
#[Bind(FakeEventPusher::class, environments: ['local', 'testing'])]
interface EventPusher
{
    // ...
}

此外，可以應用 Singleton 和 Scoped 屬性來指示容器繫結是應該被解析一次還是每個請求/任務生命週期解析一次。

 1use App\Services\RedisEventPusher;
 2use Illuminate\Container\Attributes\Bind;
 3use Illuminate\Container\Attributes\Singleton;
 4 
 5#[Bind(RedisEventPusher::class)]
 6#[Singleton]
 7interface EventPusher
 8{
 9    // ...
10}

use App\Services\RedisEventPusher;
use Illuminate\Container\Attributes\Bind;
use Illuminate\Container\Attributes\Singleton;

#[Bind(RedisEventPusher::class)]
#[Singleton]
interface EventPusher
{
    // ...
}

上下文繫結

有時您可能有兩個類使用相同的介面，但您希望向每個類注入不同的實現。例如，兩個控制器可能依賴於 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}

<?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、Context、DB、Give、Log、RouteParameter 和 Tag 屬性。

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

<?php

namespace App\Http\Controllers;

use App\Contracts\UserRepository;
use App\Models\Photo;
use App\Repositories\DatabaseRepository;
use Illuminate\Container\Attributes\Auth;
use Illuminate\Container\Attributes\Cache;
use Illuminate\Container\Attributes\Config;
use Illuminate\Container\Attributes\Context;
use Illuminate\Container\Attributes\DB;
use Illuminate\Container\Attributes\Give;
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,
        #[Context('uuid')] protected string $uuid,
        #[Context('ulid', hidden: true)] protected string $ulid,
        #[DB('mysql')] protected Connection $connection,
        #[Give(DatabaseRepository::class)] protected UserRepository $users,
        #[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 Attribute;
 6use Illuminate\Contracts\Container\Container;
 7use Illuminate\Contracts\Container\ContextualAttribute;
 8 
 9#[Attribute(Attribute::TARGET_PARAMETER)]
10class Config implements ContextualAttribute
11{
12    /**
13     * Create a new attribute instance.
14     */
15    public function __construct(public string $key, public mixed $default = null)
16    {
17    }
18 
19    /**
20     * Resolve the configuration value.
21     *
22     * @param  self  $attribute
23     * @param  \Illuminate\Contracts\Container\Container  $container
24     * @return mixed
25     */
26    public static function resolve(self $attribute, Container $container)
27    {
28        return $container->make('config')->get($attribute->key, $attribute->default);
29    }
30}

<?php

namespace App\Attributes;

use Attribute;
use Illuminate\Contracts\Container\Container;
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');

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 的例項。

服務容器

簡介

零配置解析

何時使用容器

繫結

繫結基礎

簡單繫結

繫結單例

Singleton 屬性

繫結作用域單例

Scoped 屬性

繫結例項

將介面繫結到實現

Bind 屬性

上下文繫結

上下文屬性

定義自定義屬性

繫結原始值

繫結型別化可變引數

可變標籤依賴

標籤

擴充套件繫結

解析

`make` 方法

自動注入

方法呼叫與注入

容器事件

重新繫結

PSR-11

在此頁面上

產品

Packages

資源

合作伙伴