Hogyan hozol létre valós idejű funkciókat WebSocket átjárókkal?

Question

Accepted Answer

A NestJS támogatja az **valós idejű, kétirányú kommunikációt** **WebSocket átjárók** (gateways) segítségével — olyan osztályok, amelyek a `@WebSocketGateway()` dekorátorral vannak megjelölve, és WebSocket-kapcsolatokat és üzeneteket kezelnek (jellemzően Socket.IO-n keresztül). Lehetővé teszik olyan funkciókat, mint a csevegés, élő értesítések és élő irányítópultok, a NestJS ugyanolyan szerkezetét használva (DI, dekorátorok).

## Átjáró definiálása

```ts
import { WebSocketGateway, SubscribeMessage, MessageBody, WebSocketServer } from "@nestjs/websockets";
import { Server } from "socket.io";

@WebSocketGateway({ cors: true })
export class ChatGateway {
  @WebSocketServer()
  server: Server;                        // the Socket.IO server instance

// handle a 'message' event from a client
  @SubscribeMessage("message")
  handleMessage(@MessageBody() data: { text: string }) {
    // BROADCAST to all connected clients
    this.server.emit("message", data);   // everyone receives the message
  }
}
```

Egy átjáró a `@SubscribeMessage("event")` dekorátort használja a bejövő események kezeléséhez (analóg a `@Post`-tal HTTP-hez) és az injektált `server` objektummal az eseményeket az ügyfeleknek **visszaküldi** — a `server.emit` mindenkinek sugároz.

## Kapcsolat életciklus hookok

```ts
export class ChatGateway implements OnGatewayConnection, OnGatewayDisconnect {
  handleConnection(client: Socket) {
    console.log(`Client connected: ${client.id}`);   // a user joined
  }
  handleDisconnect(client: Socket) {
    console.log(`Client disconnected: ${client.id}`); // a user left — clean up
  }
}
```

Az átjárók reagálhatnak az ügyfelek csatlakozására és leválasztására — hasznos a jelenlét nyomon követéshez és a tisztításhoz.

## Adott ügyfelek és szobák megcélzása

```ts
@SubscribeMessage("joinRoom")
handleJoin(@ConnectedSocket() client: Socket, @MessageBody() room: string) {
  client.join(room);                              // add the client to a room
}

@SubscribeMessage("roomMessage")
sendToRoom(@MessageBody() data: { room: string; text: string }) {
  this.server.to(data.room).emit("message", data.text);   // emit only to that room
  // client.emit(...) → just that client; server.emit(...) → everyone
}
```

A **szobák** csoportosítják az ügyfeleket (pl. egy csevegőszoba, egy dokumentum közreműködői), lehetővé téve, hogy adott részhalmazoknak sugározz, nem pedig mindenkinek — ezek alapvetőek a scoped valós idejű funkciókhoz.

## Átjárók újrahasznosítják a NestJS funkcióit

```text
Gateways are providers → they support dependency injection (inject services),
and can use guards, pipes, interceptors, and filters — just like HTTP controllers.
→ The same structure/patterns apply to real-time as to REST.
```

## WebSockets skálázása

```text
⚠️ WebSocket connections are STATEFUL and live on ONE server instance.
To scale across multiple instances, use a Redis adapter (socket.io-redis) so
broadcasts/rooms work across all instances. (Like sessions, don't keep state in
one process's memory when scaling horizontally.)
```

## Miért számít

A WebSocket átjárók az, ahogy a NestJS támogatja az **valós idejű, kétirányú funkciókat** — csevegés, élő értesítések, jelenlét, együttműködési szerkesztés, élő irányítópultok, multiplayer interakciók — amelyeket a REST kérés-válasz modellje nem tud biztosítani (a szerver pusholhat az ügyfeleknek, nem csak válaszolhat kérésekre).

Az ezek megértése értékes senior szintű tudás a modern interaktív alkalmazások építéséhez.

A legfontosabb erősség az, hogy az átjárók illeszkednek a NestJS ismerős szerkezetéhez: szolgáltatók, amelyek támogatják a **függőség injektálást** és használhatnak **guard-okat, pipe-okat, interceptor-okat és filter-eket** az HTTP kontrollerekhez hasonlóan, ezért ugyanezek a minták és kódszervezés vonatkozik a valós idejűre és a REST-re is.

Az események kezelésének (`@SubscribeMessage`), az ügyfeleknek történő sugárzásnak (`server.emit`), a **szobák** használatának a releváns részhalmazokra történő scoped sugárzáshoz (csevegőszobák, dokumentum közreműködői) és a kapcsolat életciklusának kezeléséhez (jelenlét, tisztítás) szükséges tudása lefedte a gyakorlati valós idejű eszközkészletet.

Kritikusan fontos a **skálázási megfontolás**: a WebSocket-kapcsolatok állapotosak és egyetlen szerver instanciához kötöttek, ezért a vízszintes skálázáshoz szükség van egy **Redis adapterre** a sugárzások és szobák koordinálásához az instanciák között (egy gyakori csapda — az munkamenetek szerint, a valós idejű állapot nem élhet egy folyamat memóriájában, amikor több instanciát futtatnak).

Ez egy fontos, egyre relevánsabb lehetőség a valós idejű, interaktív felhasználói élmények megépítéséhez, amelyet a modern felhasználók elvárnak, és a NestJS tiszta integrációja lehetővé teszi, miközben újrahasznosítja a keretrendszer szerkezetét.