设计模式学习笔记（九、行为型-职责链模式）

目录：

• 什么是职责链模式
• 为什么要有职责链模式
• 职责链模式的代码实现

什么是职责链模式

GoF中的定义是这样的：将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链，并沿着这条链传递这个请求，直到链上的某个接收对象能够处理它为止。

简单来说就是，多个处理器依次处理同一个请求，这个请求会先经过A处理器，处理完后再转交给B、C，以此类推。若某个处理器能够处理完成，则无需转交给下一个处理器来处理。

这种以链条形式处理各自职责的模式，叫做责任链模式。

为什么要有职责链模式

将请求的发送和接收解耦。

职责链模式的代码实现

1、基于链表实现。

/**
 * 职责连-抽象类
 *
 * @author zhoude
 * @date 2020/4/19 18:02
 */
public abstract class Handler {
    /**
     * 链路的接班人，也就是下一个要处理的链路，如果为null则表示这是最后一个链路
     */
    protected Handler successor = null;

    public final void handle() {
        boolean handler = doHandler();
        // 如果此链路未处理完成则转交到下一个链路处理
        if (!handler && successor != null) {
            successor.handle();
        }
    }

    /**
     * 当前链路的处理逻辑
     *
     * @return true=处理成功，false=未处理完成，待后续链路处理
     */
    public abstract boolean doHandler();

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
}

public class HandlerA extends Handler {
    @Override
    public boolean doHandler() {
        System.err.println("这里是HandlerA的处理逻辑");
        return false;
    }
}

public class HandlerB extends Handler {
    @Override
    public boolean doHandler() {
        System.err.println("这里是HandlerB的处理逻辑");
        return false;
    }
}

/**
 * 处理链路
 *
 * @author zhoude
 * @date 2020/4/19 18:09
 */
public class HandlerChain {
    /**
     * 头链路
     */
    private Handler head;

    /**
     * 尾链路
     */
    private Handler tail;

    public void addHandler(Handler handler) {
        // 每次添加新的处理链前先将尾链路的接班人设置为null，表示无后续链路
        handler.setSuccessor(null);

        // 第一个链路的头尾链路是同一个
        if (head == null) {
            head = handler;
            tail = handler;
            return;
        }

        // 非第一个链路，先设置其接班人为当前新添加的链路
        tail.setSuccessor(handler);
        // 新添加一个链路后，此条链路的尾部链路为当前添加的链路
        tail = handler;
    }

    public void handler() {
        if (head != null) {
            head.handle();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        HandlerChain chain = new HandlerChain();
        chain.addHandler(new HandlerA());
        chain.addHandler(new HandlerB());
        chain.handler();
    }
}

2、基于数组实现，这种实现方式更加简单

/**
 * 处理链
 *
 * @author zhoude
 * @date 2020/4/19 18:35
 */
public interface IHandler {
    /**
     * 具体处理逻辑
     *
     * @return true=处理成功，false=未处理完成，待后续链路处理
     */
    boolean handler();
}

public class HandlerA implements IHandler {
    @Override
    public boolean handler() {
        System.err.println("这里是HandlerA的处理逻辑");
        return false;
    }
}

public class HandlerB implements IHandler {
    @Override
    public boolean handler() {
        System.err.println("这里是HandlerB的处理逻辑");
        return false;
    }
}

public class HandlerChain {
    private List<IHandler> chain = new ArrayList<>();

    public void addHandler(IHandler handler) {
        this.chain.add(handler);
    }

    public void handler() {
        for (IHandler handler : chain) {
            boolean handled = handler.handler();
            if (handled) {
                break;
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        HandlerChain chain = new HandlerChain();
        chain.addHandler(new HandlerA());
        chain.addHandler(new HandlerB());
        chain.handler();
    }
}