设计模式—责任链模式

定义

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

使用场景

多个对象可以处理同一请求，单具体由哪个对象处理则在运行时决定

在请求处理这不明确的情况下向多个对象提交一个请求

需要动态指定一组对象处理请求

关键点

一个抽象类，定义处理请求的方法，并持有下一节点对象的引用，对请求进行分发

多个具体的请求处理类，对请求进行具体处理，如果不能处理则将请求转发给下一个节点

实现

/**
 * 抽象请求类—定义抽象请求方法
 */
public abstract class AbstractHandler {

    protected AbstractHandler nextHandler;//下一请求处理对象节点引用

    /**
     * 处理请求
     *
     * @param action
     */
    public final void handleRequest(String action) {
        if (isHandleRequest(action)) {
            handle();
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(action);
            } else {
                Log.i(getClass().getSimpleName(), "it not handle request");
            }
        }
    }

    /**
     * 是否满足处理当前请求的条件
     */
    protected abstract boolean isHandleRequest(String action);

    /**
     * 每个请求处理者具体处理请求的方法
     */
    protected abstract void handle();
}

/**
 * 具体的请求处理者A
 */
public class HandlerA extends AbstractHandler {

    @Override
    protected boolean isHandleRequest(String action) {
        return false;
    }

    @Override
    protected void handle() {
        Log.i(super.getClass().getSimpleName(), getClass().getSimpleName() + "handler request");
    }
}

/**
 * 具体的请求处理者B
 */
public class HandlerB extends AbstractHandler {

    @Override
    protected boolean isHandleRequest(String action) {
        return false;
    }

    @Override
    protected void handle() {
        Log.i(super.getClass().getSimpleName(), getClass().getSimpleName() + "handler request");
    }
}

使用

HandlerA handlerA = new HandlerA();
HandlerB handlerB = new HandlerB();
handlerA.nextHandler = handlerB;
handlerA.handleRequest("A");

小结

优点

对请求者和处理者进行解耦、提高代码的灵活性

缺点

每一个请求处理都需要一个请求处理类与之对应