广播

1php artisan install:broadcasting

1php artisan install:broadcasting --reverb

1composer require laravel/reverb

1php artisan reverb:install

1php artisan install:broadcasting --pusher

1composer require pusher/pusher-php-server

1PUSHER_APP_ID="your-pusher-app-id"
2PUSHER_APP_KEY="your-pusher-key"
3PUSHER_APP_SECRET="your-pusher-secret"
4PUSHER_HOST=
5PUSHER_PORT=443
6PUSHER_SCHEME="https"
7PUSHER_APP_CLUSTER="mt1"

1BROADCAST_CONNECTION=pusher

1php artisan install:broadcasting --ably

1composer require ably/ably-php

1ABLY_KEY=your-ably-key

1BROADCAST_CONNECTION=ably

1npm install --save-dev laravel-echo pusher-js

1npm run build

1npm install --save-dev laravel-echo pusher-js

 1PUSHER_APP_ID="your-pusher-app-id"
 2PUSHER_APP_KEY="your-pusher-key"
 3PUSHER_APP_SECRET="your-pusher-secret"
 4PUSHER_HOST=
 5PUSHER_PORT=443
 6PUSHER_SCHEME="https"
 7PUSHER_APP_CLUSTER="mt1"
 8 
 9VITE_APP_NAME="${APP_NAME}"
10VITE_PUSHER_APP_KEY="${PUSHER_APP_KEY}"
11VITE_PUSHER_HOST="${PUSHER_HOST}"
12VITE_PUSHER_PORT="${PUSHER_PORT}"
13VITE_PUSHER_SCHEME="${PUSHER_SCHEME}"
14VITE_PUSHER_APP_CLUSTER="${PUSHER_APP_CLUSTER}"

1npm run build

 1import Echo from 'laravel-echo';
 2import Pusher from 'pusher-js';
 3 
 4const options = {
 5    broadcaster: 'pusher',
 6    key: import.meta.env.VITE_PUSHER_APP_KEY
 7}
 8 
 9window.Echo = new Echo({
10    ...options,
11    client: new Pusher(options.key, options)
12});

1npm install --save-dev laravel-echo pusher-js

1npm run dev

1use App\Events\OrderShipmentStatusUpdated;
2 
3OrderShipmentStatusUpdated::dispatch($order);

 1<?php
 2 
 3namespace App\Events;
 4 
 5use App\Models\Order;
 6use Illuminate\Broadcasting\Channel;
 7use Illuminate\Broadcasting\InteractsWithSockets;
 8use Illuminate\Broadcasting\PresenceChannel;
 9use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
10use Illuminate\Queue\SerializesModels;
11 
12class OrderShipmentStatusUpdated implements ShouldBroadcast
13{
14    /**
15     * The order instance.
16     *
17     * @var \App\Models\Order
18     */
19    public $order;
20}

 1use Illuminate\Broadcasting\Channel;
 2use Illuminate\Broadcasting\PrivateChannel;
 3 
 4/**
 5 * Get the channel the event should broadcast on.
 6 */
 7public function broadcastOn(): Channel
 8{
 9    return new PrivateChannel('orders.'.$this->order->id);
10}

 1use Illuminate\Broadcasting\PrivateChannel;
 2 
 3/**
 4 * Get the channels the event should broadcast on.
 5 *
 6 * @return array<int, \Illuminate\Broadcasting\Channel>
 7 */
 8public function broadcastOn(): array
 9{
10    return [
11        new PrivateChannel('orders.'.$this->order->id),
12        // ...
13    ];
14}

1use App\Models\Order;
2use App\Models\User;
3 
4Broadcast::channel('orders.{orderId}', function (User $user, int $orderId) {
5    return $user->id === Order::findOrNew($orderId)->user_id;
6});

 1<?php
 2 
 3namespace App\Events;
 4 
 5use App\Models\User;
 6use Illuminate\Broadcasting\Channel;
 7use Illuminate\Broadcasting\InteractsWithSockets;
 8use Illuminate\Broadcasting\PresenceChannel;
 9use Illuminate\Broadcasting\PrivateChannel;
10use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
11use Illuminate\Queue\SerializesModels;
12 
13class ServerCreated implements ShouldBroadcast
14{
15    use SerializesModels;
16 
17    /**
18     * Create a new event instance.
19     */
20    public function __construct(
21        public User $user,
22    ) {}
23 
24    /**
25     * Get the channels the event should broadcast on.
26     *
27     * @return array<int, \Illuminate\Broadcasting\Channel>
28     */
29    public function broadcastOn(): array
30    {
31        return [
32            new PrivateChannel('user.'.$this->user->id),
33        ];
34    }
35}

1/**
2 * The event's broadcast name.
3 */
4public function broadcastAs(): string
5{
6    return 'server.created';
7}

1.listen('.server.created', function (e) {
2    // ...
3});

1{
2    "user": {
3        "id": 1,
4        "name": "Patrick Stewart"
5        ...
6    }
7}

1/**
2 * Get the data to broadcast.
3 *
4 * @return array<string, mixed>
5 */
6public function broadcastWith(): array
7{
8    return ['id' => $this->user->id];
9}

1use Illuminate\Queue\Attributes\Connection;
2use Illuminate\Queue\Attributes\Queue;
3 
4#[Connection('redis')]
5#[Queue('default')]
6class ServerCreated implements ShouldBroadcast
7{
8    // ...
9}

1/**
2 * The name of the queue on which to place the broadcasting job.
3 */
4public function broadcastQueue(): string
5{
6    return 'default';
7}

 1<?php
 2 
 3namespace App\Events;
 4 
 5use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
 6 
 7class OrderShipmentStatusUpdated implements ShouldBroadcastNow
 8{
 9    // ...
10}

1/**
2 * Determine if this event should broadcast.
3 */
4public function broadcastWhen(): bool
5{
6    return $this->order->value > 100;
7}

 1<?php
 2 
 3namespace App\Events;
 4 
 5use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
 6use Illuminate\Contracts\Events\ShouldDispatchAfterCommit;
 7use Illuminate\Queue\SerializesModels;
 8 
 9class ServerCreated implements ShouldBroadcast, ShouldDispatchAfterCommit
10{
11    use SerializesModels;
12}

1->withRouting(
2    web: __DIR__.'/../routes/web.php',
3    channels: __DIR__.'/../routes/channels.php',
4    health: '/up',
5)

1use App\Models\User;
2 
3Broadcast::channel('orders.{orderId}', function (User $user, int $orderId) {
4    return $user->id === Order::findOrNew($orderId)->user_id;
5});

1php artisan channel:list

1use App\Models\Order;
2use App\Models\User;
3 
4Broadcast::channel('orders.{order}', function (User $user, Order $order) {
5    return $user->id === $order->user_id;
6});

1Broadcast::channel('channel', function () {
2    // ...
3}, ['guards' => ['web', 'admin']]);

1php artisan make:channel OrderChannel

1use App\Broadcasting\OrderChannel;
2 
3Broadcast::channel('orders.{order}', OrderChannel::class);

 1<?php
 2 
 3namespace App\Broadcasting;
 4 
 5use App\Models\Order;
 6use App\Models\User;
 7 
 8class OrderChannel
 9{
10    /**
11     * Create a new channel instance.
12     */
13    public function __construct() {}
14 
15    /**
16     * Authenticate the user's access to the channel.
17     */
18    public function join(User $user, Order $order): array|bool
19    {
20        return $user->id === $order->user_id;
21    }
22}

1use App\Events\OrderShipmentStatusUpdated;
2 
3OrderShipmentStatusUpdated::dispatch($order);

1use App\Events\OrderShipmentStatusUpdated;
2 
3broadcast(new OrderShipmentStatusUpdated($update))->toOthers();

1axios.post('/task', task)
2    .then((response) => {
3        this.tasks.push(response.data);
4    });

1var socketId = Echo.socketId();

1use App\Events\OrderShipmentStatusUpdated;
2 
3broadcast(new OrderShipmentStatusUpdated($update))->via('pusher');

 1<?php
 2 
 3namespace App\Events;
 4 
 5use Illuminate\Broadcasting\Channel;
 6use Illuminate\Broadcasting\InteractsWithBroadcasting;
 7use Illuminate\Broadcasting\InteractsWithSockets;
 8use Illuminate\Broadcasting\PresenceChannel;
 9use Illuminate\Broadcasting\PrivateChannel;
10use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
11use Illuminate\Queue\SerializesModels;
12 
13class OrderShipmentStatusUpdated implements ShouldBroadcast
14{
15    use InteractsWithBroadcasting;
16 
17    /**
18     * Create a new event instance.
19     */
20    public function __construct()
21    {
22        $this->broadcastVia('pusher');
23    }
24}

1Broadcast::on('orders.'.$order->id)->send();

1{
2    "event": "AnonymousEvent",
3    "data": "[]",
4    "channel": "orders.1"
5}

1Broadcast::on('orders.'.$order->id)
2    ->as('OrderPlaced')
3    ->with($order)
4    ->send();

1{
2    "event": "OrderPlaced",
3    "data": "{ id: 1, total: 100 }",
4    "channel": "orders.1"
5}

1Broadcast::private('orders.'.$order->id)->send();
2Broadcast::presence('channels.'.$channel->id)->send();

1Broadcast::on('orders.'.$order->id)->sendNow();

1Broadcast::on('orders.'.$order->id)
2    ->toOthers()
3    ->send();

 1<?php
 2 
 3namespace App\Events;
 4 
 5use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
 6use Illuminate\Contracts\Broadcasting\ShouldRescue;
 7 
 8class ServerCreated implements ShouldBroadcast, ShouldRescue
 9{
10    // ...
11}

1Echo.channel(`orders.${this.order.id}`)
2    .listen('OrderShipmentStatusUpdated', (e) => {
3        console.log(e.order.name);
4    });

1Echo.private(`orders.${this.order.id}`)
2    .listen(/* ... */)
3    .listen(/* ... */)
4    .listen(/* ... */);

1Echo.private(`orders.${this.order.id}`)
2    .stopListening('OrderShipmentStatusUpdated');

1Echo.leaveChannel(`orders.${this.order.id}`);

1Echo.leave(`orders.${this.order.id}`);

1window.Echo = new Echo({
2    broadcaster: 'pusher',
3    // ...
4    namespace: 'App.Other.Namespace'
5});

1Echo.channel('orders')
2    .listen('.Namespace\\Event\\Class', (e) => {
3        // ...
4    });

1useEcho(
2    `orders.${orderId}`,
3    ["OrderShipmentStatusUpdated", "OrderShipped"],
4    (e) => {
5        console.log(e.order);
6    },
7);

 1type OrderData = {
 2    order: {
 3        id: number;
 4        user: {
 5            id: number;
 6            name: string;
 7        };
 8        created_at: string;
 9    };
10};
11 
12useEcho<OrderData>(`orders.${orderId}`, "OrderShipmentStatusUpdated", (e) => {
13    console.log(e.order.id);
14    console.log(e.order.user.id);
15});

1use App\Models\User;
2 
3Broadcast::channel('chat.{roomId}', function (User $user, int $roomId) {
4    if ($user->canJoinRoom($roomId)) {
5        return ['id' => $user->id, 'name' => $user->name];
6    }
7});

 1Echo.join(`chat.${roomId}`)
 2    .here((users) => {
 3        // ...
 4    })
 5    .joining((user) => {
 6        console.log(user.name);
 7    })
 8    .leaving((user) => {
 9        console.log(user.name);
10    })
11    .error((error) => {
12        console.error(error);
13    });

 1/**
 2 * Get the channels the event should broadcast on.
 3 *
 4 * @return array<int, \Illuminate\Broadcasting\Channel>
 5 */
 6public function broadcastOn(): array
 7{
 8    return [
 9        new PresenceChannel('chat.'.$this->message->room_id),
10    ];
11}

1broadcast(new NewMessage($message));
2 
3broadcast(new NewMessage($message))->toOthers();

1Echo.join(`chat.${roomId}`)
2    .here(/* ... */)
3    .joining(/* ... */)
4    .leaving(/* ... */)
5    .listen('NewMessage', (e) => {
6        // ...
7    });

 1<?php
 2 
 3namespace App\Models;
 4 
 5use Illuminate\Broadcasting\Channel;
 6use Illuminate\Broadcasting\PrivateChannel;
 7use Illuminate\Database\Eloquent\BroadcastsEvents;
 8use Illuminate\Database\Eloquent\Factories\HasFactory;
 9use Illuminate\Database\Eloquent\Model;
10use Illuminate\Database\Eloquent\Relations\BelongsTo;
11 
12class Post extends Model
13{
14    use BroadcastsEvents, HasFactory;
15 
16    /**
17     * Get the user that the post belongs to.
18     */
19    public function user(): BelongsTo
20    {
21        return $this->belongsTo(User::class);
22    }
23 
24    /**
25     * Get the channels that model events should broadcast on.
26     *
27     * @return array<int, \Illuminate\Broadcasting\Channel|\Illuminate\Database\Eloquent\Model>
28     */
29    public function broadcastOn(string $event): array
30    {
31        return [$this, $this->user];
32    }
33}

 1/**
 2 * Get the channels that model events should broadcast on.
 3 *
 4 * @return array<string, array<int, \Illuminate\Broadcasting\Channel|\Illuminate\Database\Eloquent\Model>>
 5 */
 6public function broadcastOn(string $event): array
 7{
 8    return match ($event) {
 9        'deleted' => [],
10        default => [$this, $this->user],
11    };
12}

 1use Illuminate\Database\Eloquent\BroadcastableModelEventOccurred;
 2 
 3/**
 4 * Create a new broadcastable model event for the model.
 5 */
 6protected function newBroadcastableEvent(string $event): BroadcastableModelEventOccurred
 7{
 8    return (new BroadcastableModelEventOccurred(
 9        $this, $event
10    ))->dontBroadcastToCurrentUser();
11}

 1use Illuminate\Broadcasting\PrivateChannel;
 2 
 3/**
 4 * Get the channels that model events should broadcast on.
 5 *
 6 * @return array<int, \Illuminate\Broadcasting\Channel>
 7 */
 8public function broadcastOn(string $event): array
 9{
10    return [
11        new PrivateChannel('user.'.$this->id)
12    ];
13}

1return [new Channel($this->user)];

1$user->broadcastChannel();

1{
2    "model": {
3        "id": 1,
4        "title": "My first post"
5        ...
6    },
7    ...
8    "socket": "someSocketId"
9}

 1/**
 2 * The model event's broadcast name.
 3 */
 4public function broadcastAs(string $event): string|null
 5{
 6    return match ($event) {
 7        'created' => 'post.created',
 8        default => null,
 9    };
10}
11 
12/**
13 * Get the data to broadcast for the model.
14 *
15 * @return array<string, mixed>
16 */
17public function broadcastWith(string $event): array
18{
19    return match ($event) {
20        'created' => ['title' => $this->title],
21        default => ['model' => $this],
22    };
23}

1Echo.private(`App.Models.User.${this.user.id}`)
2    .listen('.UserUpdated', (e) => {
3        console.log(e.model);
4    });

 1type User = {
 2    id: number;
 3    name: string;
 4    email: string;
 5};
 6 
 7useEchoModel<User, "App.Models.User">("App.Models.User", userId, ["UserUpdated"], (e) => {
 8    console.log(e.model.id);
 9    console.log(e.model.name);
10});

 1const callback = (notification) => {
 2    console.log(notification.type);
 3}
 4 
 5// Start listening...
 6Echo.private(`App.Models.User.${userId}`)
 7    .notification(callback);
 8 
 9// Stop listening (callback must be the same)...
10Echo.private(`App.Models.User.${userId}`)
11    .stopListeningForNotification(callback);