Como funciona a transmissão em tempo real no Laravel?

Question

Accepted Answer

O **broadcasting** do Laravel permite **features em tempo real** (notificações ao vivo, chat, atualizações ao vivo) ao enviar eventos do lado do servidor para o navegador sobre WebSockets. Funciona transmitindo eventos Laravel sobre uma conexão WebSocket, que clientes JavaScript se inscrevem e reagem — conectando seus eventos de backend ao frontend em tempo real.

## A arquitetura

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

## Transmitindo um evento do servidor

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

Um evento implementando `ShouldBroadcast` é enviado sobre um canal WebSocket quando despachado. `broadcastOn()` define qual canal — público, **privado** (requer autenticação), ou presença (quem está online).

## Escutando no cliente (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 => ...);
```

O cliente usa **Laravel Echo** para se inscrever em canais e executar código quando eventos chegam — atualizando a interface ao vivo sem polling.

## Tipos de canal e autenticação

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

## Por que isso importa

O broadcasting em tempo real é como o Laravel implementa **features ao vivo e interativas** — notificações instantâneas, chat, dashboards ao vivo, atualizações colaborativas, presença (quem está online) — que o modelo tradicional de requisição-resposta não consegue fornecer (o servidor pode enviar para clientes, não apenas responder a requisições).

Compreender isso é valioso para construir aplicações interativas modernas que os usuários cada vez mais esperam.

A elegância da abordagem do Laravel é que ela **conecta seus eventos de backend existentes ao frontend em tempo real**: você marca um evento como `ShouldBroadcast`, o despacha normalmente, e é enviado sobre WebSockets para clientes inscritos — então features em tempo real se integram naturalmente com seu código Laravel orientado a eventos normal.

No cliente, **Laravel Echo** se inscreve em canais e reage a eventos, atualizando a interface ao vivo sem polling ineficiente.

Compreender a arquitetura (eventos transmitidos sobre canais WebSocket, Echo no cliente), as opções de servidor WebSocket (o **Reverb** de primeira parte, **Pusher** hospedado, ou Soketi auto-hospedado), e os **tipos de canal** (público, privado com autorização para dados específicos do usuário, e presença para rastrear usuários online) é conhecimento importante de nível sênior para construir features em tempo real.

Como experiências ao vivo e interativas são cada vez mais esperadas em aplicações modernas, e como o Laravel fornece um sistema elegante que conecta eventos de backend a atualizações frontend em tempo real, saber como broadcasting funciona é valioso para construir as features responsivas e em tempo real (chat, notificações, atualizações ao vivo, presença) que distinguem aplicações modernas e envolventes — uma capacidade cada vez mais relevante no desenvolvimento web contemporâneo.