java/android设计模式-行为模式之责任链模式

故名思义责任链模式中存在一个链式结构,链式结构：多外节点首尾相连，每个节点都可以被拆分再连接。具体什么是责任链模式呢。它使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，将这个对象连成一条链，并沿着这个条链传递该请求，直到有一个对象处理它为止。将每一个节点看作是一个对象，每一个对象拥有不同的处理逻辑，将一个请求从链式的首段发出，沿着链的路径传递给每一个节点对象，直到有对象处理这个请求为止。
责任链模式看起来可能比较陌生，可是我们在日常开发却经常碰到这种形式。

 public void handleSomething(int eventNum){
        switch (eventNum){
            case 1:
//do something
                break;
            case 2:
//do something
                break;
            case 3:
//do something
                break;
                default:
//do something
        }
    }

switch或者if-else这种就是责任链的裸体样式，是最简单的实现格式。当然这是个不恰当的例子，if-else嵌套太多，很可能你都看不懂你的代码。

举个粟子

下面给一个简单的例子：
这个例子很简单，一个抽象的Handler（处理者角色）和一个继承Handler的具体实现者ConcreteHandler。

类图

类图

代码

Handler类:

public abstract class Handler {
    /**
     * 持有下一个处理节点
     */
    protected Handler successor;

    /**
     * 这个方法是具体的请求处理方法，在这里为了简化而没有传入参数
     */
    public abstract void handleRequest();

    /**
     * 取出下一个节点的方法
     */
    public Handler getSuccessor() {
        return successor;
    }

    /**
     * 赋值下一个节点的方法
     */
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
}

ConcreteHandler 类：

public class ConcreteHandler extends Handler {
    @Override
    public void handleRequest() {
        /**
         * 判断是否有下个节点的责任处理对象
         * 如果有，就转发请求给下一个责任处理对象
         * 如果没有，则处理请求
         */
        if (getSuccessor() != null) {
            System.out.println("放过请求");
            getSuccessor().handleRequest();
        } else {
            System.out.println("处理请求");
        }
    }
}

Cilent类:

public class Client {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler();
        Handler handler2 = new ConcreteHandler();
        handler1.setSuccessor(handler2);
        handler1.handleRequest();
    }
}

Android/java 中应用责任链模式的场景

• 在android比较明显的就是事件分发过程中对事件的投递。严格说来，事件投递并不是严格的责任链模式，是责任链模式的变种实现。子 View 的 onTouchEvent 返回 true 代码消费该事件并不再传递，false 代表不消费并且传递到父 ViewGroup 去处理，这些树形结构的子 View 就是责任链上一个个处理对象；
• OrderedBroadcast，广播的每一个接收者按照优先级依次接受消息，如果处理完成之后可以调用 abortBroadcast 终止广播，不是自己处理的就可以传递给下一个处理者；
• try-catch语句，每一个 catch 根据 Exception 类型进行匹配，形成一个责任链，如果有一个 catch 语句与该 Exception 符合，这个 Exception 就交由给它进行处理，之后所有 catch 语句都不会再次执行。

再来看看具体的粟子

如果一个程序员一个月连续加班，这个月算下来可以调休5天。然后这个coder写了调休申请给项目经理，可项目经理有点方了，他只能审批调休一天的，然后项目经理把你的申请交给部门经理，部门经理一看也没法，公司规则多，他只能审批多超过三天的，只能让总经理过目了。
那看看具体代码。

//这个是leader的抽象类
public abstract class Leader {
    private Leader successor;
    private int hoildayNum;
    private String position;

    public void setPosition(String position) {
        this.position = position;
    }

    public String getPosition() {
        return position;
    }

    public Leader(int hoildayNum) {
        this.hoildayNum = hoildayNum;
    }

    public abstract void reply(Worker worker);

    public void handleRequest(Worker worker) {
        if (worker.getHolidayNum() <= hoildayNum) {
            reply(worker);
        } else {
            if (null != successor) {
                successor.handleRequest(worker);
            } else {
                System.out.println(position + "拒绝了你的请求");
            }
        }
    }

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

/**
 * 项目经理处理类
 */
public class ProjectDirector extends Leader {

    public ProjectDirector(int hoildayNum) {
        super(hoildayNum);
        setPosition("项目经理");
    }

    @Override
    public void reply(Worker worker) {
        System.out.println(getPosition() + "已通过你的请求");
    }
}

/**
 * 部门经理处理类
 */
public class DepartmentManager extends Leader {
 public DepartmentManager(int hoildayNum) {
        super(hoildayNum);
        setPosition("部门经理");
    }

    @Override
    public void reply(Worker worker) {
        System.out.println(getPosition() + "已通过你的请求");
    }}

/**
 * 总经理处理类
 */
public class GeneralManager extends Leader {

    public GeneralManager(int hoildayNum) {
        super(hoildayNum);
        setPosition("总经理");
    }

    @Override
    public void reply(Worker worker) {
        System.out.println(getPosition() + "已通过请求");
    }
}

public class Cilent {
    public static void main(String[] args) {
        Worker worker = new Worker(6);

        Leader projectDir = new ProjectDirector(1);
        Leader departmentMan = new DepartmentManager(3);
        Leader generalMan = new GeneralManager(10);
        projectDir.setSuccessor(departmentMan);
        departmentMan.setSuccessor(generalMan);

        projectDir.handleRequest(worker);
    }
}

这样我们就把请求者与处理者优雅的解耦。

纯与不纯的责任链模式

很多资料中会介绍纯和不纯的责任链模式，在标准的责任链模式中，责任链上的一个节点只允许有两个行为：处理或者推给下个节点处理，而不允许处理完之后又推给下个节点，前者被很多资料称为纯的责任链模式，而后者被称为不纯的责任链模式。其实在实际的系统里，纯的责任链很难找到。如果坚持责任链不纯便不是责任链模式，那么责任链模式便不会有太大意义了。