NestJS自定义传输微服务的控制器疑问：能否混用TCP与自定义传输？

Hey Diego, great question! Let's break this down step by step since working with custom transports in NestJS microservices can feel a bit tricky at first, especially when you want to mix multiple transport layers like TCP and a WebSocket-style custom transport.

1. Using Controllers with a Custom Transport #

First, let's cover how to set up controllers when using a custom transport. The core idea aligns with standard transports, but you'll need to tie your controller methods to your custom transport's message handling logic:

Example: Custom WebSocket Transport Controller #

Suppose you've built a custom WebSocket transport (extending Server from @nestjs/microservices). Here's how your controller would interact with it:

import { Controller } from '@nestjs/common';
import { MessagePattern, Payload } from '@nestjs/microservices';

@Controller()
export class CustomWsController {
  // Handle request-response messages over your WebSocket transport
  @MessagePattern('ws:get-user') // Use a pattern your custom transport recognizes
  getUser(@Payload() userId: string) {
    return { id: userId, name: 'John Doe', email: 'john@example.com' };
  }

  // Handle fire-and-forget events over the WebSocket transport
  @EventPattern('ws:user-updated')
  logUserUpdate(@Payload() userData: any) {
    console.log('User updated via WebSocket:', userData);
  }
}

Then, bootstrap your microservice with the custom transport strategy:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { CustomWsServer } from './custom-ws.server'; // Your custom transport implementation

async function bootstrap() {
  const app = await NestFactory.createMicroservice(AppModule, {
    strategy: new CustomWsServer({ port: 8080 }), // Configure your custom server
  });

  await app.listen();
  console.log('Custom WebSocket microservice running');
}
bootstrap();

The critical part here is ensuring your custom transport server correctly routes incoming messages to controller methods decorated with matching @MessagePattern or @EventPattern values.

2. Mixing TCP and Custom Transports in the Same Module #

Absolutely! NestJS supports running multiple microservice instances (with different transports) from a single module, and controllers can handle messages from all of them. Here's how to set this up:

Step 1: Bootstrap Multiple Microservices #

In your main.ts, use app.connectMicroservice() for each transport layer, then start all instances together:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { Transport } from '@nestjs/microservices';
import { CustomWsServer } from './custom-ws.server';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Connect TCP microservice
  app.connectMicroservice({
    transport: Transport.TCP,
    options: { port: 3000 },
  });

  // Connect custom WebSocket microservice
  app.connectMicroservice({
    strategy: new CustomWsServer({ port: 8080 }),
  });

  // Start all microservices (plus an optional HTTP server if needed)
  await app.startAllMicroservices();
  await app.listen(3001);
  console.log('TCP and custom WebSocket microservices running');
}
bootstrap();

Step 2: Route Controller Methods to Specific Transports #

To ensure a controller method handles messages from only one transport, add the transport property to your decorator. For example:

import { Controller } from '@nestjs/common';
import { MessagePattern, Payload, Transport } from '@nestjs/microservices';

@Controller()
export class MixedTransportController {
  // Handle TCP-specific requests
  @MessagePattern({ cmd: 'tcp:get-user', transport: Transport.TCP })
  getUserFromTcp(@Payload() userId: string) {
    return { id: userId, source: 'TCP', name: 'John Doe' };
  }

  // Handle custom WebSocket-specific requests
  @MessagePattern({ cmd: 'ws:get-user', transport: 'custom-ws' }) // Use your custom transport's ID
  getUserFromWs(@Payload() userId: string) {
    return { id: userId, source: 'Custom WebSocket', name: 'John Doe' };
  }

  // Handle TCP events
  @EventPattern({ name: 'tcp:user-updated', transport: Transport.TCP })
  handleTcpUserUpdate(@Payload() data: any) {
    console.log('TCP user update:', data);
  }

  // Handle WebSocket events
  @EventPattern({ name: 'ws:user-updated', transport: 'custom-ws' })
  handleWsUserUpdate(@Payload() data: any) {
    console.log('WebSocket user update:', data);
  }
}

Note: For custom transports, define a unique identifier (like 'custom-ws') in your transport strategy's transportId property so NestJS can route messages correctly.

Key Tips #

• Your custom transport must implement core methods from the Server abstract class (e.g., listen(), close(), message routing) to integrate smoothly with NestJS controllers.
• If you omit the transport property in decorators, the method will handle matching messages from all connected microservices—use this intentionally or avoid it to prevent cross-transport conflicts.
• For cleaner code, you can split controllers into separate classes for each transport, but it’s not required.

内容的提问来源于stack exchange，提问作者Diego Fernando Murillo Valenci