读设计模式之禅--责任链模式

• 定义：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

package design.ResponsibilityChain;

/**
 * @Author: hyh
 * @Date: 2021/8/18 15:26
 * 抽象一个请求处理类
 **/
public abstract class Handler {
    // 下一个处理者
    private Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void response();

    protected final void handler(Request r) {
        if (r.getType() == this.getLevel()) {
            this.response();
        } else if (this.nextHandler != null) {
            this.nextHandler.handler(r);
        } else {
            System.out.println("一边玩去");
        }

    }

    public abstract int getLevel();
}

class Request {

    private int type;
    private String req;

    public Request(int type, String req) {
        this.type = type;
        this.req = req;
    }

    public int getType() {
        return type;
    }
}

class Level {

    private static final int TO_FATHER = 1;
    private static final int TO_MATHER = 2;
    private static final int TO_GRandMA = 3;

    public static int getToFather() {
        return TO_FATHER;
    }

    public static int getToMather() {
        return TO_MATHER;
    }

    public static int getTO_GRandMA() {
        return TO_GRandMA;
    }
}

class Father extends Handler {

    @Override
    public void response() {
        System.out.println("爸爸没有钱");
    }

    @Override
    public int getLevel() {
        return Level.getToFather();
    }
}

class GrandM extends Handler {

    @Override
    public void response() {
        System.out.println("奶奶没有钱");
    }

    @Override
    public int getLevel() {
        return Level.getTO_GRandMA();
    }
}

class Mather extends Handler {

    @Override
    public void response() {
        System.out.println("妈妈没有钱");
    }

    @Override
    public int getLevel() {
        return Level.getToMather();
    }
}
// 做一次封装
class HandlerManage {

    private Handler father;

    public HandlerManage() {
        father = new Father();
        Handler mather = new Mather();
        Handler grandM = new GrandM();
        father.setNextHandler(mather);
        mather.setNextHandler(grandM);
    }

    public void handler(Request r) {
        this.father.handler(r);
    }
}

class Child {
    public static void main(String[] args) {
        HandlerManage handlerManage = new HandlerManage();
        Request request = new Request(Level.getTO_GRandMA(), "给奶奶要钱");
        handlerManage.handler(request);
    }
}
输出：
奶奶没有钱

责任链模式的应用

• 责任链模式的优点

责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的，处 理者可以不用知道请求的全貌（例如在J2EE项目开发中，可以剥离出无状态Bean由责任链处 理），两者解耦，提高系统的灵活性。

• 责任链模式的缺点

责任链有两个非常显著的缺点：一是性能问题，每个请求都是从链头遍历到链尾，特别 是在链比较长的时候，性能是一个非常大的问题。二是调试不很方便，特别是链条比较长， 环节比较多的时候，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂。

• 责任链模式的注意事项

链中节点数量需要控制，避免出现超长链的情况，一般的做法是在Handler中设置一个 最大节点数量，在setNext方法中判断是否已经是超过其阈值，超过则不允许该链建立，避免 无意识地破坏系统性能。