【玩烂设计模式】设计模式之策略模式

2022-10-25 15:14:13 浏览数 (1)

什么是策略模式 策略模式就是定义了算法家族 分别封装起来 让它们之间互相替换 从模式让算法的变化 不会影响到使用算法的客户。

可能听起来比较抽象 举个栗子 双十一要来了 我在官网上买了一件东西 付款是用支付宝付款还是用微信付款还是银联付款 支付宝付款是一种策略 微信付款是一种策略 具体用什么付款用户来决定 如何优雅的根据用户的选择调用不同的付款方式 这是策略模式做的事情。。

下例是使用注解配合反射方式，扫描到所有的具体的支付策略并放到map集合中，然后根据前端传递来的支付类型参数，选择对应的支付策略，完成支付过程。

PayStrategy是支付策略接口；

OrderPay（订单支付），WeChatPay是PayStrategy的具体实现（支付场景）；

AbstractPayService是实现PayStrategy接口的抽象类，规定了支付的流程，在其中选择具体的支付策略，为controller提供支付接口；

PayServiceImpl实现AbstractPayService中规定的支付流程的具体步骤，调用PayStrategyFactory获取实际的支付策略class Pay是自定义注解 用来标注具体的支付方式

PayStrategyFactory使用反射扫描被Pay注解注释的类，获得所有支付策略的类型和class；调用BeansUtil返回spring容器中的具体的策略实现类；

下面我将使用代码来贴出来。。

目录结构：

PayStrategy

代码语言：javascript复制
package com.example.strategyTwo.service;

/**
 * 支付策略
 *
 * @author xiepanpan
 * @date 2018/11/14
 **/
public interface PayStrategy {

    /**
     * 支付前准备支付参数
     *
     * @param payFor
     * @return
     */
    boolean prePay(String payFor);

    /**
     * 支付后处理支付回调结果
     *
     * @param payFor
     * @param isPaySuccess
     */
    void afterPay(String payFor, boolean isPaySuccess);
}

AliPay

代码语言：javascript复制
package com.example.strategyTwo.service;

import com.example.strategyTwo.annotation.Pay;
import org.springframework.stereotype.Service;

/**
 * @author: xiepanpan
 * @Date: 2019/11/10
 * @Description:  支付宝支付
 */
@Service
@Pay("alipay")
public class AliPay implements PayStrategy {
    /**
     * 支付前准备支付参数
     *
     * @param payFor
     */
    @Override
    public boolean prePay(String payFor) {
        System.out.printf("-----------%s-----------rn", "欢迎使用支付宝");
        return true;
    }

    /**
     * 支付后处理支付回调结果
     *
     * @param payFor
     * @param isPaySuccess
     */
    @Override
    public void afterPay(String payFor, boolean isPaySuccess) {
        System.out.printf("-----------%s-----------n", "支付宝支付成功 付款2000");
    }
}

WeChatPay

代码语言：javascript复制
package com.example.strategyTwo.service;

import com.example.strategyTwo.annotation.Pay;
import org.springframework.stereotype.Service;

/**
 * @author: xiepanpan
 * @Date: 2019/11/10
 * @Description:  微信支付
 */
@Service
@Pay("wechatPay")
public class WeChatPay implements PayStrategy {
    /**
     * 支付前准备支付参数
     *
     * @param payFor
     */
    @Override
    public boolean prePay(String payFor) {
        System.out.printf("-----------%s-----------rn", "欢迎使用微信支付");
        return true;
    }

    /**
     * 支付后处理支付回调结果
     *
     * @param payFor
     * @param isPaySuccess
     */
    @Override
    public void afterPay(String payFor, boolean isPaySuccess) {
        System.out.printf("-----------%s-----------n", "微信支付成功 付款2000");
    }
}

AbstractPayService

代码语言：javascript复制
package com.example.strategyTwo.service;

/**
 * @author: xiepanpan
 * @Date: 2019/11/10
 * @Description:
 */
public abstract class AbstractPayService implements PayStrategy {
    protected String payType;

    /**
     * 支付
     *
     * @param payType
     * @param payFor
     */
    public void pay(String payType, String payFor) {
        this.payType = payType;
        boolean isPrepared = prePay(payFor);

        if (isPrepared) {
            System.out.println("------------支付请求已提交------------");
        } else {
            System.out.println("------------支付请求提交失败------------");
            return;
        }
        afterPay(payFor, true);
    }
}

PayServiceImpl

代码语言：javascript复制
package com.example.strategyTwo.service;

import com.example.strategyTwo.utils.PayStrategyFactory;
import org.springframework.stereotype.Service;

/**
 * @author: xiepanpan
 * @Date: 2019/11/10
 * @Description:  支付service
 */
@Service
public class PayServiceImpl extends AbstractPayService {
    /**
     * 支付前准备支付参数
     *
     * @param payFor
     */
    @Override
    public boolean prePay(String payFor) {
        PayStrategy payStrategy = PayStrategyFactory.getStrategy(this.payType);
        if (payStrategy == null) {
            System.out.printf("没有%s类型的支付策略...rn", this.payType);
            return false;
        }
        return payStrategy.prePay(payFor);
    }

    /**
     * 支付后处理支付回调结果
     *
     * @param payFor
     * @param isPaySuccess
     */
    @Override
    public void afterPay(String payFor, boolean isPaySuccess) {
        PayStrategy payStrategy = PayStrategyFactory.getStrategy(this.payType);
        payStrategy.afterPay(payFor, true);
    }
}

PayStrategyFactory

代码语言：javascript复制
package com.example.strategyTwo.utils;

import com.example.strategyTwo.annotation.Pay;
import com.example.strategyTwo.service.PayStrategy;
import org.reflections.Reflections;
import org.springframework.util.StringUtils;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 支付策略工厂
 *
 * @author xiepanpan
 * @date 2018/11/14
 **/
public class PayStrategyFactory {

    private static final String PAY_STRATEGY_IMPLEMENTATION_PACKAGE = "com.example.strategyTwo.service";
    private static final Map<String, Class> STRATEGY_MAP = new HashMap<>();

    // 获取所有支付策略
    static {
        Reflections reflections = new Reflections(PAY_STRATEGY_IMPLEMENTATION_PACKAGE);
        Set<Class<?>> classSet = reflections.getTypesAnnotatedWith(Pay.class);
        classSet.forEach(aClass -> {
            Pay payAnnotation = aClass.getAnnotation(Pay.class);
            STRATEGY_MAP.put(payAnnotation.value(), aClass);
        });
    }

    /**
     * 根据支付策略类型获取支付策略bean
     *
     * @param type
     * @return
     */
    public static PayStrategy getStrategy(String type) {
        // 反射获取支付策略实现类clazz
        Class clazz = STRATEGY_MAP.get(type);
        if (StringUtils.isEmpty(clazz)) {
            return null;
        }

        // 通过applicationContext获取bean
        return (PayStrategy) BeansUtil.getBean(clazz);
    }
}

BeansUtil

代码语言：javascript复制
package com.example.strategyTwo.utils;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * @author: xiepanpan
 * @Date: 2019/11/10
 * @Description:  bean工具类
 */
@Component
public class BeansUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        BeansUtil.applicationContext = applicationContext;
    }

    /**
     * 获取实例
     *
     * @param clazz
     * @return
     */
    public static Object getBean(Class clazz) {
        return applicationContext.getBean(clazz);
    }
}

Pay

代码语言：javascript复制
package com.example.strategyTwo.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解 标注支付策略
 *
 * @author xiepanpan
 * @date 2018/11/14
 **/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Pay {
    /**
     * 支付类型
     *
     * @return
     */
    String value();
}

PayController

代码语言：javascript复制
package com.example.strategyTwo.controller;

import com.example.strategyTwo.service.AbstractPayService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 支付
 *
 * @author xiepanapn
 * @date 2018/11/14
 **/
@RestController
@RequestMapping("pay")
public class PayController {
    @Autowired
    private AbstractPayService payService;

    @GetMapping
    public void pay(@RequestParam String payType, @RequestParam String payFor) {
        payService.pay(payType, payFor);
    }
}

请求路径： http://localhost:8080/pay?payType=wechatPay&payFor=20

而这种方式也方便扩展 比如再加入京东白条支付这种策略 只需要把AliPay复制一份改改名就可以了。。

代码： https://github.com/xiepanpan/strategy 总结：

设计模式最重要的就是把复杂问题简单化 当用户在面临选择的时候 在写出ifelse switch的时候 我们就可以考虑策略模式。。 而设计模式往往是多种设计模式结合着使用 策略模式往往与工厂模式结合着使用 因为它要根据不同的策略生成不同的具体类 而工厂模式就是怎么优雅的生产类

参考博客：

文章都不错

这个文章后面还有源码： https://www.cnblogs.com/jcook/p/6476731.html

https://www.cnblogs.com/zhya/p/9957819.html

https://www.cnblogs.com/chenshengyue/p/10826087.html

https 网络安全 html 编程算法 微信

0 人点赞