java设计模式---策略模式

设计模式

单例模式、策略模式、工厂模式…

策略模式

1. 定义

• 又叫Policy，将多个不同算法，将其分别封装起来，并且使他们可以相互替换。策略模式可以独立于使用他们的客户端而变化
• 常用于替换多个的if else的场景
• 好处1：满足java的开闭原则，扩展开放，修改关闭
• 好处2：符合java面向对象的特性

2. 案例说明：某支付系统的充值算法（列举4种不同的充值算法）

• 网银充值，8.5折
• 商户充值，9折
• 手机充值，没有优惠
• 点卡充值，收取1%的渠道费

3. 新手设计

package com.strategy;

public class Example {

    public Double calRecharge(Double charge, RechargeTypeEnum type) {
        if (type.equals(RechargeTypeEnum.E_BANK)) {
            return charge * 0.85;
        } else if (type.equals(RechargeTypeEnum.BUSI_ACCOUNTS)) {
            return charge * 0.90;
        } else if (type.equals(RechargeTypeEnum.MOBILE)) {
            return charge;
        } else if (type.equals(RechargeTypeEnum.CARD_RECHARGE)) {
            return charge + charge * 0.01;
        } else {
            return null;
        }
    }
}

4. 老司机设计—静态结构图

• RechargeTypeEnum（枚举类，4种充值方式）

package com.strategy;

public enum RechargeTypeEnum {

    E_BANK(1, "网银"),

    BUSI_ACCOUNTS(2, "商户账号"),

    MOBILE(3, "手机卡充值"),

    CARD_RECHARGE(4, "充值卡");

    private int value;
    private String description;

    private RechargeTypeEnum(int value, String description) {
        this.value = value;
        this.description = description;
    }

    public int value() {
        return value;
    }

    public String description() {
        return description;
    }

    public static RechargeTypeEnum valueOf(int value) {
        for (RechargeTypeEnum type : RechargeTypeEnum.values()) {
            if (type.value() == value) {
                return type;
            }
        }
        return null;
    }
}

• Strategy接口–体现了策略模式+java面向对象和多态

package com.strategy;

/**
 * ①网银充值，8.5折；
 *
 * ②商户充值，9折；
 *
 * ③手机充值，没有优惠；
 *
 * ④点卡充值，收取1%的渠道费；
 */
public interface Strategy {
    public Double calRecharge(Double charge, RechargeTypeEnum type);
}

• 实现类1：EBankStrategy（网银充值）

package com.strategy;

public class EBankStrategy implements Strategy{
    @Override
    public Double calRecharge(Double charge, RechargeTypeEnum type) {
        return charge*0.85;
    }
}

• 实现类2：BusiAcctStrategy（商户充值）

package com.strategy;

public class BusiAcctStrategy implements Strategy {
    @Override
    public Double calRecharge(Double charge, RechargeTypeEnum type) {
        return charge*0.90;
    }
}

• 实现类3：MobileStrategy（手机充值）

package com.strategy;

public class MobileStrategy implements Strategy {
    @Override
    public Double calRecharge(Double charge, RechargeTypeEnum type) {
        return charge;
    }
}

• 实现类4：CardStrategy（点卡充值）

package com.strategy;

public class CardStrategy implements Strategy {
    @Override
    public Double calRecharge(Double charge, RechargeTypeEnum type) {
        return charge*1.01;
    }
}

• 重点：StrategyFactory（创建策略类的工厂—此工厂是个单例）

package com.strategy;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * StrategyFactory是一个单例
 *  通过静态内部类实例化单例对象
 *  好处4点：比懒汉式和恶汉式好
 *  ① 只有在调用getInstance()时候才会加载StrategyFactoryInnerClass这个内部类，不会有类加载效率慢以及资源浪费的情况（恶汉式就会有此两种麻烦）
 *  ② 多线程情况下，没有线程安全问题，无论如何得到的都是同一单例(懒汉式不加锁会有线程安全问题，加锁会造成类加载效率慢)
 *  ③ 增加私有构造器相关处理（避免反射暴力访问）
 *  ④ 增加反序列化调用方法（避免反序列化时得到的不是同一个对象）
 */
public class StrategyFactory {

    private static StrategyFactory factory =null;

    private static class StrategyFactoryInnerClass{
        private static final StrategyFactory factory=new StrategyFactory();
    }

    //外部获取单例工厂对象的方法入口
    public static StrategyFactory getInstance(){
        return StrategyFactoryInnerClass.factory;
    }


    /**
     * 注意两点：
     * ① 为啥要私有化构造器：防止外部调用此构造器new对象，那么得到的就不是单例咯
     * ② private我也可以访问：我用反射暴力破解获得该类的私有构造器，从而new 对象，所以里面加了个判断，保证就算反射得到的也是该单例
     */
    private StrategyFactory(){
        if(factory!=null){
            throw new RuntimeException("此factory已存在，不允许调用此构造器创建对象");
        }
    }

    /**
     * 防止通过反序列化对象（in.readObject）得到的对象不是同一个
     * 反序列化就调用此方法获取此单列
     */
    public Object readResolve(){
        return factory;
    }

    private static Map strategyMap = new ConcurrentHashMap();


    static{
        strategyMap.put(RechargeTypeEnum.E_BANK.value(), new EBankStrategy());

        strategyMap.put(RechargeTypeEnum.BUSI_ACCOUNTS.value(), new BusiAcctStrategy());

        strategyMap.put(RechargeTypeEnum.MOBILE.value(), new MobileStrategy());

        strategyMap.put(RechargeTypeEnum.CARD_RECHARGE.value(), new CardStrategy());
    }


    public Strategy creator(Integer type){

        return (Strategy)strategyMap.get(type);

    }

}

• Context（全文）

package com.strategy;

public class Context {

    private Strategy strategy;

    public Double calRecharge(Double charge, Integer type) {
        strategy = StrategyFactory.getInstance().creator(type);
        return strategy.calRecharge(charge, RechargeTypeEnum.valueOf(type));
    }

    public Strategy getStrategy() {
        return strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
}

• Client（客户端，即用户端）

package com.strategy;

public class Client {
    public static void main(String[] args) {

        Context context = new Context();


        // 网银充值100 需要付多少
        Double money = context.calRecharge(100D,
                RechargeTypeEnum.E_BANK.value());
        System.out.println(money);


        // 商户账户充值100 需要付多少
        Double money2 = context.calRecharge(100D,
                RechargeTypeEnum.BUSI_ACCOUNTS.value());
        System.out.println(money2);


        // 手机充值100 需要付多少
        Double money3 = context.calRecharge(100D,
                RechargeTypeEnum.MOBILE.value());
        System.out.println(money3);


        // 充值卡充值100 需要付多少
        Double money4 = context.calRecharge(100D,
                RechargeTypeEnum.CARD_RECHARGE.value());
        System.out.println(money4);

    }
}

• 输出结果

85.0
90.0
100.0
101.0