【一起學習設計模式】策略模式實戰二：配合注解 干掉業務代碼中冗余的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、打印結果：

取消即時訂單

 

到了這里代碼就已經寫完了，如果仔細看的話 應該會明白這里的設計思路，通過策略模式+注解 可以大大的降低業務的耦合度，而且也極大的方便了后期維護的工作量。