Android中的设计模式之责任链模式

参考

• 《设计模式：可复用面向对象软件的基础 》5.1 Chain of responsibility 职责链 对象行为型模式
• 《Android源码设计模式解析与实战》第9章 使编程更有灵活性--责任链模式

意图

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

适用场景

• 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
• 想在不明确指定接收者的情况下，像多个对象中的一个提交一个请求。
• 可处理一个请求的对象集合应被动态指定。

结构

• Handler 抽象处理角色，声明一个请求处理的方法，并在其中保持一个对下一个处理节点Handler对象的引用。
• ConcreteHandler 具体处理者角色，对请求进行处理，如果不能处理则将该请求转发给下一个节点上的处理对象。

进一步抽象

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

代码实现

/**
 *  抽象处理类
 * @author newtrekWang
 * @email  [email protected]
 * @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  [email protected]
 * @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  [email protected]
 * @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  [email protected]
 * @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  [email protected]
 * @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  [email protected]
 * @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  [email protected]
 * @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  [email protected]
 * @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 :1
Handler2 handler request :2
Handler3 handler request :3

优点

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

缺点

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

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

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

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