java中策略模式的简单实现

首先有四要素：1每种策略都要执行的接口及对应实体类 2接口实现类（各个策略具体实现）3策略Map封装，根据key在Map里找到对应的策略应对

举例：根据不同的支付订单产生不同的应对策略

4种策略： （1）PC端支付宝支付 （2）PC端微信支付 （3）手机端支付宝支付（4）手机端微信支付

1每种策略都要执行的接口及对应实体类

@Data
@Component
public class Order implements Serializable {
    /**
     * 订单来源
     */
    private String source;
    /**
     * 支付方式
     */
    private String payMethod;
    /**
     * 订单编号
     */
    private String code;
    /**
     * 订单金额
     */
    private BigDecimal amount;
    /**其他字段  */
}

/**
 * @author czh
 * @discription  每个订单处理类都需要实现的接口
 */
public interface OrderHandler {
    /**
     *
     * 处理订单的方法
     * @param order 订单石头类
     * @return 返回信息
     */
    void handle(Order order);
}

/**
 * @author czh
 * @discription     作用于类上，用来标注某个类是用来处理哪种来源的订单
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Service
public @interface OrderHandlerType {
    String source();
    String payMethod();
}

2接口实现类

/**
 * @author czh
 * @discription   pc端支付宝支付
 */
@OrderHandlerType(source = "pc", payMethod = "ali")
@Slf4j
public class PcAliPayOrderHandler implements OrderHandler {
    @Override
    public void handle(Order order) {
        log.info("处理pc端支付宝支付的订单");
    }
}

/**
 * @author czh
 * @discription pc端微信支付
 */
@OrderHandlerType(source = "pc", payMethod = "wechat")
@Slf4j
public class PcWeChatOrderHandler implements OrderHandler {
    @Override
    public void handle(Order order)
    {
        log.info("处理pc端微信支付的订单");
    }
}

/**
 * @author czh
 * @discription   手机端支付宝支付
 */
@OrderHandlerType(source = "mobile",payMethod = "ali")
@Slf4j
public class MobileALiPayOrderHandler implements OrderHandler {
    @Override
    public void handle(Order order) {
        log.info("处理手机端支付宝支付的订单");
    }
}

/**
 * @author czh
 * @discription   手机端微信支付
 */
@OrderHandlerType(source = "mobile",payMethod = "wechat")
@Slf4j
public class MobileWeChatOrderHandler implements OrderHandler {
    @Override
    public void handle(Order order) {
        log.info("处理手机端微信支付的订单");
    }
}

3策略Map封装，根据key在Map里找到对应的策略应对

1）将所有策略（实现了策略注解的类）封装到map中

2）根据传入的策略值（key），在map中找到value(对应的策略具体实现类)

/**
 * @author czh
 * @discription orderHandlerMap 它的key为对应的订单处理器handler，通过Autowired去
 * 初始化orderHandlerMap，即从OrderHandlerMap中根据订单来源获取对应的OrderHandler,
 * 然后执行OrderHandler.handle方法即可
 */
@Service
@Slf4j
public class OrderService {
    private Map<OrderHandlerType, OrderHandler> orderHandlerMap;
    /**
     *
     * 会对List<OrderHandLer>自动进行赋值，赋值为实现了orderHandler的类对象，
     * @param
     * @return 返回信息
     */
    @Autowired
    public void setOrderHandlerMap(List<OrderHandler> orderHandlers) {
        /**注入各种类型的订单处理类  */

        orderHandlerMap = orderHandlers.stream().collect(Collectors.toMap(orderHandler -> AnnotationUtils.findAnnotation(orderHandler.getClass(), OrderHandlerType.class), v -> v, (v1, v2) -> v1));
        orderHandlerMap.forEach((k,v)->{
            OrderHandlerType orderHandlerType = k;
//            log.info(orderHandlerType.toString());
//            log.info("k为"+k+"value值为"+v);
        });
    }

    public void orderService(Order order) {
        /**通过订单来源,以及支付方式获取对应的handler  */
        /**通过订单来源，支付方式找到对应的注解类   例如，source="pc",payMethod="Ali" ，再从map集合中取到对应的handler */
        OrderHandlerType orderHandlerType = new OrderHandlerTypeImpl(order.getSource(), order.getPayMethod());
        OrderHandler orderHandler = orderHandlerMap.get(orderHandlerType);
        orderHandler.handle(order);
    }
}

用来比较对象（这个忽略就好，得有这个类）

/**
 * @author czh
 * @discription
 */
@Service
@NoArgsConstructor
@Slf4j
public class OrderHandlerTypeImpl implements OrderHandlerType {

    private String source;
    private String payMethod;

    OrderHandlerTypeImpl(String source, String payMethod) {
        this.source = source;
        this.payMethod = payMethod;
    }

    @Override
    public int hashCode() {
        int hashCode = 0;
        hashCode += (127 * "source".hashCode()) ^ source.hashCode();
        hashCode += (127 * "payMethod".hashCode()) ^ payMethod.hashCode();
        return hashCode;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof OrderHandlerType)){
            return false;
        }
        OrderHandlerType orderHandlerType = (OrderHandlerType) obj;
    return source.equals(orderHandlerType.source()) && payMethod.equals(orderHandlerType.payMethod());
    }

    @Override
    public String source() {
        return source;
    }

    @Override
    public String payMethod() {
        return payMethod;
    }

    @Override
    public Class<? extends Annotation> annotationType() {

        return OrderHandlerType.class;
    }
}

4调用

/**
 * @author czh
 * @discription
 */
@RequestMapping("/celue")
@RestController
public class HandlerController {

    @Autowired
    OrderService orderService;

    @GetMapping("/test")
    public String test(@RequestBody Order order) {
        orderService.orderService(order);
        return "";
    }
}

至此策略模式实现