Hoe werkt real-time broadcasting in Laravel?

Question

Accepted Answer

Laravel **broadcasting** maakt **real-time** functies mogelijk (live notificaties, chat, live updates) door server-side events naar de browser te sturen via WebSockets. Het werkt door Laravel events over een WebSocket-verbinding uit te zenden, waarop JavaScript-clients zich abonneren en reageren — waardoor uw backend events real-time naar de frontend worden gebracht.

## De architectuur

```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)
```

## Een event vanaf de server uitzenden

```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);
```

Een event dat `ShouldBroadcast` implementeert, wordt over een WebSocket-kanaal gepusht wanneer het wordt verstuurd. `broadcastOn()` definieert welk kanaal — openbaar, **privé** (vereist authenticatie), of presence (wie is online).

## Luisteren op de 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 => ...);
```

De client gebruikt **Laravel Echo** om zich op kanalen in te schrijven en code uit te voeren wanneer events aankomen — waarbij de UI live wordt bijgewerkt zonder polling.

## Kanaaltypen en autorisatie

```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)
```

## Waarom het belangrijk is

Real-time broadcasting is hoe Laravel **live, interactieve functies** implementeert — instant notificaties, chat, live dashboards, collaboratieve updates, presence (wie is online) — die het traditionele request-response-model niet kan bieden (de server kan naar clients pushen, niet alleen op verzoeken reageren).

De kracht van Laravel's aanpak is dat het **uw bestaande backend events real-time naar de frontend brengt**: u markeert een event als `ShouldBroadcast`, verstuurt het op de normale manier, en het wordt via WebSockets naar geabonneerde clients gepusht — dus real-time functies integreren natuurlijk met uw normale event-driven Laravel-code.

Op de client abonneert **Laravel Echo** zich op kanalen en reageert op events, waarbij de UI live wordt bijgewerkt zonder inefficiënt polling.

Het begrijpen van de architectuur (events uitgezonden over WebSocket-kanalen, Echo op de client), de WebSocket-serveropties (de eigen **Reverb**, gehoste **Pusher**, of zelfgehoste Soketi), en de **kanaaltypen** (openbaar, privé met autorisatie voor gebruikerspecifieke gegevens, en presence voor het volgen van online gebruikers) is belangrijke kennis op senior niveau voor het bouwen van real-time functies.

Aangezien live, interactieve ervaringen steeds meer worden verwacht in moderne toepassingen, en aangezien Laravel een elegante systeem biedt die backend events verbindt met real-time frontend updates, is het weten hoe broadcasting werkt waardevol voor het bouwen van de responsieve, real-time functies (chat, notificaties, live updates, presence) die moderne, aantrekkelijke toepassingen onderscheiden — een steeds relevanter vermogen in hedendaags webontwikkeling.