java spring 中使用策略模式替换 if-else
文章转载自:在 Spring Boot 中,如何干掉 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 代码,方便维护,而利用自定义注解和自注册的方式,可以方便应对需求的变更。本文只是提供一个大致的思路,还有很多细节可以灵活变化,例如使用枚举类型、或者静态常量,作为订单的类型,相信你能想到更多更好的方法。