事件

简介
生成事件和监听器
注册事件和监听器
定义事件
定义监听器
队列事件监听器
调度事件
- 数据库事务后调度事件
- 延迟事件
事件订阅者
- 编写事件订阅者
- 注册事件订阅者
测试
- 伪造事件子集
- 作用域事件伪造

简介

Laravel 的事件提供了一个简单的观察者模式实现，允许您订阅和监听应用程序中发生的各种事件。事件类通常存储在 app/Events 目录中，而其监听器存储在 app/Listeners 中。如果您在应用程序中没有看到这些目录，不用担心，因为在使用 Artisan 控制台命令生成事件和监听器时会为您创建它们。

事件是解耦应用程序各个方面的绝佳方式，因为单个事件可以有多个不相互依赖的监听器。例如，您可能希望在每次订单发货时向用户发送 Slack 通知。与其将订单处理代码与 Slack 通知代码耦合，不如引发一个 App\Events\OrderShipped 事件，监听器可以接收该事件并用于发送 Slack 通知。

生成事件和监听器

要快速生成事件和监听器，您可以使用 make:event 和 make:listener Artisan 命令：

shell

php artisan make:event PodcastProcessed

php artisan make:listener SendPodcastNotification --event=PodcastProcessed

为方便起见，您也可以不带额外参数调用 make:event 和 make:listener Artisan 命令。这样做时，Laravel 会自动提示您输入类名，并在创建监听器时提示其应监听的事件：

shell

php artisan make:event

php artisan make:listener

注册事件和监听器

事件发现

默认情况下，Laravel 会通过扫描应用程序的 Listeners 目录自动查找并注册事件监听器。当 Laravel 发现任何以 handle 或 __invoke 开头的监听器类方法时，Laravel 会将这些方法注册为方法签名中类型提示的事件的事件监听器：

php

use App\Events\PodcastProcessed;

class SendPodcastNotification
{
    /**
     * 处理事件。
     */
    public function handle(PodcastProcessed $event): void
    {
        // ...
    }
}

您可以使用 PHP 的联合类型监听多个事件：

php

/**
 * 处理事件。
 */
public function handle(PodcastProcessed|PodcastPublished $event): void
{
    // ...
}

如果您计划将监听器存储在不同的目录或多个目录中，可以在应用程序的 bootstrap/app.php 文件中使用 withEvents 方法指示 Laravel 扫描这些目录：

php

->withEvents(discover: [
    __DIR__.'/../app/Domain/Orders/Listeners',
])

您可以使用 * 字符作为通配符扫描多个类似目录：

php

->withEvents(discover: [
    __DIR__.'/../app/Domain/*/Listeners',
])

可以使用 event:list 命令列出应用程序中注册的所有监听器：

shell

php artisan event:list

生产环境中的事件发现

为了提高应用程序的速度，您应该使用 optimize 或 event:cache Artisan 命令缓存应用程序所有监听器的清单。通常，此命令应作为应用程序部署过程的一部分运行。此清单将被框架用于加速事件注册过程。可以使用 event:clear 命令销毁事件缓存。

手动注册事件

使用 Event 门面，您可以在应用程序的 AppServiceProvider 的 boot 方法中手动注册事件及其对应的监听器：

php

use App\Domain\Orders\Events\PodcastProcessed;
use App\Domain\Orders\Listeners\SendPodcastNotification;
use Illuminate\Support\Facades\Event;

/**
 * 引导任何应用程序服务。
 */
public function boot(): void
{
    Event::listen(
        PodcastProcessed::class,
        SendPodcastNotification::class,
    );
}

可以使用 event:list 命令列出应用程序中注册的所有监听器：

shell

php artisan event:list

闭包监听器

通常，监听器定义为类；但是，您也可以在应用程序的 AppServiceProvider 的 boot 方法中手动注册基于闭包的事件监听器：

php

use App\Events\PodcastProcessed;
use Illuminate\Support\Facades\Event;

/**
 * 引导任何应用程序服务。
 */
public function boot(): void
{
    Event::listen(function (PodcastProcessed $event) {
        // ...
    });
}

可队列匿名事件监听器

注册基于闭包的事件监听器时，您可以将监听器闭包包装在 Illuminate\Events\queueable 函数中，以指示 Laravel 使用队列执行监听器：

php

use App\Events\PodcastProcessed;
use function Illuminate\Events\queueable;
use Illuminate\Support\Facades\Event;

/**
 * 引导任何应用程序服务。
 */
public function boot(): void
{
    Event::listen(queueable(function (PodcastProcessed $event) {
        // ...
    }));
}

与队列任务一样，您可以使用 onConnection、onQueue 和 delay 方法自定义队列监听器的执行：

php

Event::listen(queueable(function (PodcastProcessed $event) {
    // ...
})->onConnection('redis')->onQueue('podcasts')->delay(now()->plus(seconds: 10)));

如果您想处理匿名队列监听器失败的情况，可以在定义 queueable 监听器时向 catch 方法提供一个闭包。此闭包将接收事件实例和导致监听器失败的 Throwable 实例：

php

use App\Events\PodcastProcessed;
use function Illuminate\Events\queueable;
use Illuminate\Support\Facades\Event;
use Throwable;

Event::listen(queueable(function (PodcastProcessed $event) {
    // ...
})->catch(function (PodcastProcessed $event, Throwable $e) {
    // 队列监听器失败...
}));

通配符事件监听器

您也可以使用 * 字符作为通配符参数注册监听器，允许您在同一个监听器上捕获多个事件。通配符监听器接收事件名作为第一个参数，整个事件数据数组作为第二个参数：

php

Event::listen('event.*', function (string $eventName, array $data) {
    // ...
});

定义事件

事件类本质上是一个数据容器，用于保存与事件相关的信息。例如，假设一个 App\Events\OrderShipped 事件接收一个 Eloquent ORM 对象：

php

<?php

namespace App\Events;

use App\Models\Order;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class OrderShipped
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    /**
     * 创建新的事件实例。
     */
    public function __construct(
        public Order $order,
    ) {}
}

如您所见，此事件类不包含任何逻辑。它是购买的 App\Models\Order 实例的容器。事件使用的 SerializesModels 特性将在事件对象使用 PHP 的 serialize 函数序列化时优雅地序列化任何 Eloquent 模型，例如在使用队列监听器时。

定义监听器

接下来，让我们看看示例事件的监听器。事件监听器在其 handle 方法中接收事件实例。使用 --event 选项调用 make:listener Artisan 命令时，会自动导入正确的事件类并在 handle 方法中类型提示事件。在 handle 方法中，您可以执行响应事件所需的任何操作：

php

<?php

namespace App\Listeners;

use App\Events\OrderShipped;

class SendShipmentNotification
{
    /**
     * 创建事件监听器。
     */
    public function __construct() {}

    /**
     * 处理事件。
     */
    public function handle(OrderShipped $event): void
    {
        // 使用 $event->order 访问订单...
    }
}

NOTE

您的事件监听器也可以在其构造函数中类型提示所需的任何依赖项。所有事件监听器都通过 Laravel 服务容器解析，因此依赖项将自动注入。

停止事件传播

有时，您可能希望停止事件传播到其他监听器。您可以通过从监听器的 handle 方法返回 false 来实现。

队列事件监听器

如果您的监听器将执行慢速任务（如发送电子邮件或发出 HTTP 请求），队列监听器可能会很有益。在使用队列监听器之前，请确保配置您的队列并在服务器或本地开发环境中启动队列工作进程。

要指定监听器应该被队列化，请将 ShouldQueue 接口添加到监听器类。由 make:listener Artisan 命令生成的监听器已将此接口导入到当前命名空间，因此您可以立即使用它：

php

<?php

namespace App\Listeners;

use App\Events\OrderShipped;
use Illuminate\Contracts\Queue\ShouldQueue;

class SendShipmentNotification implements ShouldQueue
{
    // ...
}

就是这样！现在，当此监听器处理的事件被调度时，监听器将自动由事件调度器使用 Laravel 的队列系统进行队列化。如果队列执行监听器时没有抛出异常，队列任务将在处理完成后自动删除。

自定义队列连接、名称和延迟

如果您想自定义事件监听器的队列连接、队列名称或队列延迟时间，可以在监听器类上使用 Connection、Queue 和 Delay 属性：

php

<?php

namespace App\Listeners;

use App\Events\OrderShipped;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\Attributes\Connection;
use Illuminate\Queue\Attributes\Delay;
use Illuminate\Queue\Attributes\Queue;

#[Connection('sqs')]
#[Queue('listeners')]
#[Delay(60)]
class SendShipmentNotification implements ShouldQueue
{
    // ...
}

如果您想在运行时定义监听器的队列连接、队列名称或延迟，可以在监听器上定义 viaConnection、viaQueue 或 withDelay 方法：

php

/**
 * 获取监听器的队列连接名称。
 */
public function viaConnection(): string
{
    return 'sqs';
}

/**
 * 获取监听器的队列名称。
 */
public function viaQueue(): string
{
    return 'listeners';
}

/**
 * 获取任务处理前应等待的秒数。
 */
public function withDelay(OrderShipped $event): int
{
    return $event->highPriority ? 0 : 60;
}

条件队列化监听器

有时，您可能需要根据仅在运行时可用的某些数据确定监听器是否应该被队列化。为此，可以向监听器添加 shouldQueue 方法以确定监听器是否应该被队列化。如果 shouldQueue 方法返回 false，监听器将不会被队列化：

php

<?php

namespace App\Listeners;

use App\Events\OrderCreated;
use Illuminate\Contracts\Queue\ShouldQueue;

class RewardGiftCard implements ShouldQueue
{
    /**
     * 奖励客户礼品卡。
     */
    public function handle(OrderCreated $event): void
    {
        // ...
    }

    /**
     * 确定监听器是否应该被队列化。
     */
    public function shouldQueue(OrderCreated $event): bool
    {
        return $event->order->subtotal >= 5000;
    }
}

手动与队列交互

如果您需要手动访问监听器底层队列任务的 delete 和 release 方法，可以使用 Illuminate\Queue\InteractsWithQueue 特性。此特性在生成的监听器上默认导入，并提供对这些方法的访问：

php

<?php

namespace App\Listeners;

use App\Events\OrderShipped;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;

class SendShipmentNotification implements ShouldQueue
{
    use InteractsWithQueue;

    /**
     * 处理事件。
     */
    public function handle(OrderShipped $event): void
    {
        if ($condition) {
            $this->release(30);
        }
    }
}

队列事件监听器和数据库事务

当队列监听器在数据库事务内调度时，它们可能会在数据库事务提交之前被队列处理。发生这种情况时，您在数据库事务期间对模型或数据库记录所做的任何更新可能尚未反映在数据库中。此外，事务内创建的任何模型或数据库记录可能不存在于数据库中。如果您的监听器依赖于这些模型，处理调度队列监听器的任务时可能会发生意外错误。

如果您的队列连接的 after_commit 配置选项设置为 false，您仍然可以通过在监听器类上实现 ShouldQueueAfterCommit 接口来指示特定队列监听器应在所有打开的数据库事务提交后调度：

php

<?php

namespace App\Listeners;

use Illuminate\Contracts\Queue\ShouldQueueAfterCommit;
use Illuminate\Queue\InteractsWithQueue;

class SendShipmentNotification implements ShouldQueueAfterCommit
{
    use InteractsWithQueue;
}

NOTE

要了解更多关于解决这些问题的信息，请查看关于队列任务和数据库事务的文档。

队列监听器中间件

队列监听器也可以使用任务中间件。任务中间件允许您在队列监听器执行周围包装自定义逻辑，减少监听器本身的样板代码。创建任务中间件后，可以通过从监听器的 middleware 方法返回它们来附加到监听器：

php

<?php

namespace App\Listeners;

use App\Events\OrderShipped;
use App\Jobs\Middleware\RateLimited;
use Illuminate\Contracts\Queue\ShouldQueue;

class SendShipmentNotification implements ShouldQueue
{
    /**
     * 处理事件。
     */
    public function handle(OrderShipped $event): void
    {
        // 处理事件...
    }

    /**
     * 获取监听器应通过的中间件。
     *
     * @return array<int, object>
     */
    public function middleware(OrderShipped $event): array
    {
        return [new RateLimited];
    }
}

加密队列监听器

Laravel 允许您通过加密确保队列监听器数据的隐私和完整性。首先，只需将 ShouldBeEncrypted 接口添加到监听器类。一旦将此接口添加到类中，Laravel 将在将监听器推送到队列之前自动加密它：

php

<?php

namespace App\Listeners;

use App\Events\OrderShipped;
use Illuminate\Contracts\Queue\ShouldBeEncrypted;
use Illuminate\Contracts\Queue\ShouldQueue;

class SendShipmentNotification implements ShouldQueue, ShouldBeEncrypted
{
    // ...
}

唯一事件监听器

WARNING

唯一监听器需要支持锁的缓存驱动程序。目前，memcached、redis、dynamodb、database、file 和 array 缓存驱动程序支持原子锁。

有时，您可能希望确保在任何时候只有一个特定监听器实例在队列上。您可以通过在监听器类上实现 ShouldBeUnique 接口来实现：

php

<?php

namespace App\Listeners;

use App\Events\LicenseSaved;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Contracts\Queue\ShouldQueue;

class AcquireProductKey implements ShouldQueue, ShouldBeUnique
{
    public function __invoke(LicenseSaved $event): void
    {
        // ...
    }
}

在上面的示例中，AcquireProductKey 监听器是唯一的。因此，如果监听器的另一个实例已经在队列上且尚未完成处理，监听器将不会被队列化。这确保每个许可证只获取一个产品密钥，即使许可证在快速连续中被保存多次。

在某些情况下，您可能希望定义使监听器唯一的特定"键"，或者您可能希望指定超时时间，超过该时间监听器不再保持唯一。为此，您可以在监听器类上定义 uniqueId 和 uniqueFor 属性或方法。方法接收事件实例，允许您使用事件数据构造返回值：

php

<?php

namespace App\Listeners;

use App\Events\LicenseSaved;
use Illuminate\Contracts\Queue\ShouldBeUnique;
use Illuminate\Contracts\Queue\ShouldQueue;

class AcquireProductKey implements ShouldQueue, ShouldBeUnique
{
    /**
     * 监听器唯一锁释放后的秒数。
     *
     * @var int
     */
    public $uniqueFor = 3600;

    public function __invoke(LicenseSaved $event): void
    {
        // ...
    }

    /**
     * 获取监听器的唯一 ID。
     */
    public function uniqueId(LicenseSaved $event): string
    {
        return 'listener:'.$event->license->id;
    }
}

在处理开始前保持监听器唯一

默认情况下，唯一监听器在任务处理完成或失败后"解锁"。但是，在某些情况下，您可能希望监听器在处理开始后立即解锁。为此，监听器可以实现 ShouldBeUniqueUntilProcessing 接口：

php

<?php

namespace App\Listeners;

use App\Events\LicenseSaved;
use Illuminate\Contracts\Queue\ShouldBeUniqueUntilProcessing;
use Illuminate\Contracts\Queue\ShouldQueue;

class AcquireProductKey implements ShouldQueue, ShouldBeUniqueUntilProcessing
{
    // ...
}

唯一监听器锁

在后台，当 ShouldBeUnique 监听器被调度时，Laravel 会尝试使用 uniqueId 键获取原子锁。如果未获取到锁，则不会调度该任务。当任务完成处理或失败时，此锁会释放。通常，这是由 Laravel 自动处理的。但是，如果您的任务在超时或手动释放锁之前失败，锁可能不会被释放。在这种情况下，您可以使用 uniqueFor 属性显式定义锁应保持唯一的秒数。

如果您想直接控制锁的获取和释放，可以在监听器类上定义 uniqueLock 方法。此方法应返回一个实现 Illuminate\Contracts\Cache\Lock 接口的锁实例：

php

use Illuminate\Contracts\Cache\Lock;
use Illuminate\Support\Facades\Cache;

/**
 * 获取监听器的唯一锁。
 */
public function uniqueLock(LicenseSaved $event): Lock
{
    return Cache::lock('listener:'.$event->license->id, 3600);
}

处理失败的任务

有时您的队列事件监听器可能会失败。如果队列监听器超过队列工作进程定义的最大尝试次数，则会调用监听器上的 failed 方法。failed 方法接收事件实例和导致失败的 Throwable：

php

<?php

namespace App\Listeners;

use App\Events\OrderShipped;
use Illuminate\Contracts\Queue\ShouldQueue;
use Throwable;

class SendShipmentNotification implements ShouldQueue
{
    /**
     * 处理事件。
     */
    public function handle(OrderShipped $event): void
    {
        // ...
    }

    /**
     * 处理任务失败。
     */
    public function failed(OrderShipped $event, Throwable $e): void
    {
        // ...
    }
}

指定最大尝试次数

如果您的监听器遇到错误，您可能不希望它无限期地重试。您可以通过在监听器类上定义 tries 属性来指定监听器应尝试的最大次数：

php

<?php

namespace App\Listeners;

use App\Events\OrderShipped;
use Illuminate\Contracts\Queue\ShouldQueue;

class SendShipmentNotification implements ShouldQueue
{
    /**
     * 任务可尝试的最大次数。
     *
     * @var int
     */
    public $tries = 3;
}

或者，如果您想动态确定监听器应尝试的最大次数，可以在监听器上定义 tries 方法：

php

/**
 * 确定监听器可尝试的最大次数。
 */
public function tries(): int
{
    return 3;
}

指定时间限制

除了设置监听器失败前可尝试的次数外，您还可以定义监听器应放弃前可运行的最长时间（秒）。这允许在长时间运行的任务中，尝试次数可能不会被准确跟踪的情况下防止任务"卡住"。要定义时间限制，请在监听器类上添加 maxExceptions 属性：

php

<?php

namespace App\Listeners;

use App\Events\OrderShipped;
use Illuminate\Contracts\Queue\ShouldQueue;

class SendShipmentNotification implements ShouldQueue
{
    /**
     * 放弃前任务可运行的最长时间（秒）。
     *
     * @var int
     */
    public $timeout = 120;
}

调度事件

要调度事件，可以在事件上调用静态 dispatch 方法。此方法由事件上的 Illuminate\Foundation\Events\Dispatchable 特性提供。传递给 dispatch 方法的任何参数都将传递给事件的构造函数：

php

<?php

namespace App\Http\Controllers;

use App\Events\OrderShipped;
use App\Http\Controllers\Controller;
use App\Models\Order;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

class OrderShipmentController extends Controller
{
    /**
     * 发货给定订单。
     */
    public function store(Request $request): RedirectResponse
    {
        $order = Order::findOrFail($request->order_id);

        // 订单发货逻辑...

        OrderShipped::dispatch($order);

        return redirect('/orders');
    }
}

数据库事务后调度事件

有时，您可能希望指示 Laravel 仅在活动数据库事务提交后才调度事件。为此，可以在事件类上实现 ShouldDispatchAfterCommit 接口。

如果事务当前未激活，事件仍将立即调度：

php

<?php

namespace App\Events;

use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Contracts\Events\ShouldDispatchAfterCommit;

class OrderShipped implements ShouldDispatchAfterCommit
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
}

延迟事件

如果您想调度事件但不希望它立即被任何监听器处理，可以使用 defer 方法。此方法将事件存储在内存中，并在当前请求生命周期结束后调度它：

php

use App\Events\OrderShipped;

OrderShipped::defer($order);

如果您想在延迟事件调度之前执行一些清理工作，可以在事件类上定义 afterCommit 方法：

php

/**
 * 在调度延迟事件之前执行。
 */
public function afterCommit(): void
{
    // ...
}

事件订阅者

编写事件订阅者

事件订阅者是可以在订阅者类本身内订阅多个事件的类，允许您在单个类中定义多个事件处理程序。订阅者应定义一个 subscribe 方法，该方法将接收事件调度器实例。您可以在调度器上调用 listen 方法来注册事件监听器：

php

<?php

namespace App\Listeners;

use Illuminate\Auth\Events\Login;
use Illuminate\Auth\Events\Logout;
use Illuminate\Events\Dispatcher;

class UserEventSubscriber
{
    /**
     * 处理用户登录事件。
     */
    public function handleUserLogin(Login $event): void
    {
        // ...
    }

    /**
     * 处理用户注销事件。
     */
    public function handleUserLogout(Logout $event): void
    {
        // ...
    }

    /**
     * 为订阅者注册监听器。
     *
     * @return array<string, string>
     */
    public function subscribe(Dispatcher $events): array
    {
        return [
            Login::class => 'handleUserLogin',
            Logout::class => 'handleUserLogout',
        ];
    }
}

注册事件订阅者

编写订阅者后，如果订阅者内的处理程序方法遵循 Laravel 的事件发现约定，Laravel 将自动注册它们。否则，您可以使用 Event 门面的 subscribe 方法手动注册订阅者。通常，这应在应用程序的 AppServiceProvider 的 boot 方法中完成：

php

<?php

namespace App\Providers;

use App\Listeners\UserEventSubscriber;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    /**
     * 引导任何应用程序服务。
     */
    public function boot(): void
    {
        Event::subscribe(UserEventSubscriber::class);
    }
}

测试

测试调度事件的代码时，您可能希望指示 Laravel 不要实际执行事件的监听器，因为监听器的代码可以直接测试，与调度相应事件的代码分开。当然，要测试监听器本身，您可以在测试中实例化监听器实例并直接调用 handle 方法。

使用 Event 门面的 fake 方法，可以阻止监听器执行，执行测试代码，然后使用 assertDispatched、assertNotDispatched 和 assertNothingDispatched 方法断言应用程序调度了哪些事件：

php

<?php

use App\Events\OrderFailedToShip;
use App\Events\OrderShipped;
use Illuminate\Support\Facades\Event;

test('orders can be shipped', function () {
    Event::fake();

    // 执行订单发货...

    // 断言调度了一个事件...
    Event::assertDispatched(OrderShipped::class);

    // 断言事件被调度了两次...
    Event::assertDispatched(OrderShipped::class, 2);

    // 断言事件被调度了一次...
    Event::assertDispatchedOnce(OrderShipped::class);

    // 断言事件未被调度...
    Event::assertNotDispatched(OrderFailedToShip::class);

    // 断言没有调度任何事件...
    Event::assertNothingDispatched();
});

php

<?php

namespace Tests\Feature;

use App\Events\OrderFailedToShip;
use App\Events\OrderShipped;
use Illuminate\Support\Facades\Event;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * 测试订单发货。
     */
    public function test_orders_can_be_shipped(): void
    {
        Event::fake();

        // 执行订单发货...

        // 断言调度了一个事件...
        Event::assertDispatched(OrderShipped::class);

        // 断言事件被调度了两次...
        Event::assertDispatched(OrderShipped::class, 2);

        // 断言事件被调度了一次...
        Event::assertDispatchedOnce(OrderShipped::class);

        // 断言事件未被调度...
        Event::assertNotDispatched(OrderFailedToShip::class);

        // 断言没有调度任何事件...
        Event::assertNothingDispatched();
    }
}

您可以向 assertDispatched 或 assertNotDispatched 方法传递闭包，以断言调度了通过给定"真值测试"的事件。如果至少调度了一个通过给定真值测试的事件，则断言将成功：

php

Event::assertDispatched(function (OrderShipped $event) use ($order) {
    return $event->order->id === $order->id;
});

如果您只想断言事件监听器正在监听给定事件，可以使用 assertListening 方法：

php

Event::assertListening(
    OrderShipped::class,
    SendShipmentNotification::class
);

WARNING

调用 Event::fake() 后，不会执行任何事件监听器。因此，如果您的测试使用依赖于事件的模型工厂，例如在模型的 creating 事件期间创建 UUID，则应在使用工厂之后调用 Event::fake()。

伪造事件子集

如果您只想伪造特定事件集的事件监听器，可以将它们传递给 fake 或 fakeFor 方法：

php

test('orders can be processed', function () {
    Event::fake([
        OrderCreated::class,
    ]);

    $order = Order::factory()->create();

    Event::assertDispatched(OrderCreated::class);

    // 其他事件正常调度...
    $order->update([
        // ...
    ]);
});

php

/**
 * 测试订单处理。
 */
public function test_orders_can_be_processed(): void
{
    Event::fake([
        OrderCreated::class,
    ]);

    $order = Order::factory()->create();

    Event::assertDispatched(OrderCreated::class);

    // 其他事件正常调度...
    $order->update([
        // ...
    ]);
}

您可以使用 except 方法伪造除指定事件集之外的所有事件：

php

Event::fake()->except([
    OrderCreated::class,
]);

作用域事件伪造

如果您只想为测试的一部分伪造事件监听器，可以使用 fakeFor 方法：

php

<?php

use App\Events\OrderCreated;
use App\Models\Order;
use Illuminate\Support\Facades\Event;

test('orders can be processed', function () {
    $order = Event::fakeFor(function () {
        $order = Order::factory()->create();

        Event::assertDispatched(OrderCreated::class);

        return $order;
    });

    // 事件正常调度，观察者将运行...
    $order->update([
        // ...
    ]);
});

php

<?php

namespace Tests\Feature;

use App\Events\OrderCreated;
use App\Models\Order;
use Illuminate\Support\Facades\Event;
use Tests\TestCase;

class ExampleTest extends TestCase
{
    /**
     * 测试订单处理。
     */
    public function test_orders_can_be_processed(): void
    {
        $order = Event::fakeFor(function () {
            $order = Order::factory()->create();

            Event::assertDispatched(OrderCreated::class);

            return $order;
        });

        // 事件正常调度，观察者将运行...
        $order->update([
            // ...
        ]);
    }
}

事件 ​

简介 ​

生成事件和监听器 ​

注册事件和监听器 ​

事件发现 ​

生产环境中的事件发现 ​

手动注册事件 ​

闭包监听器 ​

可队列匿名事件监听器 ​

通配符事件监听器 ​

定义事件 ​

定义监听器 ​

停止事件传播 ​

队列事件监听器 ​

自定义队列连接、名称和延迟 ​

条件队列化监听器 ​

手动与队列交互 ​

队列事件监听器和数据库事务 ​

队列监听器中间件 ​

加密队列监听器 ​

唯一事件监听器 ​

在处理开始前保持监听器唯一 ​

唯一监听器锁 ​

处理失败的任务 ​

指定最大尝试次数 ​

指定时间限制 ​

调度事件 ​

数据库事务后调度事件 ​

延迟事件 ​

事件订阅者 ​

编写事件订阅者 ​

注册事件订阅者 ​

测试 ​

伪造事件子集 ​

作用域事件伪造 ​

事件

简介

生成事件和监听器

注册事件和监听器

事件发现

生产环境中的事件发现

手动注册事件

闭包监听器

可队列匿名事件监听器

通配符事件监听器

定义事件

定义监听器

停止事件传播

队列事件监听器

自定义队列连接、名称和延迟

条件队列化监听器

手动与队列交互

队列事件监听器和数据库事务

队列监听器中间件

加密队列监听器

唯一事件监听器

在处理开始前保持监听器唯一

唯一监听器锁

处理失败的任务

指定最大尝试次数

指定时间限制

调度事件

数据库事务后调度事件

延迟事件

事件订阅者

编写事件订阅者

注册事件订阅者

测试

伪造事件子集

作用域事件伪造