微服务架构已成为现代、可扩展和弹性应用的核心。在本文中，我们将探讨使微服务大放异彩的强大设计模式，特别是在渐进式 Node.js 框架 NestJS 的上下文中。

? 网关模式（Gateway Pattern）

网关模式充当了所有微服务调用的单一入口点。它将请求路由到适当的服务，处理身份验证和日志记录，甚至可以聚合响应。

import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { GatewayController } from './gateway.controller';

@Module({
  imports: [
    ClientsModule.register([
      { name: 'USER_SERVICE', transport: Transport.TCP },
      { name: 'ORDER_SERVICE', transport: Transport.TCP },
    ]),
  ],
  controllers: [GatewayController],
})
export class GatewayModule {}

import { Controller, Get } from '@nestjs/common'; 
import { ClientProxy, ClientProxyFactory, Transport } from '@nestjs/microservices';

@Controller('gateway') 
export class GatewayController { 
  private userServiceClient: ClientProxy; 
  private orderServiceClient: ClientProxy;

  constructor() { 
    this.userServiceClient = ClientProxyFactory.create({ transport: Transport.TCP, options: { port: 3001 }, }); 
    this.orderServiceClient = ClientProxyFactory.create({ transport: Transport.TCP, options: { port: 3002 }, }); 
  }

  @Get('user') getUser() { 
    return this.userServiceClient.send({ cmd: 'get-user' }, {}); 
  }

  @Get('order') getOrder() { 
    return this.orderServiceClient.send({ cmd: 'get-order' }, {}); 
  } 
}  

2. 服务注册中心模式（Service Registry Pattern）

服务注册中心模式允许微服务在不硬编码其位置的情况下相互发现。在服务可能更改 IP 或端口的动态环境中，这是至关重要的。

import { Injectable, OnModuleInit } from '@nestjs/common';
import { Consul } from 'consul';

@Injectable()
export class ServiceRegistry implements OnModuleInit {
  private consul: Consul;

  constructor() {
    this.consul = new Consul();
  }

  onModuleInit() {
    this.consul.agent.service.register({
      name: 'user-service',
      address: '127.0.0.1',
      port: 3001,
    });
  }
}

?断路器模式（Circuit Breaker Pattern）

断路器模式通过在服务故障或响应缓慢时断开电路并返回回退响应，防止微服务中的级联故障。

@Injectable() 
export class CircuitBreakerService { 
  constructor(private httpService: HttpService) {}

	getUserData() { 
    return this.httpService.get('http://user-service/user') 
      .pipe( catchError(err => { 
      	console.log('Service unavailable, returning fallback data'); 
        return of({ id: 'fallback', name: 'Fallback User' }); 
    	}) ); 
  } 
} 

4. SAGA 模式

SAGA 模式通过将复杂事务分解为更小的步骤来管理跨多个服务的复杂事务。SAGA 中的每个步骤要么成功完成，要么在出现问题时触发补偿事务来撤消先前的步骤。

import { Injectable } from '@nestjs/common';
import { EventPattern } from '@nestjs/microservices';

@Injectable()
export class SagaService {
  @EventPattern('order-created')
  async handleOrderCreated(data: Record<string, unknown>) {
    // Reserve inventory
    // If inventory reservation fails, trigger a compensating transaction
  }

  @EventPattern('payment-processed')
  async handlePaymentProcessed(data: Record<string, unknown>) {
    // Confirm order
    // If payment fails, trigger a compensating transaction to release inventory
  }
}

5. CQRS（命令查询职责分离）

CQRS 将读写操作分离，通过独立优化每种操作类型来提高性能。它在具有复杂查询要求的系统中特别有用。

import { QueryHandler, IQueryHandler } from '@nestjs/cqrs';

export class GetUserQuery {
  constructor(userId: string) {
    this.userId = userId;
  }
}

@QueryHandler(GetUserQuery)
export class GetUserHandler implements IQueryHandler<GetUserQuery> {
  async execute(query: GetUserQuery) {
    // Handle the query, e.g., return user data
    return { id: query.userId, name: 'John Doe' };
  }
} 

6. 舱壁模式（Bulkhead Pattern）

舱壁模式将服务中的组件隔离开来，以防止故障蔓延，确保一个服务出现故障不会导致其他服务崩溃。

import { Injectable } from '@nestjs/common';
import { Queue } from 'bull';

@Injectable()
export class BulkheadService {
  private readonly taskQueue: Queue;

  constructor() {
    this.taskQueue = new Queue('tasks');
  }

  async handleTask(taskData: any) {
    await this.taskQueue.add(taskData);
    // Process task without affecting other components
  }
}

7. 边车模式（Sidecar Pattern）

边车模式（Sidecar Pattern）在不改变核心服务逻辑的情况下为服务添加额外的功能（如监控、日志记录或代理）。

import { Injectable } from '@nestjs/common';
import { createProxyMiddleware } from 'http-proxy-middleware';

@Injectable()
export class SidecarService {
  configure(app) {
    app.use('/user', createProxyMiddleware({
      target: 'http://localhost:3001',
      changeOrigin: true
    }));
  }
} 

8. API 组合模式（API Composition Pattern）

API 组合将多个微服务组合成单个 API 响应，当构建聚合来自不同来源的数据的 API 时，这非常有用。

import { Controller, Get } from '@nestjs/common'; 
import { HttpService } from '@nestjs/common';

@Controller('orders') 
export class OrdersController { 
  constructor(private httpService: HttpService) {}

	@Get() 
  async getOrders() { 
    const user = await this.httpService.get('http://user-service/user').toPromise(); 
    const order = await this.httpService.get('http://order-service/order').toPromise(); 
    return {...user.data,...order.data }; 
  } 
}  

9. ?? 事件驱动架构（Event-Driven Architecture）

在事件驱动架构中，服务会异步响应事件，从而使系统更具响应性和松耦合性。

import { Controller } from '@nestjs/common';
import { EventPattern } from '@nestjs/microservices';

@Controller()
export class EventController {
  @EventPattern('user_created')
  handleUserCreated(data: Record<string, unknown>) {
    console.log('User created event received:', data);
    // React to the event
  }
}

10. 服务数据库（Database per Service）

每个微服务都拥有自己的数据，存储在自己的数据库中，确保数据的隔离和独立性。这种模式允许微服务独立演进。

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(@InjectRepository(User) private userRepository: Repository<User>) {}

  findAll() {
    return this.userRepository.find();
  }
}

重试模式（Retry Pattern）

重试模式通过重试失败的操作来处理瞬时故障，通常采用指数退避策略。

import { Injectable } from '@nestjs/common';
import { HttpService } from '@nestjs/common';
import { catchError, retryWhen, delay, take } from 'rxjs/operators';
import { of } from 'rxjs';

@Injectable()
export class RetryService {
  constructor(httpService: HttpService) {}

  fetchData() {
    return this.httpService.get('http://unreliable-service/data')
     .pipe(
        retryWhen(errors => errors.pipe(delay(1000), take(3))),
        catchError(err => {
          console.log('Failed after retries');
          return of({ fallback: true });
        })
      );
  }
} 

配置外部化（Configuration Externalization）

配置外部化将配置管理集中化，使更改配置而无需重新部署服务变得更加容易。

import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      envFilePath: '.env',
    }),
  ],
})
export class AppModule {}

结论

微服务架构与上述设计模式相结合，可以使应用程序变得灵活、有弹性且可扩展。NestJS 凭借其模块化方法和强大的抽象，是实现这些模式的绝佳框架，可确保您的应用程序能够处理现代分布式系统的复杂性。