JAVA之设计模式-责任链模式

什么是责任链模式？

责任链是一种对象的行为模式，在责任链模式里，很多拥有共同属性的对象组合成一条链。来共同处理一条请求。没有特定指定某一对象来应答请求，这条请求并不知道是哪个对象响应的自己。使得在不影响客户端的情况下动态分配责任。

1.1 举例

我家一共四口人，由姐姐爸爸妈妈组成，现在我要像他们借点生活费，（最近烟钱都没有了...）姐姐的权利比较小，最多只能借我50，妈妈最多只能借我200，爸爸最多只能借我500。姐姐爸爸妈妈都能借我钱，但是每人借钱的额度有限，最后无论是谁都会给我一个响应的结果。

1.2 源代码 

借钱流程的接口类（抽象的）

/**
 * 对外使用的抽象接口
 *
 * @author san.liu
 */
public abstract class PriceHandler {

    // 用于传递请求
    protected PriceHandler priceHandler;

    public void setPriceHandler(PriceHandler priceHandler) {
        this.priceHandler = priceHandler;
    }

    /**
     * 借钱的接口
     *
     * @param price 需要借钱的金额
     * @param sb    日志
     */
    public abstract String Request(double price, StringBuffer sb);
}

姐姐借钱的实现类

/**
 * 姐姐借钱的具体实现类
 *
 * @author san.liu
 */
public class SisterPriceHandler extends PriceHandler {

    public String Request(double price, StringBuffer sb) {
        sb.append("\n我是姐姐-");
        if (price <= 50) {
            sb.append("没有超过50，我可以借给你");
        } else {
            sb.append("超出我的能力范围，你去问问爸妈吧。");
            priceHandler.Request(price, sb);
        }
        return sb.toString();
    }
}

妈妈借钱的实现类

/**
 * 妈妈借钱的具体实现类
 *
 * @author san.liu
 */
public class MotherPriceHandler extends PriceHandler {

    public String Request(double price, StringBuffer sb) {
        sb.append("\n我是妈妈-");
        if (price <= 200) {
            sb.append("没有超过200，我可以借给你");
        } else {
            sb.append("超出我的能力范围，你去问问你爸爸吧。");
            priceHandler.Request(price, sb);
        }
        return sb.toString();
    }
}

爸爸借钱的实现类

/**
 * 爸爸借钱的具体实现类
 *
 * @author san.liu
 */
public class FatherPriceHandler extends PriceHandler {

    public String Request(double price, StringBuffer sb) {
        sb.append("\n我是爸爸-");
        if (price <= 500) {
            sb.append("没有超过500，我可以借给你");
        } else {
            sb.append("小犊子，你要那么多钱干什么！");
        }
        return sb.toString();
    }
}

测试类

// 实现和家人借钱的一个测试方法
    public static void main(String[] args) {

        // 实例化所有可以借给我钱的人
        PriceHandler priceHandler1 = new SisterPriceHandler();
        PriceHandler priceHandler2 = new MotherPriceHandler();
        PriceHandler priceHandler3 = new FatherPriceHandler();

        // 将所有可以借我钱的人连在一起（责任链组装）
        priceHandler1.setPriceHandler(priceHandler2);
        priceHandler2.setPriceHandler(priceHandler3);

        // 测试执行
        StringBuffer sb = new StringBuffer();
        System.out.println(priceHandler1.Request(40, sb));
        System.out.println(priceHandler1.Request(201, sb));
        System.out.println(priceHandler1.Request(501, sb));
    }

log:
       
    我是姐姐-没有超过50，我可以借给你


    我是姐姐-超出我的能力范围，你去问问爸妈吧。
    我是妈妈-超出我的能力范围，你去问问你爸爸吧。
    我是爸爸-没有超过500，我可以借给你


    我是姐姐-超出我的能力范围，你去问问爸妈吧。
    我是妈妈-超出我的能力范围，你去问问你爸爸吧。
    我是爸爸-小犊子，你要那么多钱干什么！

PS:选择StringBuffer的原因是可以更明确的看出整个借钱流程。。。小细节问题

1.3 总结

所有的实现类都继承PriceHandler 这个抽象类，也就是说都可以借给我钱（这是共同点），也是责任链组装在一起必然要素，这种实现方法方便后续的添加，比如我要向爷爷借钱，直接添加爷爷的具体实现类，并组装到责任链中，降低了程序的耦合，而对于我来说，并不关心是谁借我钱。对于客户端来说，我并不知道是谁来响应的我，也就实现可客户端与后台的解耦。

1.4 优点

• 抽象类方法实现简单
• 解耦

1.5 缺点

• 内存消耗大