参考

《设计模式：可复用面向对象软件的基础》5.1 Chain of responsibility 职责链对象行为型模式

《Android源码设计模式解析与实战》第9章使编程更有灵活性--责任链模式

意图

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

适用场景

有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

想在不明确指定接收者的情况下，像多个对象中的一个提交一个请求。

可处理一个请求的对象集合应被动态指定。

结构

Handler 抽象处理角色，声明一个请求处理的方法，并在其中保持一个对下一个处理节点Handler对象的引用。

ConcreteHandler 具体处理者角色，对请求进行处理，如果不能处理则将该请求转发给下一个节点上的处理对象。

进一步抽象

对于请求来说，其形式是固定的，就是一个字符串，而判断一个节点上的对象是否能够处理该请求的标志，则是该字符串是否与之匹配。然而在大多数情况下，责任链中的请求和对应的处理规则是不尽相同的，在这种情况下可以将请求进行抽象，使之对请求的处理规则也进行封装作为一个独立的对象。

进一步抽象Request

代码实现

/** *  抽象处理类 * @author newtrekWang * @email  wangjiaxing20160101@gmail.com * @time   2018/8/19  0:18 */public abstract class AbstractHandler {    /**     * 下一节点上的处理者对象     */    private AbstractHandler nextHandler;    /**     * 处理请求     * @param request     */    public void handleRequest(AbstractRequest request){        if (getHandlerLevel() == request.getRequestLevel()){            handle(request);        }else {            if (nextHandler != null){                nextHandler.handleRequest(request);            }else {                System.out.println("所有对象都不能处理该请求");            }        }    }    /**     * 处理请求     * @param request 请求对象     */    public abstract void handle(AbstractRequest request);    /**     * 每个处理者具体处理请求对象的实现     * @return 处理级别     */    public abstract int getHandlerLevel();    /**     * 设置下一个处理者     * @param nextHandler     */    public void setNextHandler(AbstractHandler nextHandler) {        this.nextHandler = nextHandler;    }}/** *  抽象请求类 * @author newtrekWang * @email  wangjiaxing20160101@gmail.com * @time   2018/8/19  0:20 */public abstract class AbstractRequest {    /**     * 要处理的内容对象     */    private Object object;    /**     * 通过构造函数注入要处理的内容对象     * @param object 要处理的内容对象     */    public AbstractRequest(Object object) {        this.object = object;    }    /**     * 获取要处理的内容对象     * @return 要处理的内容对象     */    public Object getObject() {        return object;    }    /**     * 获取请求级别     * @return 请求级别     */    public abstract int getRequestLevel();}** *  具体处理者1 * @author newtrekWang * @email  wangjiaxing20160101@gmail.com * @time   2018/8/19  0:33 */public class ConcretHandler1 extends AbstractHandler {    @Override    public void handle(AbstractRequest request) {        System.out.println("Handler1 handler request :"+request.getRequestLevel());    }    @Override    public int getHandlerLevel() {        return 1;    }}/** *  具体处理者2 * @author newtrekWang * @email  wangjiaxing20160101@gmail.com * @time   2018/8/19  0:33 */public class ConcretHandler2 extends AbstractHandler {    @Override    public void handle(AbstractRequest request) {        System.out.println("Handler2 handler request :"+request.getRequestLevel());    }    @Override    public int getHandlerLevel() {        return 2;    }}/** *  具体处理者3 * @author newtrekWang * @email  wangjiaxing20160101@gmail.com * @time   2018/8/19  0:33 */public class ConcretHandler3 extends AbstractHandler {    @Override    public void handle(AbstractRequest request) {        System.out.println("Handler3 handler request :"+request.getRequestLevel());    }    @Override    public int getHandlerLevel() {        return 3;    }}/** *  具体请求者1 * @author newtrekWang * @email  wangjiaxing20160101@gmail.com * @time   2018/8/19  0:36 */public class ConcretRequest1 extends AbstractRequest {    /**     * 通过构造函数注入要处理的内容对象     *     * @param object 要处理的内容对象     */    public ConcretRequest1(Object object) {        super(object);    }    @Override    public int getRequestLevel() {        return 1;    }}** *  具体请求者2 * @author newtrekWang * @email  wangjiaxing20160101@gmail.com * @time   2018/8/19  0:36 */public class ConcretRequest2 extends AbstractRequest {    /**     * 通过构造函数注入要处理的内容对象     *     * @param object 要处理的内容对象     */    public ConcretRequest2(Object object) {        super(object);    }    @Override    public int getRequestLevel() {        return 2;    }}** *  具体请求者3 * @author newtrekWang * @email  wangjiaxing20160101@gmail.com * @time   2018/8/19  0:36 */public class ConcretRequest3 extends AbstractRequest {    /**     * 通过构造函数注入要处理的内容对象     *     * @param object 要处理的内容对象     */    public ConcretRequest3(Object object) {        super(object);    }    @Override    public int getRequestLevel() {        return 3;    }} public static void main(String[] args){        // 三个不同级别的请求        AbstractRequest request1 = new ConcretRequest1("request 1");        AbstractRequest  request2 = new ConcretRequest2("request 2");        AbstractRequest  request3 = new ConcretRequest3("request 3");        //三个不同级别的处理者        AbstractHandler handler1 = new ConcretHandler1();        AbstractHandler handler2 = new ConcretHandler2();        AbstractHandler handler3 = new ConcretHandler3();        // 设置处理者的链式关系        handler1.setNextHandler(handler2);        handler2.setNextHandler(handler3);        // 总是从链子的首端发起请求        handler1.handleRequest(request1);        handler1.handleRequest(request2);        handler1.handleRequest(request3);    }

输出结果：

Handler1 handler request :1Handler2 handler request :2Handler3 handler request :3

优点

对请求者和处理者关系解耦，提高代码的灵活性。

缺点

如果处理者太多，那么遍历必定会影响性能。

应用例子1 Android 的触摸事件传递与分发机制

应用例子2 利用有序广播实现责任链事件处理

Android种的BroastCast分为两种，一种时普通广播，另一种是有序广播。普通广播是异步的，发出时可以被所有的接收者收到。而有序广播是根据优先级一次传播的，直到有接收者将其终止或者所有接收者都不终止它。有序广播的这一特性与我们的责任链模式很相近，我们可以轻松地实现一种全局的责任链事件处理。

转载地址：http://ayuaa.baihongyu.com/

你可能感兴趣的文章