使用策略模式来解决代码中差分过多的问题

假设存在以下需求:
如果请求对象是猫 我的hello服务需要响应喵喵 如果是狗狗我需要响应汪汪。此时我有两种方案解决这个问题
方案一:在个controller中写

if (animalType === 'cat') {
    return "喵喵" 
} else if (animalType === 'dog') {
    return "汪汪"
}

这样的问题是如果动物增多 if/else会越来越多,另一个问题是 eat里面仍然需要区分猫猫和狗狗。

第二个方案是实现一个抽象类定义动物的基本行为,然后定义cat.service,以及dog.service,例如hello eat run。然后定义一个路由守卫,在路由守卫中根据请求对象决定使用哪个service。具体示例如下:

// Step 1: 基类 `BaseAnimalService` 包含所有动物共享的通用行为
class BaseAnimalService {
  // 共同行为
  friendly(): boolean {
    return true;
  }
}

// Step 2: 抽象类 `AnimalService` 仅声明所有动物必须实现的通用方法
abstract class AnimalService extends BaseAnimalService {
  abstract hello(): string;
  abstract eat(): string;
  abstract run(): string;
}

// Step 3: 具体子类 `CatService` 实现特有和通用的行为
class CatService extends AnimalService {
  hello(): string {
    return '喵喵';
  }

  eat(): string {
    return '猫在吃鱼';
  }

  run(): string {
    return '猫在跑';
  }

  // 只有猫可以做的事情
  climbTree(): string {
    return '猫在爬树';
  }
}

// Step 4: 具体子类 `DogService` 实现特有和通用的行为
class DogService extends AnimalService {
  hello(): string {
    return '汪汪';
  }

  eat(): string {
    return '狗在吃骨头';
  }

  run(): string {
    return '狗在跑';
  }

  // 狗没有 `climbTree` 方法
}

// Step 5: 在控制器中使用路由守卫或中间件选择具体的实现
@Controller('animals')
class AnimalController {
  constructor(private animalService: AnimalService) {}

  @Get('hello')
  sayHello(): string {
    return this.animalService.hello();
  }

  @Get('friendly')
  checkFriendly(): boolean {
    return this.animalService.friendly(); // 通用行为
  }

  @Get('climb-tree')
  climbTree(): string {
    if (this.animalService instanceof CatService) {
      // 只有当 animalService 是 CatService 时,才调用 climbTree
      return (this.animalService as CatService).climbTree();
    }
    throw new Error('This animal cannot climb trees!');
  }
}

// Step 6: 在守卫或中间件中选择具体的服务实现
@Injectable()
class AnimalGuard implements CanActivate {
  constructor(
    private catService: CatService,
    private dogService: DogService,
  ) {}

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const animalType = request.body.animalType;

    // 根据 animalType 决定使用哪个服务
    if (animalType === 'cat') {
      request.animalService = this.catService;
    } else if (animalType === 'dog') {
      request.animalService = this.dogService;
    } else {
      return false; // 如果动物类型不支持,拒绝请求
    }

    return true;
  }
}

这样的优点:

  • 可扩展性: 新增一种动物时,只需添加新的服务类(继承自 AnimalService),无需修改现有代码的逻辑。
  • 代码清晰: 避免了大量的 if-else 语句,代码结构清晰,易于维护。
  • 单一职责原则: 每个类只负责一种特定动物的行为实现,符合面向对象设计原则。
  • 依赖注入和解耦: 使用 NestJS 的依赖注入功能,使代码更松散耦合,更易于测试和维护。

以上是策略模式的一个很好的应用示例。策略模式的核心思想是将行为的定义和行为的使用解耦,通过这种设计,能够更容易地扩展系统,添加新功能,同时保持代码的清晰和可维护性。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值