Prologo

Primi Passi

Architettura

Le Basi

Approfondimenti

Sicurezza

Database

Eloquent ORM

Testing

Package

Broadcasting

Introduzione

In molte applicazioni web moderne, i WebSockets vengono utilizzati per implementare interfacce utente in tempo reale e aggiornamenti live. Quando alcuni dati vengono aggiornati sul server, un messaggio viene generalmente inviato tramite una connessione WebSocket per essere gestito dal client. I WebSockets offrono un’alternativa più efficiente rispetto al continuo polling del server dell’applicazione per rilevare cambiamenti nei dati che dovrebbero essere riflessi nell’interfaccia utente.

Ad esempio, immagina che la tua applicazione possa esportare i dati di un utente in un file CSV e inviarli via email. Tuttavia, la creazione di questo file CSV richiede diversi minuti, quindi scegli di creare e inviare il CSV all’interno di un job in coda. Quando il CSV è stato creato e inviato all’utente, possiamo utilizzare il broadcasting degli eventi per dispatchare un evento App\Events\UserDataExported che viene ricevuto dal JavaScript della nostra applicazione. Una volta ricevuto l’evento, possiamo mostrare un messaggio all’utente che il loro CSV è stato inviato via email senza che debbano mai ricaricare la pagina.

Per aiutarti a costruire questo tipo di funzionalità, Laravel rende facile "broadcastare" i tuoi eventi Laravel lato server attraverso una connessione WebSocket. Broadcastare i tuoi eventi Laravel ti permette di condividere gli stessi nomi di eventi e i dati tra la tua applicazione Laravel lato server e la tua applicazione JavaScript lato client.

I concetti fondamentali dietro il broadcasting sono semplici: i client si connettono a canali nominati nel frontend, mentre la tua applicazione Laravel broadcasta eventi su questi canali nel backend. Questi eventi possono contenere tutti i dati aggiuntivi che desideri rendere disponibili nel frontend.

Driver Supportati

Per impostazione predefinita, Laravel include tre driver di broadcasting lato server tra cui scegliere: Laravel Reverb, Pusher Channels e Ably.

Prima di iniziare con il broadcasting degli eventi, assicurati di aver letto la documentazione di Laravel su eventi e listener.

Installazione lato Server

Per iniziare a usare il broadcasting degli eventi di Laravel, dobbiamo configurare l’applicazione Laravel e installare alcuni pacchetti.

Il broadcasting degli eventi viene realizzato da un driver di broadcasting lato server che trasmette i tuoi eventi Laravel in modo che Laravel Echo (una libreria JavaScript) possa riceverli nel client del browser. Non preoccuparti: guideremo ogni parte del processo di installazione passo dopo passo.

Configurazione

Tutta la configurazione per lo streaming degli eventi della tua applicazione si trova nel file config/broadcasting.php. Non preoccuparti se questa directory non esiste nella tua applicazione; verrà creata quando esegui il comando Artisan install:broadcasting.

Laravel supporta diversi driver di streaming pronti all’uso: Laravel Reverb, Pusher Channels, Ably e un driver log per lo sviluppo locale e il debug. Inoltre, è incluso un driver null che permette di disabilitare lo streaming durante i test. Nel file config/broadcasting.php è incluso un esempio di configurazione per ciascuno di questi driver.

Installazione

Per impostazione predefinita, lo broadcasting non è abilitato nelle nuove applicazioni Laravel. Puoi abilitare lo broadcasting usando il comando Artisan install:broadcasting:

php artisan install:broadcasting

Il comando install:broadcasting creerà il file di configurazione config/broadcasting.php. Inoltre, il comando creerà il file routes/channels.php dove potrai registrare le route di autorizzazione per lo broadcasting della tua applicazione e i relativi callback.

Configurazione della Coda

Prima di trasmettere qualsiasi evento, devi configurare ed eseguire un queue worker. Tutta la trasmissione degli eventi avviene tramite job in coda, in modo che il tempo di risposta della tua applicazione non sia notevolmente influenzato dagli eventi trasmessi.

Reverb

Quando esegui il comando install:broadcasting, ti verrà chiesto di installare Laravel Reverb. Naturalmente, puoi anche installare Reverb manualmente usando il gestore di pacchetti Composer.

composer require laravel/reverb

Una volta installato il pacchetto, puoi eseguire il comando di installazione di Reverb per pubblicare la configurazione, aggiungere le variabili d’ambiente richieste da Reverb e abilitare la trasmissione degli eventi nella tua applicazione:

php artisan reverb:install

Puoi trovare istruzioni dettagliate per l’installazione e l’uso di Reverb nella documentazione di Reverb.

Pusher Channels

Se prevedi di trasmettere i tuoi eventi utilizzando Pusher Channels, dovresti installare l’SDK PHP di Pusher Channels usando il gestore di pacchetti Composer:

composer require pusher/pusher-php-server

Successivamente, configura le tue credenziali di Pusher Channels nel file di configurazione config/broadcasting.php. Un esempio di configurazione per Pusher Channels è già incluso in questo file, permettendoti di specificare rapidamente la tua chiave, il segreto e l’ID dell’applicazione. Di solito, dovresti configurare le tue credenziali di Pusher Channels nel file .env della tua applicazione:

PUSHER_APP_ID="your-pusher-app-id"
PUSHER_APP_KEY="your-pusher-key"
PUSHER_APP_SECRET="your-pusher-secret"
PUSHER_HOST=
PUSHER_PORT=443
PUSHER_SCHEME="https"
PUSHER_APP_CLUSTER="mt1"

La configurazione pusher nel file config/broadcasting.php ti permette anche di specificare ulteriori options supportate da Channels, come ad esempio il cluster.

Poi, imposta la variabile d’ambiente BROADCAST_CONNECTION su pusher nel file .env della tua applicazione:

BROADCAST_CONNECTION=pusher

Infine, sei pronto per installare e configurare Laravel Echo, che riceverà gli eventi di broadcast lato client.

Ably

La documentazione seguente spiega come usare Ably in modalità "compatibilità con Pusher". Tuttavia, il team di Ably consiglia e mantiene un broadcaster e un client Echo capaci di sfruttare le funzionalità uniche offerte da Ably. Per maggiori informazioni sull’uso dei driver mantenuti da Ably, consulta la documentazione del broadcaster Laravel di Ably.

Se intendi trasmettere i tuoi eventi usando Ably, devi installare l’SDK PHP di Ably utilizzando Composer:

composer require ably/ably-php

Successivamente, configura le tue credenziali Ably nel file di configurazione config/broadcasting.php. In questo file è già incluso un esempio di configurazione Ably, permettendoti di specificare rapidamente la tua chiave. Solitamente, questo valore dovrebbe essere impostato tramite la variabile d’ambiente ABLY_KEY:

ABLY_KEY=your-ably-key

Poi, imposta la variabile d’ambiente BROADCAST_CONNECTION su ably nel file .env della tua applicazione:

BROADCAST_CONNECTION=ably

Infine, sei pronto per installare e configurare Laravel Echo, che riceverà gli eventi broadcast sul lato client.

Installazione lato client

Reverb

Laravel Echo è una libreria JavaScript che semplifica l’iscrizione ai canali e l’ascolto degli eventi trasmessi dal driver di broadcasting lato server. Puoi installare Echo tramite il gestore di pacchetti NPM. In questo esempio, installeremo anche il pacchetto pusher-js poiché Reverb utilizza il protocollo Pusher per le sottoscrizioni WebSocket, i canali e i messaggi:

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

Una volta installato Echo, sei pronto per creare una nuova istanza di Echo nel JavaScript della tua applicazione. Un ottimo posto per farlo è alla fine del file resources/js/bootstrap.js incluso con il framework Laravel. Di default, in questo file è già inclusa una configurazione di esempio di Echo: devi semplicemente sbloccarla e aggiornare l’opzione di configurazione broadcaster a reverb:

import Echo from 'laravel-echo';

import Pusher from 'pusher-js';
window.Pusher = Pusher;

window.Echo = new Echo({
    broadcaster: 'reverb',
    key: import.meta.env.VITE_REVERB_APP_KEY,
    wsHost: import.meta.env.VITE_REVERB_HOST,
    wsPort: import.meta.env.VITE_REVERB_PORT,
    wssPort: import.meta.env.VITE_REVERB_PORT,
    forceTLS: (import.meta.env.VITE_REVERB_SCHEME ?? 'https') === 'https',
    enabledTransports: ['ws', 'wss'],
});

Successivamente, dovresti compilare le risorse della tua applicazione:

npm run build

Il broadcaster reverb di Laravel Echo richiede laravel-echo v1.16.0+.

Pusher Channels

Laravel Echo è una libreria JavaScript che facilita l’iscrizione ai canali e l’ascolto degli eventi trasmessi dal tuo driver di broadcasting lato server. Echo utilizza anche il pacchetto NPM pusher-js per implementare il protocollo Pusher per le sottoscrizioni WebSocket, i canali e i messaggi.

Il comando Artisan install:broadcasting installa automaticamente i pacchetti laravel-echo e pusher-js per te; tuttavia, puoi anche installare questi pacchetti manualmente tramite NPM:

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

Una volta installato Echo, sei pronto per creare una nuova istanza di Echo nel JavaScript della tua applicazione. Il comando install:broadcasting crea un file di configurazione Echo in resources/js/echo.js; tuttavia, la configurazione predefinita in questo file è pensata per Laravel Reverb. Puoi copiare la configurazione seguente per passare a Pusher:

import Echo from 'laravel-echo';

import Pusher from 'pusher-js';
window.Pusher = Pusher;

window.Echo = new Echo({
    broadcaster: 'pusher',
    key: import.meta.env.VITE_PUSHER_APP_KEY,
    cluster: import.meta.env.VITE_PUSHER_APP_CLUSTER,
    forceTLS: true
});

Successivamente, dovresti definire i valori appropriati per le variabili d’ambiente di Pusher nel file .env della tua applicazione. Se queste variabili non esistono già nel tuo file .env, devi aggiungerle:

PUSHER_APP_ID="your-pusher-app-id"
PUSHER_APP_KEY="your-pusher-key"
PUSHER_APP_SECRET="your-pusher-secret"
PUSHER_HOST=
PUSHER_PORT=443
PUSHER_SCHEME="https"
PUSHER_APP_CLUSTER="mt1"

VITE_APP_NAME="${APP_NAME}"
VITE_PUSHER_APP_KEY="${PUSHER_APP_KEY}"
VITE_PUSHER_HOST="${PUSHER_HOST}"
VITE_PUSHER_PORT="${PUSHER_PORT}"
VITE_PUSHER_SCHEME="${PUSHER_SCHEME}"
VITE_PUSHER_APP_CLUSTER="${PUSHER_APP_CLUSTER}"

Una volta adeguata la configurazione di Echo secondo le esigenze della tua applicazione, puoi compilare gli asset della tua applicazione:

npm run build

Per saperne di più sulla compilazione degli asset JavaScript della tua applicazione, consulta la documentazione su Vite.

Utilizzare un’istanza client esistente

Se hai già un’istanza client di Pusher Channels preconfigurata che desideri che Echo utilizzi, puoi passarla a Echo tramite l’opzione di configurazione client:

import Echo from 'laravel-echo';
import Pusher from 'pusher-js';

const options = {
    broadcaster: 'pusher',
    key: 'your-pusher-channels-key'
}

window.Echo = new Echo({
    ...options,
    client: new Pusher(options.key, options)
});

Ably

La documentazione qui sotto spiega come usare Ably in modalità "compatibilità Pusher". Tuttavia, il team di Ably consiglia e mantiene un broadcaster e un client Echo che possono sfruttare le capacità uniche offerte da Ably. Per maggiori informazioni sull’utilizzo dei driver mantenuti da Ably, si prega di consultare la documentazione del broadcaster Laravel di Ably.

Laravel Echo è una libreria JavaScript che rende semplice iscriversi ai canali e ascoltare gli eventi trasmessi dal tuo driver di broadcasting lato server. Echo utilizza anche il pacchetto NPM pusher-js per implementare il protocollo Pusher per abbonamenti WebSocket, canali e messaggi.

Il comando Artisan install:broadcasting installa automaticamente i pacchetti laravel-echo e pusher-js per te; tuttavia, puoi anche installare questi pacchetti manualmente tramite NPM:

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

Prima di continuare, dovresti abilitare il supporto al protocollo Pusher nelle impostazioni della tua applicazione Ably. Puoi abilitare questa funzione nella sezione "Protocol Adapter Settings" del pannello delle impostazioni della tua applicazione Ably.

Una volta installato Echo, sei pronto per creare una nuova istanza di Echo nel JavaScript della tua applicazione. Il comando install:broadcasting crea un file di configurazione Echo in resources/js/echo.js; tuttavia, la configurazione predefinita in questo file è pensata per Laravel Reverb. Puoi copiare la configurazione sottostante per adattare la tua configurazione ad Ably:

import Echo from 'laravel-echo';

import Pusher from 'pusher-js';
window.Pusher = Pusher;

window.Echo = new Echo({
    broadcaster: 'pusher',
    key: import.meta.env.VITE_ABLY_PUBLIC_KEY,
    wsHost: 'realtime-pusher.ably.io',
    wsPort: 443,
    disableStats: true,
    encrypted: true,
});

Potresti aver notato che la nostra configurazione Echo per Ably fa riferimento a una variabile d’ambiente VITE_ABLY_PUBLIC_KEY. Il valore di questa variabile dovrebbe essere la tua chiave pubblica Ably. La tua chiave pubblica è la parte della tua chiave Ably che appare prima del carattere :.

Una volta che hai adattato la configurazione Echo secondo le tue necessità, puoi compilare le risorse della tua applicazione:

npm run dev

Per saperne di più sulla compilazione delle risorse JavaScript della tua applicazione, consulta la documentazione su Vite.

Panoramica del Concetto

La trasmissione di eventi di Laravel ti permette di inviare i tuoi eventi Laravel lato server alla tua applicazione JavaScript lato client utilizzando un approccio basato su driver per i WebSockets. Attualmente, Laravel include i driver Pusher Channels e Ably. Gli eventi possono essere facilmente consumati lato client utilizzando il pacchetto JavaScript Laravel Echo.

Gli eventi vengono trasmessi su "canali", che possono essere specificati come pubblici o privati. Qualsiasi visitatore della tua applicazione può iscriversi a un canale pubblico senza alcuna autenticazione o autorizzazione; tuttavia, per iscriversi a un canale privato, un utente deve essere autenticato e autorizzato ad ascoltare su quel canale.

Utilizzo di un’Applicazione di Esempio

Prima di approfondire ogni componente della trasmissione degli eventi, facciamo una panoramica generale utilizzando un negozio di e-commerce come esempio.

Nella nostra applicazione, supponiamo di avere una pagina che permette agli utenti di visualizzare lo stato di spedizione dei loro ordini. Supponiamo inoltre che venga generato un evento OrderShipmentStatusUpdated quando un aggiornamento dello stato di spedizione viene elaborato dall’applicazione:

use App\Events\OrderShipmentStatusUpdated;

OrderShipmentStatusUpdated::dispatch($order);

L’interfaccia ShouldBroadcast

Quando un utente visualizza uno dei suoi ordini, non vogliamo che debba ricaricare la pagina per vedere gli aggiornamenti di stato. Invece, vogliamo trasmettere gli aggiornamenti all’applicazione man mano che vengono creati. Pertanto, dobbiamo segnare l’evento OrderShipmentStatusUpdated con l’interfaccia ShouldBroadcast. Questo istruirà Laravel a trasmettere l’evento quando viene attivato:

    <?php

    namespace App\Events;

    use App\Models\Order;
    use Illuminate\Broadcasting\Channel;
    use Illuminate\Broadcasting\InteractsWithSockets;
    use Illuminate\Broadcasting\PresenceChannel;
    use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
    use Illuminate\Queue\SerializesModels;

    class OrderShipmentStatusUpdated implements ShouldBroadcast
    {
        /**
         * The order instance.
         *
         * @var \App\Models\Order
         */
        public $order;
    }

L’interfaccia ShouldBroadcast richiede che il nostro evento definisca un metodo broadcastOn. Questo metodo è responsabile di restituire i canali su cui l’evento deve essere trasmesso. Uno scheletro vuoto di questo metodo è già definito nelle classi degli eventi generate, quindi dobbiamo solo completare i dettagli. Vogliamo che solo il creatore dell’ordine possa visualizzare gli aggiornamenti di stato, quindi trasmetteremo l’evento su un canale privato legato all’ordine:

    use Illuminate\Broadcasting\Channel;
    use Illuminate\Broadcasting\PrivateChannel;

    /**
     * Get the channel the event should broadcast on.
     */
    public function broadcastOn(): Channel
    {
        return new PrivateChannel('orders.'.$this->order->id);
    }

Se desideri che l’evento venga trasmesso su più canali, puoi restituire un array invece:

    use Illuminate\Broadcasting\PrivateChannel;

    /**
     * Get the channels the event should broadcast on.
     *
     * @return array<int, \Illuminate\Broadcasting\Channel>
     */
    public function broadcastOn(): array
    {
        return [
            new PrivateChannel('orders.'.$this->order->id),
            // ...
        ];
    }

Autorizzare i Canali

Ricorda, gli utenti devono essere autorizzati ad ascoltare sui canali privati. Possiamo definire le regole di autorizzazione dei canali nel file routes/channels.php della nostra applicazione. In questo esempio, dobbiamo verificare che qualsiasi utente che tenta di ascoltare sul canale privato orders.1 sia effettivamente il creatore dell’ordine:

use App\Models\Order;
use App\Models\User;

Broadcast::channel('orders.{orderId}', function (User $user, int $orderId) {
    return $user->id === Order::findOrNew($orderId)->user_id;
});

Il metodo channel accetta due argomenti: il nome del canale e una callback che ritorna true o false indicando se l’utente è autorizzato ad ascoltare sul canale.

Tutte le callback di autorizzazione ricevono l’utente autenticato attualmente come primo argomento e eventuali parametri wildcard aggiuntivi come argomenti successivi. In questo esempio, stiamo usando il segnaposto {orderId} per indicare che la parte "ID" del nome del canale è un wildcard.

Ascolto dei Broadcast di Eventi

Successivamente, tutto ciò che resta è ascoltare l’evento nella nostra applicazione JavaScript. Possiamo farlo usando Laravel Echo. Prima, useremo il metodo private per iscriverci al canale privato. Poi, possiamo usare il metodo listen per ascoltare l’evento OrderShipmentStatusUpdated. Per default, tutte le proprietà pubbliche dell’evento saranno incluse nel broadcast dell’evento:

Echo.private(`orders.${orderId}`)
    .listen('OrderShipmentStatusUpdated', (e) => {
        console.log(e.order);
    });

Definire gli Eventi di Broadcast

Per informare Laravel che un determinato evento deve essere broadcast, devi implementare l’interfaccia Illuminate\Contracts\Broadcasting\ShouldBroadcast nella classe dell’evento. Questa interfaccia è già importata in tutte le classi degli eventi generate dal framework, quindi puoi aggiungerla facilmente a qualsiasi tuo evento.

L’interfaccia ShouldBroadcast richiede di implementare un unico metodo: broadcastOn. Il metodo broadcastOn deve restituire un canale o un array di canali su cui l’evento deve essere broadcast. I canali devono essere istanze di Channel, PrivateChannel o PresenceChannel. Le istanze di Channel rappresentano canali pubblici a cui qualsiasi utente può iscriversi, mentre PrivateChannels e PresenceChannels rappresentano canali privati che richiedono autorizzazione dei canali:

<?php

namespace App\Events;

use App\Models\User;
use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Broadcasting\PresenceChannel;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Queue\SerializesModels;

class ServerCreated implements ShouldBroadcast
{
    use SerializesModels;

    /**
     * Crea una nuova istanza dell'evento.
     */
    public function __construct(
        public User $user,
    ) {}

    /**
     * Ottieni i canali su cui l'evento deve essere broadcast.
     *
     * @return array<int, \Illuminate\Broadcasting\Channel>
     */
    public function broadcastOn(): array
    {
        return [
            new PrivateChannel('user.'.$this->user->id),
        ];
    }
}

Dopo aver implementato l’interfaccia ShouldBroadcast, devi solo emettere l’evento come fai normalmente. Una volta che l’evento è stato emesso, un job in coda broadcastarà automaticamente l’evento utilizzando il driver di broadcast specificato.

Nome del Broadcast

Per impostazione predefinita, Laravel trasmetterà l’evento usando il nome della classe dell’evento. Tuttavia, puoi personalizzare il nome del broadcast definendo un metodo broadcastAs nell’evento:

/**
 * Il nome del broadcast dell'evento.
 */
public function broadcastAs(): string
{
    return 'server.created';
}

Se personalizzi il nome del broadcast usando il metodo broadcastAs, assicurati di registrare il tuo listener con un carattere . iniziale. Questo indicherà a Echo di non anteporre lo spazio dei nomi dell’applicazione all’evento:

.listen('.server.created', function (e) {
    ....
});

Dati del Broadcast

Quando un evento viene trasmesso, tutte le sue proprietà public sono automaticamente serializzate e trasmesse come payload dell’evento, permettendoti di accedere a qualsiasi dato pubblico dalla tua applicazione JavaScript. Quindi, ad esempio, se il tuo evento ha una singola proprietà pubblica $user che contiene un modello Eloquent, il payload trasmesso dell’evento sarà:

{
    "user": {
        "id": 1,
        "name": "Patrick Stewart"
        ...
    }
}

Tuttavia, se desideri avere un controllo più dettagliato sul payload del tuo broadcast, puoi aggiungere un metodo broadcastWith al tuo evento. Questo metodo dovrebbe restituire l’array di dati che desideri trasmettere come payload dell’evento:

    /**
     * Get the data to broadcast.
     *
     * @return array<string, mixed>
     */
    public function broadcastWith(): array
    {
        return ['id' => $this->user->id];
    }

Broadcast Queue

Per default, ogni evento di broadcast viene inserito nella queue predefinita per la connessione di queue predefinita specificata nel tuo file di configurazione queue.php. Puoi personalizzare la connessione della queue e il nome usati dal broadcaster definendo le proprietà connection e queue nella tua classe evento:

/**
 * Il nome della connessione queue da usare quando si trasmette l'evento.
 *
 * @var string
 */
public $connection = 'redis';

/**
 * Il nome della queue su cui inserire il job di broadcast.
 *
 * @var string
 */
public $queue = 'default';

In alternativa, puoi personalizzare il nome della queue definendo un metodo broadcastQueue nel tuo evento:

/**
 * Il nome della queue su cui inserire il job di broadcast.
 */
public function broadcastQueue(): string
{
    return 'default';
}

Se desideri trasmettere il tuo evento utilizzando la queue sync invece del driver di queue predefinito, puoi implementare l’interfaccia ShouldBroadcastNow invece di ShouldBroadcast:

<?php

use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;

class OrderShipmentStatusUpdated implements ShouldBroadcastNow
{
    // ...
}

Condizioni di Broadcast

A volte vuoi trasmettere il tuo evento solo se una determinata condizione è vera. Puoi definire queste condizioni aggiungendo un metodo broadcastWhen alla tua classe evento:

/**
 * Determina se questo evento deve essere trasmesso.
 */
public function broadcastWhen(): bool
{
    return $this->order->value > 100;
}

Broadcasting e Transazioni nel Database

Quando gli eventi di broadcast vengono dispatchati all’interno di transazioni nel database, potrebbero essere elaborati dalla coda prima che la transazione del database sia stata commessa. Quando ciò accade, eventuali aggiornamenti che hai effettuato sui modelli o sui record del database durante la transazione potrebbero non essere ancora riflessi nel database. Inoltre, eventuali modelli o record del database creati all’interno della transazione potrebbero non esistere nel database. Se il tuo evento dipende da questi modelli, potrebbero verificarsi errori inaspettati quando il job che esegue il broadcast dell’evento viene processato.

Se l’opzione di configurazione after_commit della tua connessione di coda è impostata su false, puoi comunque indicare che un particolare evento di broadcast debba essere dispatchato dopo che tutte le transazioni aperte nel database sono state commesse implementando l’interfaccia ShouldDispatchAfterCommit nella classe dell’evento:

    <?php

    namespace App\Events;

    use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
    use Illuminate\Contracts\Events\ShouldDispatchAfterCommit;
    use Illuminate\Queue\SerializesModels;

    class ServerCreated implements ShouldBroadcast, ShouldDispatchAfterCommit
    {
        use SerializesModels;
    }

Per saperne di più su come aggirare questi problemi, consulta la documentazione relativa a queued jobs and database transactions.

Autorizzazione dei Canali

I canali privati richiedono di autorizzare che l’utente attualmente autenticato possa effettivamente ascoltare sul canale. Ciò si ottiene effettuando una richiesta HTTP alla tua applicazione Laravel con il nome del canale, permettendo alla tua applicazione di determinare se l’utente può ascoltare su quel canale. Quando usi Laravel Echo, la richiesta HTTP per autorizzare le sottoscrizioni ai canali privati viene fatta automaticamente.

Quando il broadcasting è abilitato, Laravel registra automaticamente la rotta /broadcasting/auth per gestire le richieste di autorizzazione. La rotta /broadcasting/auth viene automaticamente inserita nel gruppo di middleware web.

Definizione dei Callback di Autorizzazione

Successivamente, dobbiamo definire la logica che determinerà se l’utente autenticato può ascoltare un determinato canale. Questo viene fatto nel file routes/channels.php creato dal comando Artisan install:broadcasting. In questo file, puoi usare il metodo Broadcast::channel per registrare i callback di autorizzazione dei canali:

use App\Models\User;

Broadcast::channel('orders.{orderId}', function (User $user, int $orderId) {
    return $user->id === Order::findOrNew($orderId)->user_id;
});

Il metodo channel accetta due argomenti: il nome del canale e un callback che restituisce true o false per indicare se l’utente è autorizzato ad ascoltare il canale.

Tutti i callback di autorizzazione ricevono l’utente autenticato come primo argomento e eventuali parametri wildcard come argomenti successivi. In questo esempio, usiamo il segnaposto {orderId} per indicare che la parte "ID" del nome del canale è una wildcard.

Puoi visualizzare l’elenco dei callback di autorizzazione per lo streaming della tua applicazione usando il comando Artisan channel:list:

php artisan channel:list

Binding del Modello tramite Callback di Autorizzazione

Proprio come le rotte HTTP, anche le rotte dei canali possono beneficiare del route model binding implicito ed esplicito. Ad esempio, invece di ricevere un ID ordine come stringa o numero, puoi richiedere un’istanza reale del modello Order:

use App\Models\Order;
use App\Models\User;

Broadcast::channel('orders.{order}', function (User $user, Order $order) {
    return $user->id === $order->user_id;
});

A differenza del route model binding delle rotte HTTP, il channel model binding non supporta lo scoping automatico del implicit model binding scoping. Tuttavia, questo è raramente un problema poiché la maggior parte dei canali può essere limitata in base alla chiave primaria unica di un singolo modello.

Autenticazione del Callback di Autorizzazione

I canali di broadcast privati e di presenza autenticano l’utente corrente tramite la guardia di autenticazione predefinita della tua applicazione. Se l’utente non è autenticato, l’autorizzazione al canale viene automaticamente negata e il callback di autorizzazione non viene mai eseguito. Tuttavia, puoi assegnare più guardie personalizzate che devono autenticare la richiesta in arrivo se necessario:

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

Definire le Classi dei Canali

Se la tua applicazione utilizza molti canali differenti, il file routes/channels.php potrebbe diventare ingombrante. Quindi, invece di usare le closure per autorizzare i canali, puoi usare le classi dei canali. Per generare una classe di canale, usa il comando Artisan make:channel. Questo comando creerà una nuova classe di canale nella directory App/Broadcasting.

php artisan make:channel OrderChannel

Successivamente, registra il tuo canale nel file routes/channels.php:

    use App\Broadcasting\OrderChannel;

    Broadcast::channel('orders.{order}', OrderChannel::class);

Infine, puoi inserire la logica di autorizzazione per il tuo canale nel metodo join della classe del canale. Questo metodo join conterrà la stessa logica che normalmente avresti inserito nella closure di autorizzazione del canale. Puoi anche sfruttare il binding del modello del canale:

    <?php

    namespace App\Broadcasting;

    use App\Models\Order;
    use App\Models\User;

    class OrderChannel
    {
        /**
         * Crea una nuova istanza di canale.
         */
        public function __construct() {}

        /**
         * Autentica l'accesso dell'utente al canale.
         */
        public function join(User $user, Order $order): array|bool
        {
            return $user->id === $order->user_id;
        }
    }

Come molte altre classi in Laravel, le classi dei canali saranno risolte automaticamente dal service container. Quindi, puoi specificare qualsiasi dipendenza necessaria per il tuo canale nel suo costruttore.

Trasmettere gli Eventi

Dopo aver definito un evento e contrassegnato con l’interfaccia ShouldBroadcast, devi solo attivarlo usando il metodo dispatch. Il dispatcher riconoscerà l’interfaccia ShouldBroadcast e metterà in coda l’evento per la trasmissione:

use App\Events\OrderShipmentStatusUpdated;

OrderShipmentStatusUpdated::dispatch($order);

Solo agli Altri

Quando costruisci un’applicazione che utilizza la trasmissione di eventi, potresti occasionalmente aver bisogno di trasmettere un evento a tutti gli abbonati di un determinato canale tranne l’utente corrente. Puoi ottenere ciò utilizzando l’helper broadcast e il metodo toOthers:

use App\Events\OrderShipmentStatusUpdated;

broadcast(new OrderShipmentStatusUpdated($update))->toOthers();

Per comprendere meglio quando potresti voler usare il metodo toOthers, immaginiamo un’applicazione di elenco attività dove un utente può creare una nuova attività inserendo un nome. Per creare un’attività, la tua applicazione potrebbe fare una richiesta a un URL /task che trasmette la creazione dell’attività e restituisce una rappresentazione JSON della nuova attività. Quando la tua applicazione JavaScript riceve la risposta dall’endpoint, potrebbe inserire direttamente la nuova attività nel suo elenco come segue:

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

Tuttavia, ricorda che trasmettiamo anche la creazione dell’attività. Se la tua applicazione JavaScript ascolta anche questo evento per aggiungere attività all’elenco, avrai attività duplicate nel tuo elenco: una dall’endpoint e una dalla trasmissione. Puoi risolvere questo utilizzando il metodo toOthers per istruire il trasmettitore a non trasmettere l’evento all’utente corrente.

Il tuo evento deve utilizzare il trait Illuminate\Broadcasting\InteractsWithSockets per poter chiamare il metodo toOthers.

Configurazione

Quando inizializzi un’istanza di Laravel Echo, viene assegnato un ID socket alla connessione. Se stai usando un’istanza globale di Axios per fare richieste HTTP dalla tua applicazione JavaScript, l’ID socket verrà automaticamente aggiunto a ogni richiesta in uscita come header X-Socket-ID. Poi, quando chiami il metodo toOthers, Laravel estrarrà l’ID socket dall’header e istruirà il broadcaster a non trasmettere a nessuna connessione con quell’ID socket.

Se non stai usando un’istanza globale di Axios, dovrai configurare manualmente la tua applicazione JavaScript per inviare l’header X-Socket-ID con tutte le richieste in uscita. Puoi recuperare l’ID socket usando il metodo Echo.socketId:

var socketId = Echo.socketId();

Personalizzare la Connessione

Se la tua applicazione utilizza più connessioni di broadcast e desideri trasmettere un evento usando un broadcaster diverso da quello predefinito, puoi specificare a quale connessione inviare l’evento utilizzando il metodo via:

    use App\Events\OrderShipmentStatusUpdated;

    broadcast(new OrderShipmentStatusUpdated($update))->via('pusher');

In alternativa, puoi specificare la connessione di broadcast dell’evento chiamando il metodo broadcastVia nel costruttore dell’evento. Tuttavia, prima di farlo, assicurati che la classe dell’evento utilizzi il trait InteractsWithBroadcasting:

    <?php

    namespace App\Events;

    use Illuminate\Broadcasting\Channel;
    use Illuminate\Broadcasting\InteractsWithBroadcasting;
    use Illuminate\Broadcasting\InteractsWithSockets;
    use Illuminate\Broadcasting\PresenceChannel;
    use Illuminate\Broadcasting\PrivateChannel;
    use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
    use Illuminate\Queue\SerializesModels;

    class OrderShipmentStatusUpdated implements ShouldBroadcast
    {
        use InteractsWithBroadcasting;

        /**
         * Crea una nuova istanza dell'evento.
         */
        public function __construct()
        {
            $this->broadcastVia('pusher');
        }
    }

Eventi Anonimi

A volte, potresti voler trasmettere un evento semplice al frontend della tua applicazione senza creare una classe evento dedicata. Per questo, il facade Broadcast permette di trasmettere "eventi anonimi":

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

L’esempio sopra trasmetterà il seguente evento:

{
    "event": "AnonymousEvent",
    "data": "[]",
    "channel": "orders.1"
}

Usando i metodi as e with, puoi personalizzare il nome e i dati dell’evento:

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

L’esempio sopra trasmetterà un evento simile al seguente:

{
    "event": "OrderPlaced",
    "data": "{ id: 1, total: 100 }",
    "channel": "orders.1"
}

Se desideri trasmettere l’evento anonimo su un canale privato o di presenza, puoi utilizzare i metodi private e presence:

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

Trasmettere un evento anonimo usando il metodo send invia l’evento alla coda della tua applicazione per l’elaborazione. Tuttavia, se vuoi trasmettere l’evento immediatamente, puoi usare il metodo sendNow:

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

Per trasmettere l’evento a tutti gli abbonati al canale eccetto l’utente attualmente autenticato, puoi invocare il metodo toOthers:

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

Ricevere Broadcasts

Ascolto degli Eventi

Dopo aver installato e istanziato Laravel Echo, sei pronto per iniziare ad ascoltare gli eventi trasmessi dalla tua applicazione Laravel. Per prima cosa, usa il metodo channel per ottenere un’istanza di un canale, poi chiama il metodo listen per ascoltare un evento specifico:

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

Se desideri ascoltare gli eventi su un canale privato, usa invece il metodo private. Puoi continuare a concatenare chiamate al metodo listen per ascoltare più eventi su un singolo canale:

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

Interrompere l’ascolto per gli eventi

Se desideri interrompere l’ascolto di un determinato evento senza lasciare il canale, puoi usare il metodo stopListening:

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

Lasciare un canale

Per lasciare un canale, puoi chiamare il metodo leaveChannel sulla tua istanza Echo:

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

Se desideri lasciare un canale e anche i canali privati e di presenza associati, puoi usare il metodo leave:

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

Namespace

Probabilmente hai notato negli esempi precedenti che non abbiamo specificato l’intero namespace App\Events per le classi degli eventi. Questo perché Echo presumerà automaticamente che gli eventi si trovino nel namespace App\Events. Tuttavia, puoi configurare il namespace principale quando istanzi Echo passando un’opzione di configurazione namespace:

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

In alternativa, puoi anteporre un . alle classi degli eventi quando ti iscrivi a loro usando Echo. Questo ti permetterà di specificare sempre il nome completo della classe:

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

Presence Channels

I canali di presenza si basano sulla sicurezza dei canali privati, offrendo inoltre la funzionalità aggiuntiva di consapevolezza su chi è iscritto al canale. Questo facilita la creazione di funzionalità applicative potenti e collaborative, come notificare gli utenti quando un altro utente sta visualizzando la stessa pagina o elencare gli abitanti di una chat room.

Autorizzare i Canali di Presenza

Tutti i canali di presenza sono anche canali privati; quindi, gli utenti devono essere autorizzati ad accedervi. Tuttavia, quando definisci le callback di autorizzazione per i canali di presenza, non restituirai true se l’utente è autorizzato a unirsi al canale. Invece, dovresti restituire un array di dati sull’utente.

I dati restituiti dalla callback di autorizzazione saranno disponibili agli ascoltatori di eventi del canale di presenza nella tua applicazione JavaScript. Se l’utente non è autorizzato a unirsi al canale di presenza, dovresti restituire false o null:

use App\Models\User;

Broadcast::channel('chat.{roomId}', function (User $user, int $roomId) {
    if ($user->canJoinRoom($roomId)) {
        return ['id' => $user->id, 'name' => $user->name];
    }
});

Unire Canali di Presenza

Per unirti a un canale di presenza, puoi utilizzare il metodo join di Echo. Il metodo join restituirà un’implementazione di PresenceChannel che, insieme al metodo listen, ti permette di iscriverti agli eventi here, joining e leaving.

Echo.join(`chat.${roomId}`)
    .here((users) => {
        // ...
    })
    .joining((user) => {
        console.log(user.name);
    })
    .leaving((user) => {
        console.log(user.name);
    })
    .error((error) => {
        console.error(error);
    });

La callback here verrà eseguita immediatamente dopo che il canale è stato unito con successo e riceverà un array contenente le informazioni degli utenti attualmente iscritti al canale. Il metodo joining verrà eseguito quando un nuovo utente si unisce al canale, mentre il metodo leaving verrà eseguito quando un utente lascia il canale. Il metodo error verrà eseguito quando l’endpoint di autenticazione restituisce un codice di stato HTTP diverso da 200 o se c’è un problema nel parsing del JSON restituito.

Trasmissione nei Canali di Presenza

I canali di presenza possono ricevere eventi proprio come i canali pubblici o privati. Usando l’esempio di una chat, potremmo voler trasmettere eventi NewMessage al canale di presenza della stanza. Per farlo, restituiremo un’istanza di PresenceChannel dal metodo broadcastOn dell’evento:

/**
 * Get the channels the event should broadcast on.
 *
 * @return array<int, \Illuminate\Broadcasting\Channel>
 */
public function broadcastOn(): array
{
    return [
        new PresenceChannel('chat.'.$this->message->room_id),
    ];
}

Come per altri eventi, puoi usare l’assistente broadcast e il metodo toOthers per escludere l’utente corrente dal ricevere la trasmissione:

broadcast(new NewMessage($message));

broadcast(new NewMessage($message))->toOthers();

Come di consueto per altri tipi di eventi, puoi ascoltare gli eventi inviati ai canali di presenza utilizzando il metodo listen di Echo:

Echo.join(`chat.${roomId}`)
    .here(/* ... */)
    .joining(/* ... */)
    .leaving(/* ... */)
    .listen('NewMessage', (e) => {
        // ...
    });

Broadcasting dei Modelli

Prima di leggere la seguente documentazione sul broadcasting dei modelli, ti consigliamo di familiarizzare con i concetti generali dei servizi di broadcasting dei modelli di Laravel e con come creare e ascoltare manualmente gli eventi di broadcast.

È comune trasmettere eventi quando i modelli Eloquent della tua applicazione vengono creati, aggiornati o eliminati. Naturalmente, ciò può essere facilmente realizzato definendo manualmente eventi personalizzati per i cambiamenti di stato dei modelli Eloquent e contrassegnando questi eventi con l’interfaccia ShouldBroadcast.

Tuttavia, se non utilizzi questi eventi per altri scopi nella tua applicazione, può essere scomodo creare classi di eventi solo per trasmetterli. Per risolvere questo problema, Laravel ti permette di indicare che un modello Eloquent dovrebbe trasmettere automaticamente i suoi cambiamenti di stato.

Per iniziare, il tuo modello Eloquent dovrebbe utilizzare il trait Illuminate\Database\Eloquent\BroadcastsEvents. Inoltre, il modello dovrebbe definire un metodo broadcastOn, che restituirà un array di canali su cui gli eventi del modello verranno trasmessi:

<?php

namespace App\Models;

use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Database\Eloquent\BroadcastsEvents;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Post extends Model
{
    use BroadcastsEvents, HasFactory;

    /**
     * Get the user that the post belongs to.
     */
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }

    /**
     * Get the channels that model events should broadcast on.
     *
     * @return array<int, \Illuminate\Broadcasting\Channel|\Illuminate\Database\Eloquent\Model>
     */
    public function broadcastOn(string $event): array
    {
        return [$this, $this->user];
    }
}

Una volta che il tuo modello include questo trait e definisce i suoi canali di broadcast, inizierà automaticamente a trasmettere eventi quando un’istanza del modello viene creata, aggiornata, eliminata, archiviata o ripristinata.

Inoltre, potresti aver notato che il metodo broadcastOn riceve un argomento stringa $event. Questo argomento contiene il tipo di evento che si è verificato sul modello e avrà un valore di created, updated, deleted, trashed o restored. Esaminando il valore di questa variabile, puoi determinare su quali canali (se presenti) il modello dovrebbe trasmettere per un determinato evento:

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

Personalizzare la Creazione degli Eventi di Broadcasting del Modello

A volte potresti voler personalizzare come Laravel crea l’evento di broadcasting del modello. Puoi farlo definendo un metodo newBroadcastableEvent nel tuo modello Eloquent. Questo metodo deve restituire un’istanza di Illuminate\Database\Eloquent\BroadcastableModelEventOccurred:

use Illuminate\Database\Eloquent\BroadcastableModelEventOccurred;

/**
 * Crea un nuovo evento di modello broadcastable per il modello.
 */
protected function newBroadcastableEvent(string $event): BroadcastableModelEventOccurred
{
    return (new BroadcastableModelEventOccurred(
        $this, $event
    ))->dontBroadcastToCurrentUser();
}

Convenzioni per il Broadcasting dei Modelli

Convenzioni sui Canali

Come avrai notato, il metodo broadcastOn nell’esempio di modello sopra non ha restituito istanze di Channel. Invece, sono stati restituiti direttamente i modelli Eloquent. Se un’istanza di modello Eloquent viene restituita dal metodo broadcastOn del tuo modello (o è contenuta in un array restituito dal metodo), Laravel istanzierà automaticamente un’istanza di canale privato per il modello utilizzando il nome della classe del modello e l’identificatore della chiave primaria come nome del canale.

Quindi, un modello App\Models\User con un id di 1 verrebbe convertito in un’istanza di Illuminate\Broadcasting\PrivateChannel con un nome di App.Models.User.1. Naturalmente, oltre a restituire istanze di modelli Eloquent dal metodo broadcastOn del tuo modello, puoi restituire istanze complete di Channel per avere il pieno controllo sui nomi dei canali del modello:

use Illuminate\Broadcasting\PrivateChannel;

/**
 * Get the channels that model events should broadcast on.
 *
 * @return array<int, \Illuminate\Broadcasting\Channel>
 */
public function broadcastOn(string $event): array
{
    return [
        new PrivateChannel('user.'.$this->id)
    ];
}

Se prevedi di restituire esplicitamente un’istanza di canale dal metodo broadcastOn del tuo modello, puoi passare un’istanza di modello Eloquent al costruttore del canale. In questo modo, Laravel utilizzerà le convenzioni sui canali dei modelli discusse sopra per convertire il modello Eloquent in una stringa di nome del canale:

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

Se hai bisogno di determinare il nome del canale di un modello, puoi chiamare il metodo broadcastChannel su qualsiasi istanza di modello. Ad esempio, questo metodo restituisce la stringa App.Models.User.1 per un modello App\Models\User con un id di 1:

$user->broadcastChannel()

Convenzioni sugli Eventi

Poiché gli eventi di broadcast dei modelli non sono associati a un evento "reale" all’interno della directory App\Events della tua applicazione, vengono assegnati un nome e un payload basati su convenzioni. La convenzione di Laravel prevede di trasmettere l’evento utilizzando il nome della classe del modello (senza includere il namespace) e il nome dell’evento del modello che ha attivato il broadcast.

Ad esempio, un aggiornamento del modello App\Models\Post trasmetterebbe un evento alla tua applicazione lato client come PostUpdated con il seguente payload:

{
    "model": {
        "id": 1,
        "title": "My first post"
        ...
    },
    ...
    "socket": "someSocketId",
}

La cancellazione del modello App\Models\User trasmetterebbe un evento denominato UserDeleted.

Se lo desideri, puoi definire un nome di broadcast e un payload personalizzati aggiungendo i metodi broadcastAs e broadcastWith al tuo modello. Questi metodi ricevono il nome dell’evento/operazione del modello che si sta verificando, permettendoti di personalizzare il nome e il payload dell’evento per ogni operazione del modello. Se il metodo broadcastAs restituisce null, Laravel utilizzerà le convenzioni di denominazione degli eventi di broadcast del modello discusse sopra durante la trasmissione dell’evento:

/**
 * The model event's broadcast name.
 */
public function broadcastAs(string $event): string|null
{
    return match ($event) {
        'created' => 'post.created',
        default => null,
    };
}

/**
 * Get the data to broadcast for the model.
 *
 * @return array<string, mixed>
 */
public function broadcastWith(string $event): array
{
    return match ($event) {
        'created' => ['title' => $this->title],
        default => ['model' => $this],
    };
}

Ascoltare le Trasmissioni dei Modelli

Dopo aver aggiunto il trait BroadcastsEvents al tuo modello e definito il metodo broadcastOn del modello, sei pronto per iniziare ad ascoltare gli eventi di modello trasmessi all’interno della tua applicazione lato client. Prima di cominciare, potresti voler consultare la documentazione completa su ascoltare gli eventi.

Innanzitutto, utilizza il metodo private per ottenere un’istanza di un canale, quindi chiama il metodo listen per ascoltare un evento specifico. Generalmente, il nome del canale passato al metodo private dovrebbe corrispondere alle convenzioni di trasmissione dei modelli di Laravel.

Una volta ottenuta un’istanza del canale, puoi usare il metodo listen per ascoltare un particolare evento. Poiché gli eventi di trasmissione dei modelli non sono associati a un evento "reale" nella directory App\Events della tua applicazione, il nome dell’evento deve essere preceduto da un . per indicare che non appartiene a uno specifico namespace. Ogni evento di trasmissione del modello ha una proprietà model che contiene tutte le proprietà trasmissibili del modello:

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

Eventi Client

Quando usi Pusher Channels, devi abilitare l’opzione "Client Events" nella sezione "App Settings" del tuo application dashboard per poter inviare eventi client.

A volte potresti voler trasmettere un evento ad altri client connessi senza coinvolgere affatto la tua applicazione Laravel. Questo può essere particolarmente utile per notifiche come "sta digitando", dove vuoi avvisare gli utenti della tua applicazione che un altro utente sta scrivendo un messaggio in una determinata schermata.

Per trasmettere eventi client, puoi usare il metodo whisper di Echo:

Echo.private(`chat.${roomId}`)
    .whisper('typing', {
        name: this.user.name
    });

Per ascoltare gli eventi client, puoi usare il metodo listenForWhisper:

Echo.private(`chat.${roomId}`)
    .listenForWhisper('typing', (e) => {
        console.log(e.name);
    });

Notifiche

Associando la trasmissione di eventi con le notifiche, la tua applicazione JavaScript può ricevere nuove notifiche non appena si verificano senza dover ricaricare la pagina. Prima di iniziare, assicurati di leggere la documentazione sull’uso di il canale di notifica broadcast.

Una volta configurata una notifica per utilizzare il canale broadcast, puoi ascoltare gli eventi broadcast usando il metodo notification di Echo. Ricorda, il nome del canale dovrebbe corrispondere al nome della classe dell’entità che riceve le notifiche:

Echo.private(`App.Models.User.${userId}`)
    .notification((notification) => {
        console.log(notification.type);
    });

In questo esempio, tutte le notifiche inviate alle istanze di App\Models\User tramite il canale broadcast saranno ricevute dal callback. Un callback di autorizzazione del canale per il canale App.Models.User.{id} è incluso nel file routes/channels.php della tua applicazione.

Lascia un commento

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Laravel-Italia.it è il sito della Community Italiana di Laravel.
2024 — Laravel-Italia