Java策略模式实战

背景介绍

在上篇文章中：项目中的if else 太多了，要怎么重构？Java工厂模式实战 讲到了Java 工厂模式的使用，其中利用了反射来实例化对象，但是在优化的过程中发现，反射的效率实在是不敢恭维。

问题分析与解决方案

工厂模式的核心就是创建对象，而对于我们的业务场景来说，重要的是在不通的行为中如何作出选择，而策略模式正好是一种行为模式，注重的是对行为的封装，解决的是策略的切换与扩展，更简洁的说是定义策略族，分别封装起来，让他们之间可以相互替换，策略模式让策略的变化独立于使用策略的客户。所以我们最后使用策略模式对这个模块进行了优化，下面跟大家分享一下具体实现。

具体实现

对于业务背景这里就不做陈述啦，因为上一篇文章已经介绍的很清楚啦，上面有文章链接，大家可以看一看，有什么写的不好的地方也欢迎大家指出来，大家一起学习、进步。

首先用一个自定义的注解来标记所有这次优化设计到的基本类：

@Documented
@Inherited
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface CarrierTypeHandler {
    CarrierEnum value();
}

CarrierEnum 是我们物流公司的枚举类：

@Getter
public enum CarrierEnum {

  DEFAULT(0, "default", "0", "0"),
  SF_QIAO(1, "sfexpress qiao", "20", "0"),
  ELEME(2, "eleme", "2", "0"),
  SF_SAMECITY(3, "sfsamecity", "2", "0"),
  SAMESTORE(4, "samestore", "2", "0"),
  TMALL_DSS(5, "tmalldss", "2", "0");

  private int key;
  private String name;
  private String leadTimeHour;
  private String supplyPrice;

  private CarrierEnum(){}

  CarrierEnum(int key, String name, String leadTimeHour, String supplyPrice){

    this.key = key;
    this.name = name;
    this.leadTimeHour = leadTimeHour;
    this.supplyPrice = supplyPrice;
  }
  public static List toList(){
    List<CarrierEnum> list = Lists.newArrayList();
    list.addAll(Arrays.asList(CarrierEnum.values()));
    return list;
  }

  public static List nameList(){
    List<String> list = Lists.newArrayList();
    for (CarrierEnum carrierEnum :CarrierEnum.values()){
      list.add(carrierEnum.name);
    }
    return list;
  }

  public static CarrierEnum getCarrierEnum(String name){
    CarrierEnum carrierEnum = null;
    for (CarrierEnum carrierNameEnum:CarrierEnum.values()){
      if (carrierNameEnum.getName().equals(name)){
        carrierEnum = carrierNameEnum;
      }
    }
    return carrierEnum;
  }
}

定义一个接口 ICarrierService ：

public interface ICarrierService<T> {
    ApiResponseDto createOrder(BasicCarrierRequestDto basicCarrierRequestDto) throws Exception;

}

下面是两个实现类：

SFExpressServiceImpl :

@Service
@Slf4j
@CarrierTypeHandler(CarrierEnum.SF_QIAO)
public class SFExpressServiceImpl implements ISFExpressService<String> {
@Override
public ApiResponseDto createOrder(BasicCarrierRequestDto basicCarrierRequestDto) throws Exception {
   log.debug("[{}] - Hello I am [{}], I am doing [{}]", this.getClass(), basicCarrierRequestDto.getCarrierName(), basicCarrierRequestDto.getActionName());
   return ApiResponseDto.success();
    }
}

 SFSamecityServiceImpl :

@Service
@Slf4j
@CarrierTypeHandler(CarrierEnum.SF_SAMECITY)
public class SFSamecityServiceImpl implements ISFSamecityService<String> {

@Override
public ApiResponseDto createOrder(BasicCarrierRequestDto basicCarrierRequestDto) throws Exception {
    log.debug("[ {} ] - Hello I am [ {} ], I am doing [ {} ]", this.getClass(), basicCarrierRequestDto.getCarrierName(), basicCarrierRequestDto.getActionName());
    return ApiResponseDto.success();
    }
}

那么重点来了，我们怎么根据不同的物流公司进行不同的 createOrder 操作呢？所以通过上面定义的注解，我们将不同service和Carrier做了一个mapping操作，那么接下来我们只需要在使用的时候拿到这个mapping关系就可以啦。这个场景很向我们Java中的一种数据结构：Map，它们都是 k-v 形式的，所以我们可以使用一个map来存储它们之间的对应关系。

但是什么时候存呢？ 当然是在程序加载的时候就存好，当我们用的时候直接拿最好了，所以我们定义了一个CarrierServiceContext对象来存储这个map，使用ApplicationListener做存储动作的发起者具体实现如下：

CarrierServiceContext ：

@Component
public class CarrierServiceContext<T> {
    private final Map<String, T> handlerMap = new HashMap<>();

    public T getCarrierSevice(String name) {
        return handlerMap.get(name);
    }

    public void putCarrierService(String name, T businessService) {
        handlerMap.put(name, businessService);
    }
}

CarrierServiceListener ： 在spring启动过程中，获取所有加了CarrierTypeHandler 注解的类beans，并获CarrierServiceContext，通过 CarrierServiceContext 的 put 方法，将注解中 value 的值与 实现类 保存在 handlerMap 中。

@Component
public class CarrierServiceListener<T> implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        Map<String, Object> beans = contextRefreshedEvent.getApplicationContext().getBeansWithAnnotation(CarrierTypeHandler.class);

        CarrierServiceContext<T> carrierServiceContext = contextRefreshedEvent.getApplicationContext().getBean(CarrierServiceContext.class);

        beans.forEach((name, bean) -> {
            CarrierTypeHandler typeHandler = bean.getClass().getAnnotation(CarrierTypeHandler.class);
            carrierServiceContext.putCarrierService(typeHandler.value().getName(), (T) bean);
        });

    }
}

然后就是万事俱备只欠东风了，只要在controller中调用 CarrierServiceContext 中的 getCarrierService就好啦：

@Api(tags = "Carrier Module", description = "Carrier Module APIs to connect various carrier vendors for fast delivery")
@RestController
@Slf4j
public class CarrierController {

    @Autowired
    private CarrierServiceContext<ICarrierService<BasicCarrierRequestDto>> carrierServiceContext;

    @ApiOperation(value = "Create order to various carrier vendors.")
    @ApiResponses(value = {
            @ApiResponse(code = 200, message = "Create order in carrier successfully"),
            @ApiResponse(code = 401, message = "You are not authorized to access to this API"),
            @ApiResponse(code = 403, message = "Accessing the resource you were trying to reach is forbidden"),
            @ApiResponse(code = 404, message = "The resource you were trying to reach is not found")
    })
    @PostMapping(value = "/orders", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ResponseBody
    public ResponseEntity<ApiResponseDto> createOrder(
            @RequestBody BasicCarrierRequestDto basicCarrierRequestDto) throws Exception {

        log.info("Input is {}", basicCarrierRequestDto);

        ICarrierService<BasicCarrierRequestDto> carrierService = carrierServiceContext.getCarrierSevice(basicCarrierRequestDto.getCarrierName());

        ApiResponseDto apiResponseDto = carrierService.createOrder(basicCarrierRequestDto);

        return ResponseEntity.ok(apiResponseDto);
    }
}