【一起学习设计模式】策略模式实战二：配合注解 干掉业务代码中冗余的if else......

前言：

之前写过一个工作中常见升级模式-策略模式 的文章，里面讲了具体是怎样使用策略模式去抽象现实中的业务代码，今天来拿出实际代码来写个demo，这里做个整理来加深自己对策略模式的理解。

一、业务流程

取消订单会有多种情况，比如：取消即时订单、取消预约订单、取消拼车订单

一般业务代码中我们会根据取消类型来进行不同的逻辑处理，代码中无外乎多了很多if else的业务逻辑，且代码耦合度很高。

那么有没有一种优雅的处理方式呢？ 当然有了，现在就来说下我们系统中是如何处理这种问题的（ 具体业务需求可以参考我上一篇文章： https://www.cnblogs.com/wang-meng/p/11457544.html）

二、流程图

上面已经说了业务流程，当然有流程图才是最直观的，这里我们可以直接参见下图：

这里我们可以使用Spring 获取到所有 AbstractOrderStrategy 实现类中@OrderTypeAnnotation注解的类，然后比较orderType即可。下面就看具体代码吧；

三、代码实现及解析

1、自定义订单类型枚举：OrderTypeAnnotation

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface OrderTypeAnnotation {
    OrderTypeEnum orderType();
}

这里 ElementType.TYPE表示用于类上，RetentionPolicy.RUNTIME 表示运行时解析的。更多的含义大家可以看注解的相关知识。

2、构建OrderType枚举：OrderTypeEnum

public enum OrderTypeEnum {
    INSTANT(1, "即时订单"),
    BOOKING(2, "预约订单"),
    CARPOOL(3, "拼车订单");
 
 
    private int code;
    private String desc;
 
 
    OrderTypeEnum(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }
 
 
    public int getCode() {
        return code;
    }
 
 
    public String getDesc() {
        return desc;
    }
 
 
    public static OrderTypeEnum getByCode(int code) {
        for (OrderTypeEnum orderTypeEnum : values()) {
            if (orderTypeEnum.getCode() == code) {
                return orderTypeEnum;
            }
        }
        return null;
    }
}

 

这里会显示该取消订单的类型，如过往代码中所有if 中的条件判断，这里用枚举进行归纳。

3、构建抽象策略及策略实现类

 

策略抽象类：AbstractOrderStrategy

public abstract class AbstractOrderStrategy {
 
    /**
     * 策略抽象方法
     * @param orderDTO
     */
    abstract public void process(OrderDTO orderDTO);
}

为了容易理解，这里只有一个业务实现类，继承该抽象类的策略类都会实现具体的业务。

预约单处理策略类：BookingOrderStrategy

@Service
@OrderTypeAnnotation(orderType = OrderTypeEnum.BOOKING)
public class BookingOrderStrategy extends AbstractOrderStrategy {

    @Override
    public void process(OrderDTO orderDTO) {
        System.out.println("取消预约订单");
    }
}

这里重点关注orderType，代码区分具体的执行策略 都是通过这个type去进行处理的。

即时单处理策略类：InstantOrderStrategy

@Service
@OrderTypeAnnotation(orderType = OrderTypeEnum.INSTANT)
public class InstantOrderStrategy extends AbstractOrderStrategy {
 
    @Override
    public void process(OrderDTO orderDTO) {
        System.out.println("取消即时订单");
    }
}

4、策略分发处理类

这个类主要是接收业务请求，然后转发到具体的策略类进行处理，这里使用到了spring 获取具体的类，然后通过类上面的注解信息进行转发。

@Service
@Slf4j
public class CancelOrderStrategyService {
    /**
     * 处理取消逻辑
     */
    public void process(OrderDTO orderDTO) {
        Map<String, AbstractOrderStrategy> beanMap = SpringBeanUtils.getBeanMap(AbstractOrderStrategy.class);
        try {
            for (Map.Entry<String, AbstractOrderStrategy> entry : beanMap.entrySet()) {
                Object real = SpringBeanUtils.getTarget(entry.getValue());
                OrderTypeAnnotation annotation = real.getClass().getAnnotation(OrderTypeAnnotation.class);
                if (orderDTO.getServiceType() == annotation.orderType().getCode()) {
                    entry.getValue().process(orderDTO);
                    break;
                }
            }
        } catch (Exception e) {
            log.error("获取目标代理对象失败:{}", e);
        }
    }
}

 

其中：

Map<String, AbstractOrderStrategy> beanMap = SpringBeanUtils.getBeanMap(AbstractOrderStrategy.class);

代表获取AbstractOrderStrategy 下全部子类或接口。

Object real = SpringBeanUtils.getTarget(entry.getValue());

代表获取具体的代理类

OrderTypeAnnotation annotation = real.getClass().getAnnotation(OrderTypeAnnotation.class);

代表取类上有OrderTypeAnnotation 的注解信息。

CancelOrderStrategyService.process() 这个方法是可以扩展的，通过外部传入的class信息来获取具体的代理类。

5、Spring获取bean工具类

@Component
public class SpringBeanUtils implements ApplicationContextAware {
    private static ApplicationContext applicationContext;
 
    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        if (applicationContext == null) {
            applicationContext = context;
        }
    }
 
    public static Object getBean(String name) {
        return applicationContext.getBean(name);
    }
 
    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }
 
    /**
     * 获取类型为requiredType的Map
     *
     * @param clazz
     * @return
     */
    public static <T> Map<String, T> getBeanMap(Class<T> clazz) {
        return applicationContext.getBeansOfType(clazz);
    }
 
    /**
     * 获取 目标对象
     *
     * @param proxy 代理对象
     * @return 目标对象
     * @throws Exception
     */
    public static Object getTarget(Object proxy) throws Exception {
        if (!AopUtils.isAopProxy(proxy)) {
            // 不是代理对象,直接返回
            return proxy;
        }
 
        if (AopUtils.isJdkDynamicProxy(proxy)) {
            return getJdkDynamicProxyTargetObject(proxy);
        } else {
            // cglib
            return getCglibProxyTargetObject(proxy);
        }
    }
 
    private static Object getJdkDynamicProxyTargetObject(Object proxy) throws Exception {
        Field field = proxy.getClass().getSuperclass().getDeclaredField("h");
        field.setAccessible(true);
        AopProxy aopProxy = (AopProxy) field.get(proxy);
        Field advised = aopProxy.getClass().getDeclaredField("advised");
        advised.setAccessible(true);
 
        Object target = ((AdvisedSupport) advised.get(aopProxy)).getTargetSource().getTarget();
        return target;
    }
 
    private static Object getCglibProxyTargetObject(Object proxy) throws Exception {
        Field field = proxy.getClass().getDeclaredField("CGLIB$CALLBACK_0");
        field.setAccessible(true);
        Object dynamicAdvisedInterceptor = field.get(proxy);
 
        Field advised = dynamicAdvisedInterceptor.getClass().getDeclaredField("advised");
        advised.setAccessible(true);
 
        Object target = ((AdvisedSupport) advised.get(dynamicAdvisedInterceptor)).getTargetSource().getTarget();
        return target;
    }
}

 

6、添加单元测试

public class CancelAbstractOrderStrategyTest extends BaseTest {
@Autowired
private CancelOrderStrategyService cancelOrderStrategyService;
@Test
public void process() {
OrderDTO orderDTO = new OrderDTO();
orderDTO.setServiceType(OrderTypeEnum.INSTANT.getCode());
cancelOrderStrategyService.process(orderDTO);
}
}

7、打印结果：

取消即时订单

到了这里代码就已经写完了，如果仔细看的话 应该会明白这里的设计思路，通过策略模式+注解 可以大大的降低业务的耦合度，而且也极大的方便了后期维护的工作量。