NestJS部署AWS Lambda后，如何拆分SQS批量请求到对应controller？

针对你在Lambda中处理SQS批量请求的场景，这里提供三种可行的解决方案，覆盖不同需求场景：

1. 直接调用Service层方法（最优方案） #

NestJS的Controller本质是HTTP路由的入口，核心业务逻辑应该抽离在Service层。直接调用Service方法可以完全绕开HTTP层，性能最高，也是最符合Nest架构设计的方式。

实现步骤： #

• 先将Controller中的业务逻辑迁移到对应Service：

// users.service.ts
import { Injectable } from '@nestjs/common';
import { CreateUserDto } from './dto/create-user.dto';

@Injectable()
export class UsersService {
  async createUser(dto: CreateUserDto) {
    // 这里是实际的业务逻辑，比如写入数据库、调用第三方服务等
    return { id: Date.now().toString(), ...dto };
  }
}

• 让Controller依赖Service，仅做路由转发：

// users.controller.ts
import { Controller, Post, Body } from '@nestjs/common';
import { UsersService } from './users.service';
import { CreateUserDto } from './dto/create-user.dto';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  create(@Body() createUserDto: CreateUserDto) {
    return this.usersService.createUser(createUserDto);
  }
}

• 在Lambda Handler中初始化Nest上下文，循环处理每个批量请求：

// lambda.handler.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { Handler } from 'aws-lambda';

// 冷启动时初始化一次Nest上下文
let appContext: any;

export const handler: Handler = async (event) => {
  if (!appContext) {
    appContext = await NestFactory.createApplicationContext(AppModule);
    await appContext.init();
  }

  // 解析SQS批量请求（根据你的实际event结构调整）
  const batchRequests = event.Records.map(record => JSON.parse(record.body));

  // 并行处理所有请求
  const results = await Promise.all(
    batchRequests.map(async (req) => {
      try {
        // 根据请求的endpoint匹配对应的Service和方法
        switch (req.endpoint) {
          case '/users':
            const usersService = appContext.get(UsersService);
            return await usersService.createUser(req.body);
          case '/orders':
            const ordersService = appContext.get(OrdersService);
            return await ordersService.createOrder(req.body, req.headers);
          // 扩展其他endpoint的处理逻辑
          default:
            return { code: 404, message: '未知的Endpoint' };
        }
      } catch (err) {
        return { code: 500, message: err.message };
      }
    })
  );

  return {
    statusCode: 200,
    body: JSON.stringify(results),
  };
};

2. 模拟HTTP请求复用Controller逻辑 #

如果不想重构现有代码，需要复用Controller的完整逻辑（包括管道、守卫、拦截器等），可以通过Nest的HTTP适配器模拟HTTP请求，让每个批量请求走正常的Controller路由流程。

实现示例： #

// lambda.handler.ts
import { NestFactory } from '@nestjs/core';
import { ExpressAdapter } from '@nestjs/platform-express';
import { AppModule } from './app.module';
import { Handler } from 'aws-lambda';
import * as express from 'express';

let expressApp: express.Express;
let nestApp: any;

export const handler: Handler = async (event) => {
  if (!nestApp) {
    expressApp = express();
    const adapter = new ExpressAdapter(expressApp);
    nestApp = await NestFactory.create(AppModule, adapter);
    await nestApp.init();
  }

  const batchRequests = event.Records.map(record => JSON.parse(record.body));
  const results = await Promise.all(
    batchRequests.map(async (req) => {
      try {
        // 模拟Express请求对象
        const mockReq = {
          method: req.method || 'POST',
          url: req.endpoint,
          headers: req.headers,
          body: req.body,
        } as express.Request;

        // 模拟Express响应对象，捕获返回结果
        const mockRes = {
          json: jest.fn().mockReturnThis(),
          send: jest.fn().mockReturnThis(),
          status: jest.fn().mockReturnThis(),
        } as unknown as express.Response;

        // 让Express处理模拟请求
        await new Promise<void>((resolve) => {
          expressApp(mockReq, mockRes, resolve);
        });

        // 提取响应结果
        return mockRes.json.mock.calls[0]?.[0] || mockRes.send.mock.calls[0]?.[0] || { status: 'success' };
      } catch (err) {
        return { code: 500, message: err.message };
      }
    })
  );

  return {
    statusCode: 200,
    body: JSON.stringify(results),
  };
};

3. 自定义批量请求中间件 #

如果希望在Nest的请求生命周期内处理批量请求，可以在入口处添加中间件，识别批量请求后拆分处理，再合并结果返回。

实现步骤： #

• 创建批量处理中间件：

// batch.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { UsersService } from './users/users.service';

@Injectable()
export class BatchMiddleware implements NestMiddleware {
  private appContext: any;

  async use(req: Request, res: Response, next: NextFunction) {
    // 判断是否为批量请求（根据你的请求格式调整）
    if (req.body?.batchRequests && Array.isArray(req.body.batchRequests)) {
      if (!this.appContext) {
        this.appContext = await NestFactory.createApplicationContext(AppModule);
        await this.appContext.init();
      }

      const usersService = this.appContext.get(UsersService);
      const results = await Promise.all(
        req.body.batchRequests.map(async (batchReq) => {
          // 这里可以用Service调用或模拟请求的方式处理单个请求
          return usersService.createUser(batchReq.body);
        })
      );

      res.json(results);
    } else {
      // 非批量请求，走正常路由流程
      next();
    }
  }
}

• 在AppModule中注册中间件：

// app.module.ts
import { Module, MiddlewareConsumer } from '@nestjs/common';
import { BatchMiddleware } from './batch.middleware';
import { UsersModule } from './users/users.module';

@Module({
  imports: [UsersModule],
})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(BatchMiddleware).forRoutes('*');
  }
}

内容的提问来源于stack exchange，提问作者TooHasty