WebSocket gateways ఉపయోగించి రియల్-టైమ్ ఫీచర్‌లను ఎలా నిర్మించాలి?

Question

Accepted Answer

NestJS **రియల్-టైమ్, ద్విముఖ సంప్రదాయం** సపోర్ట్ చేస్తుంది **WebSocket gateways** ద్వారా — `@WebSocketGateway()` డెకోరేటర్‌తో సzm్మతిస్తే క్లాస్‌లు WebSocket కనెక్షన్‌లు మరియు సందేశాలను నిర్వహిస్తాయి (సాధారణంగా Socket.IO ద్వారా). అవి చాట్, లైవ్ నోటిఫికేషన్‌లు, మరియు లైవ్ డ్యాష్‌బోర్డ్‌ల వంటి ఫీచర్‌లను ప్రారంభం చేస్తాయి, అదే NestJS స్ట్రక్చర్‌ను ఉపయోగించి (DI, డెకోరేటర్‌లు).

## Gateway నిర్వచించడం

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

Gateway `@SubscribeMessage("event")` ఉపయోగించి ఇన్‌కమింగ్ ఇవెంట్‌లను నిర్వహిస్తుంది (HTTP కోసం `@Post`కు సమానం) మరియు ఇంజెక్ట్ చేయబడిన `server` ఉపయోగించి ఈవెంట్‌లను క్లయింట్‌లకు **విడుదల** చేస్తుంది — `server.emit` అందరికీ ప్రసారం చేస్తుంది.

## కనెక్షన్ జీవిత చక్र హుక్‌లు

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

Gateway‌లు క్లయింట్‌లు కనెక్ట్ చేయడానికి మరియు డిస్‌కనెక్ట్ చేయడానికి ప్రతిస్పందించగలవు — ఉపస్థితి ట్రాకింగ్ మరియు క్లీన‌అప్‌కు ఉపయోగకరమైనది.

## నిర్దిష్ట క్లయింట్‌లు మరియు గదులను లక్ష్యంగా చేయడం

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

**Rooms** క్లయింట్‌లను సమూహపరచండి (ఉదా చాట్ రూమ్, డాక్యుమెంట్ యొక్క సహযోగిత), ప్రతిఒక్కరికీ బదులుగా నిర్దిష్ట ఉపసమితులకు ప్రసారం చేయడానికి నిష్టంలను అనుమతిస్తుంది — స్కోపుడ్ రియల్-టైమ్ ఫీచర్‌ల కోసం అవసరం.

## Gateway‌లు NestJS ఫీచర్‌లను పునర్వినియోగం చేస్తాయి

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

## WebSocket‌లను స్కేలింగ్ చేయడం

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

## ఇది ఎందుకు ముఖ్యమైనది

WebSocket gateway‌లు NestJS **రియల్-టైమ్, ద్విముఖ ఫీచర్‌ల** సపోర్ట్ చేసే విధానం — చాట్, లైవ్ నోటిఫికేషన్‌లు, ఉపస్థితి, సహకార సవరణ, లైవ్ డ్యాష్‌బోర్డ్‌లు, మల్టీప్లేయర్ ఇంటరঅ్యాక్షన్‌లు — REST యొక్క అభ్యర్థన-ప్రతిస్పందన మోడల్ ఇవ్వదగినవి (సర్వర్ క్లయింట్‌లకు పుష్ చేయగలదు, కేవలం అభ్యర్థన‌లకు ప్రతిస్పందించదు).

వాటిని అర్థం చేసుకోవడం ఆధునిక ఇంటరঅ్యాక్టివ్ అనువర్తనాలను నిర్మించడానికి విలువైన సీనియర్ స్థర స్నానం.

ముఖ్య శక్తి ఏమిటంటే gateway‌లు NestJS యొక్క పరిచిత సంरचనకు సరిపోతాయి: అవి **ఆధారపడటం ఇంజెక్షన్** సపోర్ట్ చేసే ప్రోవైడర్‌లు మరియు **గార్డ్‌లు, పైపులు, ఇంటరసెప్టర్‌లు, మరియు ఫిల్టర్‌లు** HTTP నియంత్రకుల వంటి ఉపయోగించవచ్చు, కాబట్టి అదే నమూనాలు మరియు కోడ్ సంస్థ రియల్-టైమ్ నుండి REST కు వర్తిస్తుంది.

ఇవెంట్‌లను నిర్వహించడం (`@SubscribeMessage`), క్లయింట్‌లకు ప్రసారం చేయడం (`server.emit`), **గదులు** ఉపయోగించి సంబంధితమైన ఉపసమితులకు ప్రసారం చేయడం (చాట్ గదులు, డాక్యుమెంట్ సహకారిత), మరియు కనెక్షన్ జీవిత చక్రం నిర్వహించడం (ఉపస్థితి, క్లీన‌అప్) జ్ఞానం ఆచరణీయ రియల్-టైమ్ టూల్‌కిట్‌ను కవర్ చేస్తుంది.

వివరణీయంగా ముఖ్యమైనది **స్కేలింగ్ పరిగణన**: WebSocket కనెక్షన్‌లు స్థితిబద్ధమైనవి మరియు ఒకే సర్వర్ ఇన్‌స్టెన్స్‌కు చేరుకుని ఉన్నాయి, కాబట్టి సమస్తంగా స్కేలింగ్ చేయడానికి **Redis అడాప్టర్** ఉదాహరణలలో ప్రసారం/గదులను సమన్వయం చేయడానికి అవసరం (సాధారణ నష్టం — సెషన్‌ల వంటి, రియల్-టైమ్ స్థితి బహుళ ఉదాహరణలు నడుస్తున్నప్పుడు ఒక ప్రక్రియ యొక్క మెమోరిలో నివాసం చేయలేదు).

ఇది ఆధునిక వినియోగదారులు ఆశించే రియల్-టైమ్, ఇంటరঅ్యాక్టివ్ అభిజ్ఞతలను నిర్మించడానికి ఒక ముఖ్యమైన, క్రమపర్యాయంగా-సంబంధితమైన సామర్థ్యం, మరియు NestJS యొక్క శుద్ధ సమన్వయం దానిని సులభంగా చేస్తుంది జ్ఞాపకం యొక్క నిర్మాణాన్ని పునర్వినియోగం చేస్తూ.