Kuinka rakennat reaaliaikaisia ominaisuuksia WebSocket-yhdyskäytävien avulla?

Question

Accepted Answer

NestJS tukee **reaaliaikaista, kaksisuuntaista viestintää** **WebSocket-yhdyskäytävien** kautta — luokkia, joita on koristeltu `@WebSocketGateway()`-dekoraattorilla ja jotka käsittelevät WebSocket-yhteyksiä ja viestejä (tyypillisesti Socket.IO:n välityksellä). Ne mahdollistavat ominaisuuksia kuten chat, live-ilmoitukset ja live-kojelauta käyttämällä samaa NestJS-rakennetta (riippuvuuksien injektointi, dekoraattorit).

## Yhdyskäytävän määrittäminen

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

Yhdyskäytävä käyttää `@SubscribeMessage("event")` saapuvien tapahtumien käsittelyyn (analoginen `@Post`:lle HTTP:lle) ja injektoitua `server`-objektia tapahtumien **lähettämiseen** takaisin asiakkaille — `server.emit` lähettää kaikille.

## Yhteyden elinkaaren koukut

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

Yhdyskäytävät voivat reagoida asiakkaiden yhteyden muodostamiseen ja katkeamiseen — hyödyllinen läsnäolon seurantaa ja siivoustöitä varten.

## Spesifisten asiakkaiden ja huoneiden kohdentaminen

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

**Huoneet** ryhmittelevät asiakkaita (esim. chat-huone, dokumentin yhteistyökumppanit), jolloin voit lähettää spesifisille osajoukoille kaikille — välttämätöntä rajatuille reaaliaikaisille ominaisuuksille.

## Yhdyskäytävät käyttävät NestJS-ominaisuuksia uudelleen

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

## WebSocketien skaalaaminen

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

## Miksi se on tärkeää

WebSocket-yhdyskäytävät ovat tapa, jolla NestJS tukee **reaaliaikaisia, kaksisuuntaisia ominaisuuksia** — chat, live-ilmoitukset, läsnäolo, yhteistyön muokkaus, live-kojelauta, moninpeli-vuorovaikutus — joita REST:n request-response-malli ei voi tarjota (palvelin voi työntää asiakkaille, ei vain vastata pyyntöihin).

Niiden ymmärtäminen on arvokasta senior-tason osaamista moderneille interaktiivisille sovelluksille.

Päävoima on, että yhdyskäytävät sopivat NestJS:n tuttuun rakenteeseen: ne ovat palveluntarjoajia, jotka tukevat **riippuvuuksien injektointia** ja voivat käyttää **vartijia, putkia, väliintuloja ja suodattimia** aivan kuten HTTP-ohjaimet, joten samat kuviot ja koodin organisaatio pätevät reaaliaaikaan kuin REST:iin.

Tapahtumien käsittely (`@SubscribeMessage`), asiakkaille lähettäminen (`server.emit`), **huoneiden** käyttäminen yleislevitysten rajaamiseen relevantteille osajoukoille (chat-huoneet, dokumentin yhteistyökumppanit) ja yhteyden elinkaaren hallinta (läsnäolo, siivous) kattaa käytännöllisen reaaliaikaisen työkalupaketin.

Kritiikin kannalta tärkeä on **skaalaushuomio**: WebSocket-yhteydet ovat tilallisia ja sidottu yhteen palvelinesiintymään, joten vaakasuora skaalaaminen vaatii **Redis-sovittinta** yleislevitysten ja huoneiden koordinoimiseksi instanssien välillä (yleinen sudenkuoppa — kuten istunnot, reaaliaikainen tila ei voi elää yhden prosessin muistissa useiden instanssien käynnissä ollessa).

Tämä on tärkeä ja yhä relevantimpi kyky rakentaa reaaliaikaisia, interaktiivisia kokemuksia, joita modernit käyttäjät odottavat, ja NestJS:n puhdas integraatio tekee siitä saavutettavaa samalla kun se uudelleenkäyttää kehyksen rakennetta.