设计模式之责任链模式

java程序的设计原则

6大原则：

单一职责：一个类和方法只做一件事。
开闭原则：对修改关闭，对扩展开发。
里氏替换原则：子类可扩展新方法，但不可修改父类已有方法（父类已提供了具体实现的方法）。
依赖倒置：依赖于抽象，而非具体实现，即面向接口编程（如方法参数，类属性使用接口声明，这样可接收任何子类）。
接口隔离：使用多个隔离的接口定义抽象，降低耦合。
最少知道/迪米特原则：降低类之间的依赖，聚合，组合等。

1：责任链设计模式

责任链设计模式是行为型设计模式的一种，用来控制对象通过链式的方式来执行，一般适用于完成某个功能需要若干个步骤的情况，比如计算报表数据，每一项数据的计算都是独立的，可以使用该设计模式，责任链中的每个类负责一个条目的计算，这样做的好处是，扩展性强（增加新的计算条目的话在责任链中增加一个新的类即可），修改的影响小（去除某个计算条目的话把对应的类删除即可）。

应用场景如下：

1：多个对象可以处理一个请求，但具体由哪个对象处理该请求在运行时自动确定。
2：可动态指定一组对象处理请求，或添加新的处理者。
3：需要在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求。

责任链设计模式角色如下：

抽象处理者角色(Handler)：定义处理请求的接口，包含一个具体处理请求的方法，和下一个处理请求Handler引用。
具体处理者角色（ConcreteHandler）：实现抽象处理者角色，实现处理请求方法，判断是否能够处理本次请求，如果是能够处理则处理，否则直接调用下一个Handler处理。
客户端角色（Client）：创建处理链，并向链头的Handler发送处理请求。

UML图如下：

客户端创建的处理链结构如下图：

接下来我们看下如何通过程序实现上述UML图。

1.1：抽象处理者角色

// 抽象处理者角色
abstract class Handler {
    private Handler next;

    public void setNext(Handler next) {
        this.next = next;
    }

    public Handler getNext() {
        return next;
    }

    // 处理请求的方法
    public abstract void handleRequest(String request);
}

1.2：2个具体处理者角色

// 具体处理者角色1
class ConcreteHandler1 extends Handler {

    public void handleRequest(String request) {
        System.out.println("处理者1号Handler处理请求: " + request);
        Handler next;
        if ((next = getNext()) != null) {
            next.handleRequest(request);
        } else {
            System.out.println("没有其他handler了，处理请求结束！");
        }
    }

}

public class ConcreteHandler2 extends Handler {
    @Override
    public void handleRequest(String request) {
        /*if (request.equals("one")) {
            System.out.println("具体处理者1负责处理该请求！");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(request);
            } else {
                System.out.println("没有人处理该请求！");
            }
        }*/
        System.out.println("处理者2号Handler处理请求: " + request);
        Handler next;
        if ((next = getNext()) != null) {
            next.handleRequest(request);
        } else {
            System.out.println("没有其他handler了，处理请求结束！");
        }
    }
}

1.3：客户端

public class ChainOfResponsibilityPattern {
    public static void main(String[] args) {
        // 组装责任链
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        handler1.setNext(handler2);
        // 提交请求
        handler1.handleRequest("dongshidaddy study design pattern");
    }
}

运行：

处理者1号Handler处理请求: dongshidaddy study design pattern
处理者2号Handler处理请求: dongshidaddy study design pattern
没有其他handler了，处理请求结束！

接下来我们再通过一个实际的例子看下纯的责任链设计模式如何使用。

2：请假谁来批？

分析：假如规定学生请假小于或等于 2 天，班主任可以批准；小于或等于 7 天，系主任可以批准；小于或等于 10 天，院长可以批准；其他情况不予批准；这个实例适合使用职责链模式实现。

首先，定义一个领导类（Leader），它是抽象处理者，包含了一个指向下一位领导的指针 next 和一个处理假条的抽象处理方法 handleRequest(int LeaveDays)；然后，定义班主任类（ClassAdviser）、系主任类（DepartmentHead）和院长类（Dean），它们是抽象处理者的子类，是具体处理者，必须根据自己的权力去实现父类的 handleRequest(int LeaveDays) 方法，如果无权处理就将假条交给下一位具体处理者，直到最后；客户类负责创建处理链，并将假条交给链头的具体处理者（班主任）。图 3 所示是其结构图。

2.1：领导类->Handler

// 抽象处理者：领导类
abstract class Leader {
    private Leader next;

    public void setNext(Leader next) {
        this.next = next;
    }

    public Leader getNext() {
        return next;
    }

    //处理请求的方法
    public abstract void handleRequest(int LeaveDays);
}

2.2：各级领导->ConcreteHandler

// 具体处理者1：班主任类
class ClassAdviser extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 2) {
            System.out.println("班主任批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

// 具体处理者2：系主任类
class DepartmentHead extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 7) {
            System.out.println("系主任批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

// 具体处理者3：院长类
class Dean extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 10) {
            System.out.println("院长批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

// 具体处理者4：教务处长类
class DeanOfStudies extends Leader {
    public void handleRequest(int LeaveDays) {
        if (LeaveDays <= 20) {
            System.out.println("教务处长批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

2.3：测试->Client

public class LeaveApprovalTest {
    public static void main(String[] args) {
        // 组装责任链
        Leader teacher1 = new ClassAdviser();
        Leader teacher2 = new DepartmentHead();
        Leader teacher3 = new Dean();
        Leader teacher4 = new DeanOfStudies();
        teacher1.setNext(teacher2);
        teacher2.setNext(teacher3);
        teacher3.setNext(teacher4);
        // 提交请求
        teacher1.handleRequest(1);
        teacher1.handleRequest(7);
        teacher1.handleRequest(90);
    }
}

运行：

班主任批准您请假1天。
系主任批准您请假7天。
请假天数太多，没有人批准该假条！

参考文章列表

责任链模式（职责链模式）详解 。