第八章 策略模式

Java设计模式浅析

第一章 简单工厂模式
第二章 工厂方法模式
第三章 抽象工厂模式
第四章 单例模式
第五章 破坏单例模式
第六章 原型模式
第七章 代理模式
第八章 策略模式

---

---

策略模式概述

策略模式（Strategy Pattern）是指定义了算法家族并分别封装起来，		 
让它们之间可以相互替换，
此模式使得算法的变化不会影响使用算法的用户。

---

一、示例代码

订单类

package com.Design.Proxy.Strategy;
import com.Design.Proxy.Strategy.Payment;
//订单类
public class Order {
    private String uid;
    private String orderId;
    private Double amount;

    public Order(String uid, String orderId, Double amount) {
        this.uid = uid;
        this.orderId = orderId;
        this.amount = amount;
    }

    public PayState pay() {
        //无参数 取默认支付方式
        return pay(PayStrategy.DEFAULT_PAY);
    }

    public PayState pay(String payKey) {
        //从策略类取支付方式 参数 payKey
        Payment payment = PayStrategy.get(payKey);
        System.out.println("欢迎使用" + payment.getName());
        System.out.println("本次交易金额为：" + amount + "，开始扣款。。。");
        return payment.pay(uid, amount);
    }
}

支付策略管理类

package com.Design.Proxy.Strategy;
import com.Design.Proxy.Strategy.AliPay;
import com.Design.Proxy.Strategy.Payment;
import com.Design.Proxy.Strategy.UnionPay;
import com.Design.Proxy.Strategy.WechatPay;

import java.util.HashMap;
import java.util.Map; 
//逻辑处理类
public class PayStrategy {

    public static final String DEFAULT_PAY = "AliPay";
    public static final String ALI_PAY = "AliPay";
    public static final String WECHAT_PAY = "WechatPay";
    public static final String UNION_PAY = "UnionPay";

    private static Map<String, Payment> payStrategy = new HashMap<>();

    static {
        // map 存放  <String, Payment> Payment的各继承类
        payStrategy.put(DEFAULT_PAY, new AliPay());
        payStrategy.put(ALI_PAY, new AliPay());
        payStrategy.put(WECHAT_PAY, new WechatPay());
        payStrategy.put(UNION_PAY, new UnionPay());
    }

    public static Payment get(String payKey) {
        if (!payStrategy.containsKey(payKey)) {
            //map中没有对应的key 就取默认的支付方式  new AliPay()
            return payStrategy.get(DEFAULT_PAY);
        }
        return payStrategy.get(payKey);
    }
}

抽象支付父类

定义支付规范和支付逻辑

package com.Design.Proxy.Strategy;
//抽象支付方式父类
public abstract class Payment {

    /**
     * 支付类型
     */
    public abstract String getName();

    /**
     * 查询余额
     *
     * @param uid
     * @return
     */
    protected abstract double queryBalance(String uid);

    /**
     * 扣款
     *
     * @param uid
     * @param amount
     */
    public PayState pay(String uid, Double amount) {
         System.out.println(queryBalance(uid));
        if (queryBalance(uid) < amount) {
            return new PayState(500, "支付失败", "余额不足");
        }
        return new PayState(200, "支付成功", "支付金额：" + amount);
    }
}

支付子类

支付宝支付

package com.Design.Proxy.Strategy;

public class AliPay extends Payment{

    @Override
    public String getName() {
        return "支付宝";
    }

    @Override
    //查询余额
    protected double queryBalance(String uid) {
        return 10;
    }
}

微信支付

package com.Design.Proxy.Strategy;

public class WechatPay extends Payment{
    
    @Override
    public String getName() {
        return "微信支付";
    }

    @Override
    protected double queryBalance(String uid) {
        return 256;
    }
}

银联支付

package com.Design.Proxy.Strategy;

public class UnionPay extends Payment{
    @Override
    public String getName() {
        return "银联支付";
    }

    @Override
    protected double queryBalance(String uid) {
        return 120;
    }
}

支付状态包装类

package com.Design.Proxy.Strategy;
//支付状态类
public class PayState {
    private int code;
    private Object data;
    private String msg;

    public PayState(int code, Object data, String msg) {
        this.code = code;
        this.data = data;
        this.msg = msg;
    }

    @Override
    public String toString() {
        return ("支付状态：[" + code + "]，" + msg + "，交易详情：" + data);
    }
}

二、测试代码

package com.Design.Proxy.Strategy;

public class PayStrategyTest {
    public static void main(String[] args) {
        Order order = new Order("1", "20191119163020300", 300.87);
        System.out.println(order.pay(PayStrategy.ALI_PAY));
        System.out.println(order.pay(PayStrategy.UNION_PAY));
        System.out.println(order.pay(PayStrategy.WECHAT_PAY));
    }
}

---

总结

该模式比较简单，把策略管理类和订单类中的处理方式搞懂就OK了！！！

order类

    public PayState pay() {
        //无参数 取默认支付方式
        //会再次调用有参的pay（payKey）方法
        return pay(PayStrategy.DEFAULT_PAY);
    }

    public PayState pay(String payKey) {
        //从策略类取支付方式 参数 payKey
        Payment payment = PayStrategy.get(payKey);
        System.out.println("欢迎使用" + payment.getName());
        System.out.println("本次交易金额为：" + amount + "，开始扣款。。。");
        return payment.pay(uid, amount);
    }

策略管理类

static {
        // map 存放  <String, Payment> Payment的各继承类
        // 静态方法
        payStrategy.put(DEFAULT_PAY, new AliPay());
        payStrategy.put(ALI_PAY, new AliPay());
        payStrategy.put(WECHAT_PAY, new WechatPay());
        payStrategy.put(UNION_PAY, new UnionPay());
    }

    public static Payment get(String payKey) {
        //payStrategy 判断map中是否存在对应的key
        if (!payStrategy.containsKey(payKey)) {
            //map中没有对应的key 就取默认的支付方式  new AliPay()
            return payStrategy.get(DEFAULT_PAY);
        }
        //
        return payStrategy.get(payKey);
    }