23种设计模式之行为型模式——策略模式实现方式案例

传统的通过 if…else 判断来实现多个功能的使用，但这带来的复杂和难以维护，通过使用策略模式实现了易于扩展和代码维护。

if…else实现功能

订单实体类

package com.zcl.springcode.dto;

import org.springframework.stereotype.Component;

import java.math.BigDecimal;

/**
 * 订单实体类.
 *
 * @Author Chenglin Zhu
 * @Date 2020/9/23 10:26
 */
@Component
public class OrderDTO {

    private String code;
    private BigDecimal price;
    /*
    * 订单类型
    * 1、普通订单
    * 2、团购订单
    * 3、促销订单
    *
    * */
    private String type;

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public BigDecimal getPrice() {
        return price;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

订单服务类

package com.zcl.springcode.service;

import com.zcl.springcode.dto.OrderDTO;

/**
 * 订单服务类.
 *
 * @Author Chenglin Zhu
 * @Date 2020/9/23 10:28
 */
public interface IOrderService {

    /**
     * 根据订单的不同类型做出不同处理
     *
     * @param dto 订单实体
     * @return 返回字符串
     */
    String handle(OrderDTO dto);

}

订单实现类（通过if…else方法实现）

package com.zcl.springcode.service.impl;

import com.zcl.springcode.dto.OrderDTO;
import com.zcl.springcode.service.IOrderService;
import org.springframework.stereotype.Service;

/**
 * 订单实现类.
 *
 * @Author Chenglin Zhu
 * @Date 2020/9/23 10:30
 */
@Service("orderServiceImpl")
public class OrderServiceImpl implements IOrderService {
    @Override
    public String handle(OrderDTO dto) {
        String type = dto.getType();
        // 传统思路，通过if...else实现多类型的方案处理
        if ("1".equals(type)) {
            return "处理普通订单";
        } else if ("2".equals(type)) {
            return "处理团购订单";
        } else if ("3".equals(type)) {
            return "处理促销订单";
        }
        return null;
    }
}

策略模式

抽象处理器

package com.zcl.springcode.util;

import com.zcl.springcode.dto.OrderDTO;

/**
 * 抽象处理器.
 *
 * @Author Chenglin Zhu
 * @Date 2020/9/23 11:01
 */
public abstract class AbstractHandler {
    abstract public String handle(OrderDTO dto);
}

自定义注解

package com.zcl.springcode.annotation;

import java.lang.annotation.*;

/**
 * .
 *
 * @Author Chenglin Zhu
 * @Date 2020/9/23 11:02
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface HandlerType {
    String value();
}

处理返回对应扩展实现类

package com.zcl.springcode.util;

import com.zcl.springcode.annotation.HandlerType;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 处理返回对应扩展实现类.
 *
 * @Author Chenglin Zhu
 * @Date 2020/9/23 10:44
 */
@Component
public class HandleContext implements ApplicationContextAware {

    @Autowired
    private ApplicationContext applicationContext;

    private Map<String,Class> handlerMap;

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

    public AbstractHandler getInstance(String type){
        Class clazz =   handlerMap.get(type);
        if (clazz == null) {
            throw new IllegalArgumentException("not found handler for type:"+type);
        }
        return (AbstractHandler) applicationContext.getBean(clazz);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        // 遍历带有HandlerType注释的类
        Map<String,Object> beans = applicationContext.getBeansWithAnnotation(HandlerType.class);
        if (beans.size() > 0) {
            for (Object serviceBean : beans.values()) {
                String payType = serviceBean.getClass().getAnnotation(HandlerType.class).value();
                handlerMap.put(payType, serviceBean.getClass());
            }
        }
    }
}

继承抽象处理器的实现类

团购订单处理类

package com.zcl.springcode.service.impl;

import com.zcl.springcode.annotation.HandlerType;
import com.zcl.springcode.dto.OrderDTO;
import com.zcl.springcode.util.AbstractHandler;
import org.springframework.stereotype.Component;

/**
 * 团购订单处理类.
 *
 * @Author Chenglin Zhu
 * @Date 2020/9/23 11:01
 */
@Component
@HandlerType("2")
public class GroupHandler extends AbstractHandler {
    @Override
    public String handle(OrderDTO dto) {
        return "处理团购订单";
    }
}

普通订单处理类

package com.zcl.springcode.service.impl;

import com.zcl.springcode.annotation.HandlerType;
import com.zcl.springcode.dto.OrderDTO;
import com.zcl.springcode.util.AbstractHandler;
import org.springframework.stereotype.Component;

/**
 * 普通订单处理类.
 *
 * @Author Chenglin Zhu
 * @Date 2020/9/23 11:01
 */
@Component
@HandlerType("1")
public class NormalHandler extends AbstractHandler {
    @Override
    public String handle(OrderDTO dto) {
        return "处理普通订单";
    }
}

促销订单处理类

package com.zcl.springcode.service.impl;

import com.zcl.springcode.annotation.HandlerType;
import com.zcl.springcode.dto.OrderDTO;
import com.zcl.springcode.util.AbstractHandler;
import org.springframework.stereotype.Component;

/**
 * 促销订单处理类.
 *
 * @Author Chenglin Zhu
 * @Date 2020/9/23 11:01
 */
@Component
@HandlerType("3")
public class PromotionHandler extends AbstractHandler {
    @Override
    public String handle(OrderDTO dto) {
        return "处理促销订单";
    }
}

订单控制层

package com.zcl.springcode.controller;

import com.zcl.springcode.dto.OrderDTO;
import com.zcl.springcode.service.IOrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * 订单控制层.
 *
 * @Author Chenglin Zhu
 * @Date 2020/9/23 10:34
 */
@RestController
public class OrderController {
    @Autowired
    IOrderService orderServiceImpl;

    @Autowired
    IOrderService orderServiceV2Impl;

    @RequestMapping("/order")
    @ResponseBody
    public String order(OrderDTO dto){
        return orderServiceImpl.handle(dto);
    }

    @RequestMapping("/order2")
    @ResponseBody
    public String order2(OrderDTO dto){
        return orderServiceV2Impl.handle(dto);
    }
}