java spring 中使用策略模式替换 if-else

背景

最近业务有个接单业务，根据不同的类型，做出不同的处理

/**
 * 订单实体
 * @Author ScarletDrop
 * @Time 2020-12-16 19:41
 */
public class OrderDto {

 /**
  * 流水号
  */
  private String lsh;
 /**
  * 订单id
  */
  private String orderId;
 /**
  * 订单类型
  * 1: 普通订单
  * 2: 团购订单
  * 3: 促销订单
  */
  private String type;

  // ... 省略其他参数
}

/**
 * service 接口
 * @Author ScarletDrop
 * @Time 2020-12-16 19:43
 */
public interface IOrderService {

 /**
  * 根据订单的不同类型作出不同的处理
  *
  * @param dto 订单实体
  * @return boolean
  * @date 2020-12-16 19:23
  **/
  boolean handle(OrderDto dto);
}

传统实现

按以前的思路就是写一堆 if-else if 进行判断

/**
 * service 实现类
 * @Author ScarletDrop
 * @Time 2020-12-16 19:46
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class OrderServiceImpl implements IOrderService {

  @Override
  public boolean handle(OrderDto dto) {
    String type = dto.getType();
    if ("1".equals(type)) {
      // 处理普通订单
      return normalHandle(dto);
    } else if ("2".equals(type)) {
      // 处理团购订单
      return groupHandle(dto);
    } else if ("3".equals(type)) {
      // 处理促销订单
      return promotionHandle(dto);
    }
    // .....
  }
}

虽然上面的确实实现了这个业务需求，但 if-else 嵌套多了之后，看着着实难受，正巧前端时间看了策略模式相关的知识，这里就记录一下由策略模式实现的方式

策略模式实现

利用策略模式，只需要两行即可实现业务逻辑:

/**
 * service 实现类
 * @Author ScarletDrop
 * @Time 2020-12-16 19:46
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class StrategyOrderServiceImpl implements IOrderService {

  @Autowired
  private HandlerContext handlerContext

  @Override
  public boolean handle(OrderDto dto) {
    AbstractHandler handler = handlerContext.getInstance(dto.getType());
    return handler.handler(dto);
  }
}

可以看到上面的方法中注入了 HandlerContext，这是一个处理器上下文，用来保存不同的业务处理器，具体在下文会讲解。我们从中获取一个抽象的处理器 AbstractHandler，调用其方法实现业务逻辑。
现在可以了解到，我们主要的业务逻辑是在处理器中实现的，因此有多少个订单类型，就对应有多少个处理器。以后需求变化，增加了订单类型，只需要添加相应的处理器就可以，上述 StrategyOrderServiceImpl 完全不需改动。

业务处理器

每个处理器都必须添加到 spring 容器中，因此需要加上@Component 注解，
需要加上一个自定义注解@HandlerType，用于标识该处理器对应哪个订单类型，
就是继承 AbstractHandler，实现自己的业务逻辑。

/**
 * 普通订单业务处理器
 * @Author ScarletDrop
 * @Time 2020-12-16 19:57
 */
@Slf4j
@Component
@HandlerType("1")
public class NormalHandle extends AbstractHandler {

  @Override
  public boolean handle(OrderDto dto) {
    // do something
    return true;
  }
}

/**
 * 团购业务处理器
 * @Author ScarletDrop
 * @Time 2020-12-16 19:57
 */
@Slf4j
@Component
@HandlerType("2")
public class GroupHandle extends AbstractHandler {

  @Override
  public boolean handle(OrderDto dto) {
    // do something
    return true;
  }
}
/**
 * 促销订单业务处理器
 * @Author ScarletDrop
 * @Time 2020-12-16 19:57
 */
@Slf4j
@Component
@HandlerType("3")
public class PromotionHandle extends AbstractHandler {

  @Override
  public boolean handle(OrderDto dto) {
    // do something
    return true;
  }
}

自定义注解和抽象处理器并注册到 spring 容器

/**
 * 自定义注解
 * @Author ScarletDrop
 * @Time 2020-12-16 20:04
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface HandlerType {
  String value();
}

/**
 * 抽象处理器
 * @Author ScarletDrop
 * @Time 2020-12-16 20:04
 */
public abstract class AbstractHandler {
   abstract public String handler(OrderDto dto);
}

自定义注解和抽象处理器都很简单，接下来就是将处理器注册到 spring 容器中了？

具体思路是：

扫描指定包中标有@HandlerType 的类；
将注解中的类型值作为 key，对应的类作为 value，保存在 Map 中；
以上面的 map 作为构造函数参数，初始化 HandlerContext，将其注册到 spring 容器中；

我们将核心的功能封装在 HandlerProcessor 类中，完成上面的功能。

/**
 * 抽象处理器
 * @Author ScarletDrop
 * @Time 2020-12-16 20:09
 */
@Component
public class HandlerProcessor implements BeanFactoryPostProcessor {

  private static final String HANDLER_PACKAGE = "com.kanade.mall.order.handler.processor";

  /**
    * 扫描 @HandlerType,初始化SHandlerContext,将其注册到spring容器
    *
    * @param beanFactory bean工厂
    * @return void
    * @author ScarletDrop
    * @time 2020-12-16 20:16
    **/
  @Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    Map<String, Class<?>> handlers = Maps.newHashMap();
    // ClassScanner：扫描工具类源码
    // 我用的是hutool工具类，这里顺带推荐一下这个工具类，这个工具类非常好用，包含了各种开发中可能会用到得工具方法
    ClassScanner.scanPackage(HANDLER_PACKAGE, clazz -> clazz.isAnnotationPresent(HandlerType.class)).forEach(clazz -> {
      // 获取注解中的类型值
      String step = clazz.getAnnotation(HandlerType.class).value();
      // 将注解中的类型值作为key，对应的类作为value，保存在map中
      handlers.put(step, clazz);
    });
    // 初始化HandlerContext，将其注册到spring容器中
    HandlerContext context = new HandlerContext(handlers);
    beanFactory.registerSingleton(HandlerContext.class.getName(), context);
  }
}

HandlerProcessor 需要实现 BeanFactoryPostProcessor，在 spring 处理 bean 前，将自定义的 bean 注册到容器中。

通过 HandlerContext 获取对应的处理器

上面的操作已经完成核心工作，接下来就是使用 HandlerContext 获取对应的处理器：

/**
  * 接单处理上下文
  *
  * @param beanFactory bean工厂
  * @return void
  * @author ScarletDrop
  * @time 2020-12-16 20:16
  **/
@Slf4j
public class HandlerContext {

    private final Map<String, Class<?>> handlerMap;

    public HandlerContext(Map<String, Class<?>> handlerMap) {
        this.handlerMap = handlerMap;
    }

    public AbstractHandler getInstance(String type) throws IllegalAccessException {
        Class<?> clazz = handlerMap.get(type);
        if (clazz == null) {
            throw new IllegalAccessException("没有找到指定的类型：" + type);
        }
        return (AbstractHandler) SpringUtils.getBean(clazz);
    }
}

// SpringUtils：获取 bean 工具类
@Component
public final class SpringUtils implements BeanFactoryPostProcessor {
  /**
    * Spring应用上下文环境
    */
  private static ConfigurableListableBeanFactory beanFactory;
 /**
  * 获取类型为clz的对象
  *
  * @param clz
  * @return
  * @throws BeansException
  */
  public static <T> T getBean(Class<T> clz) throws BeansException {
    T result = (T) beanFactory.getBean(clz);
    return result;
  }
}

getInstance 方法根据类型获取对应的 class，然后根据 class 类型获取注册到 spring 中的 bean。

最后请注意一点，HandlerProcessor 和 SpringUtils 必须能被扫描到，或者通过@Bean 的方式显式的注册，才能在项目启动时发挥作用。

总结

利用策略模式可以简化繁杂的 if else 代码，方便维护，而利用自定义注解和自注册的方式，可以方便应对需求的变更。本文只是提供一个大致的思路，还有很多细节可以灵活变化，例如使用枚举类型、或者静态常量，作为订单的类型，相信你能想到更多更好的方法。

未結束的旋律の blog

java策略模式替换if-else