Hvordan fungerer realtidsudstråling i Laravel?

Question

Accepted Answer

Laravel **broadcasting** muliggør **realtids**-funktioner (live-notifikationer, chat, live-opdateringer) ved at pushe server-side events til browseren via WebSockets. Det fungerer ved at udsende Laravel-events over en WebSocket-forbindelse, som JavaScript-klienter abonnerer på og reagerer på — hvilket forbinder dine backend-events til frontend i realtid.

## Arkitekturen

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

## Udsendelse af et event fra serveren

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

Et event, der implementerer `ShouldBroadcast`, pushes over en WebSocket-kanal, når det sendes. `broadcastOn()` definerer, hvilken kanal — offentlig, **privat** (autentifikation påkrævet), eller presence (hvem der er online).

## Lytning på klienten (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 => ...);
```

Klienten bruger **Laravel Echo** til at abonnere på kanaler og køre kode, når events ankommer — opdaterer brugerfladen live uden polling.

## Kanaltyper og autentifikation

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

## Hvorfor det betyder noget

Realtidsudstråling er, hvordan Laravel implementerer **live, interaktive funktioner** — øjeblikkelige notifikationer, chat, live-dashboards, samarbejdsopdateringer, presence (hvem der er online) — som den traditionelle request-response-model ikke kan levere (serveren kan pushe til klienter, ikke blot svare på requests).

At forstå det er værdifuldt for at opbygge moderne interaktive applikationer, som brugere i stigende grad forventer.

Det elegante ved Laravels tilgang er, at det **forbinder dine eksisterende backend-events til frontend i realtid**: du markerer et event som `ShouldBroadcast`, sender det som normalt, og det pushes over WebSockets til abonnerede klienter — således integreres realtids-funktioner naturligt med din normale event-drevne Laravel-kode.

På klienten abonnerer **Laravel Echo** på kanaler og reagerer på events, opdaterer brugerfladen live uden ineffektiv polling.

At forstå arkitekturen (events udsendt over WebSocket-kanaler, Echo på klienten), WebSocket-serverindstillingerne (førstepartsløsningen **Reverb**, hostede **Pusher**, eller selvhostet Soketi), og **kanaltyperne** (offentlig, privat med autentifikation for brugerspecifikke data, og presence til sporing af online-brugere) er vigtig senior-level-viden for at opbygge realtids-funktioner.

Da live, interaktive oplevelser i stigende grad forventes i moderne applikationer, og da Laravel leverer et elegant system, der forbinder backend-events med realtids-frontend-opdateringer, er det værdifuldt at vide, hvordan broadcasting fungerer, for at opbygge de responsive, realtids-funktioner (chat, notifikationer, live-opdateringer, presence), som adskiller moderne, engagerende applikationer — en i stigende grad relevant evne i moderne webudvikling.