设计模式之委派模式和策略模式

委派模式delegate pattern:负责任务的调度和分配

应用场景

1. 当你要实现表现层和业务层之间的松耦合的时候。
2. 当你想要编排多个服务之间的调用的时候。
3. 当你想要再封装一层服务查找和调用时候

示例代码

public interface IEmployee {

    public void doing(String command);
}

public class EmployeeA implements IEmployee{

    @Override
    public void doing(String command) {

        System.out.println("我是A我可以使用Java");
    }
}


public class EmployeeB implements IEmployee{

    @Override
    public void doing(String command) {

        System.out.println("我是b我可以使用python");
    }
}


//leader相当于委派者，给不同的员工，委派者要有被委派者的引用
public class Leader implements IEmployee{

     private HashMap targets/* 被委派者*/ = new HashMap();


     public Leader(){
         targets.put("java",new EmployeeA());
         targets.put("python",new EmployeeB());

     }

     @Override
    public void doing(String command) {

           targets.get(command).doing(command);

     }
}



//客户端
public class Boss {

    public void command(String command, Leader leader){
        leader.doing(command);
    }
}

委派模式UML

总结：委派模式就是静态代理和策略模式的一种特殊结合，代理模式注重过程委派模式注重结果。委派模式注重内部的灵活和复用，策略模式注重的是可拓展(外部拓展)

策略模式strategy：是指定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变换不会影响到使用算法的用户

应用场景：

1. 假如系统中有很多类，区别仅仅在于行为不同
2. 一个系统需要动态的在几种算法中选择一种

示例代码

public class PayState {

    private int code;
    private Object data;
    private String msg;

    public PayState(int code, String msg, Object data){
        this.code = code;
        this.data = data;
        this.msg = msg;
    }
    public String toString(){
        return ("支付状态：[" + code + "]," + msg + ",交易详情：" + data);
    }
}

//定义抽象的支付规范和逻辑

public abstract class Payment {

    // 支付类型
    public abstract String name();
    // 查询余额
    protected abstract double queryBalance(String uid);
    // 扣款支付
    public PayState pay(String uid,double amount) {
        if(queryBalance(uid) < amount){
        return new PayState(500,"支付失败","余额不足");
        }
        return new PayState(200,"支付成功","支付金额：" + amount);
    }

}


public class ALiPay extends Payment {
    @Override
    public String name() {
        return " 支付宝 ";
    }

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

public class JDPay extends Payment {
    @Override
    public String name() {
        return " 京东白条 ";
    }

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

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

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

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

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

//策略管理相当于工厂
public class PayStrategy {
    public static final String ALI_PAY = "AliPay"; 
    public static final String JD_PAY = "JdPay";
    public static final String UNION_PAY = "UnionPay"; 
    public static final String WECHAT_PAY = "WechatPay";
    public static final String DEFAULT_PAY = ALI_PAY; 
    private static Map payStrategy = new HashMap(); 
    static {
        payStrategy.put(ALI_PAY,new ALiPay()); 
        payStrategy.put(WECHAT_PAY,new WeChatPay()); 
        payStrategy.put(UNION_PAY,new UnionPay());
        payStrategy.put(JD_PAY,new JDPay());
    }
    public static Payment get(String payKey){
        if(!payStrategy.containsKey(payKey)){ 
            return payStrategy.get(DEFAULT_PAY); 
        }
        return payStrategy.get(payKey); 
    }
}

策略模式UML

优缺点：

1. 客户端必须知道所有的策略，并且自行决定使用哪一个策略类
2. 代码中会产生很多的策略类，增加维护难度