Comment fonctionne la diffusion en temps réel dans Laravel ?

Question

Accepted Answer

La **diffusion** Laravel active les fonctionnalités **temps réel** (notifications en direct, chat, mises à jour en direct) en envoyant les événements côté serveur au navigateur via WebSockets. Cela fonctionne en diffusant les événements Laravel sur une connexion WebSocket, à laquelle les clients JavaScript s'abonnent et réagissent — reliant vos événements backend au frontend en temps réel.

## L'architecture

```text
Server event (e.g. MessageSent) → broadcast over a WebSocket channel →
  client JS (Laravel Echo) listening on that channel receives it → updates the UI live.

WebSocket server options:
  ✓ Laravel Reverb (first-party, self-hosted WebSocket server)
  ✓ Pusher (hosted service)
  ✓ Soketi (open-source, self-hosted)
```

## Diffuser un événement depuis le serveur

```php
<?php
class MessageSent implements ShouldBroadcast {       // mark the event to broadcast
    public function __construct(public Message $message) {}

public function broadcastOn(): Channel {
        return new PrivateChannel('chat.' . $this->message->room_id);   // the channel
    }
}

// dispatch it — it's sent to subscribed clients over WebSockets
MessageSent::dispatch($message);
```

Un événement implémentant `ShouldBroadcast` est poussé sur un canal WebSocket lors de sa distribution. `broadcastOn()` définit sur quel canal — public, **privé** (authentification requise), ou présence (qui est en ligne).

## Écouter sur le client (Laravel Echo)

```js
// Laravel Echo — the JS library that subscribes to channels
Echo.private(`chat.${roomId}`)
    .listen('MessageSent', (e) => {
        addMessageToUI(e.message);     // react in real time when the event arrives
    });

// presence channels — track who's online
Echo.join(`room.${roomId}`)
    .here(users => ...)        // currently present users
    .joining(user => ...).leaving(user => ...);
```

Le client utilise **Laravel Echo** pour s'abonner aux canaux et exécuter du code à l'arrivée d'événements — mettant à jour l'interface utilisateur en direct sans interrogation.

## Types de canaux et autorisation

```text
Public channel   → anyone can listen
Private channel  → requires authorization (defined in channels.php) — for user-specific data
Presence channel → private + tracks who's currently subscribed (online users)
```

## Pourquoi c'est important

La diffusion en temps réel est la façon dont Laravel implémente les **fonctionnalités en direct et interactives** — notifications instantanées, chat, tableaux de bord en direct, mises à jour collaboratives, présence (qui est en ligne) — que le modèle traditionnel requête-réponse ne peut pas fournir (le serveur peut envoyer aux clients, pas seulement répondre aux requêtes).

Comprendre cela est précieux pour construire des applications modernes interactives que les utilisateurs s'attendent de plus en plus à avoir.

L'élégance de l'approche de Laravel est qu'elle **relie vos événements backend existants au frontend en temps réel** : vous marquez un événement comme `ShouldBroadcast`, le distribuez comme d'habitude, et il est poussé via WebSockets aux clients abonnés — donc les fonctionnalités temps réel s'intègrent naturellement à votre code Laravel ordinaire orienté vers les événements.

Sur le client, **Laravel Echo** s'abonne aux canaux et réagit aux événements, mettant à jour l'interface utilisateur en direct sans interrogation inefficace.

Comprendre l'architecture (événements diffusés sur des canaux WebSocket, Echo sur le client), les options de serveur WebSocket (le **Reverb** propriétaire, **Pusher** hébergé, ou Soketi auto-hébergé), et les **types de canaux** (public, privé avec autorisation pour les données spécifiques à l'utilisateur, et présence pour suivre les utilisateurs en ligne) est une connaissance importante au niveau senior pour construire des fonctionnalités temps réel.

Puisque les expériences en direct et interactives sont de plus en plus attendues dans les applications modernes, et puisque Laravel fournit un système élégant qui connecte les événements backend aux mises à jour frontend en temps réel, savoir comment fonctionne la diffusion est précieux pour construire les fonctionnalités réactives et temps réel (chat, notifications, mises à jour en direct, présence) qui distinguent les applications modernes et engageantes — une capacité de plus en plus pertinente dans le développement web contemporain.