设计模式学习与整理-责任链模式

介绍

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。对请求的发送者和接收者进行解耦。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

应用场景

（1）有许多对象可以处理用户的请求，希望程序在运行期间自动确定处理用户的那个对象。

（2）希望用户不必明确指定接受者的情况下，向多个接受者的一个提交请求。

（3）程序希望动态制定可处理用户请求的对象集合。

模式结构

（1）处理者（Handler）：处理者是一个接口，负责规定具体处理者处理请求的方法，以及具体处理者设置后继对象的方法。
（2）具体处理者（ConcreteHandler）：具体处理者是实现处理者接口的类的实例。具体处理者通过调用处理者接口规定的方法处理用户的请求，即在接到用户的请求后，处理者将调用接口规定的方法，在执行该方法的过程中，如果发现能处理用户的请求，就处理有关数据，否则就反馈无法处理的信息给用户，然后将用户的请求传递给自己的后继对象。

代码案例

这次是在多个城市根据姓名找人的例子，首先，创建处理者（Handler）：

public interface Handler {
    void findUserName(String userName);
    void setNextHandler(Handler handler);
}

创建具体处理者：

public class Suzhou implements Handler {

    private Handler nextHandler;

    private List<String> userNameList = new ArrayList<>();

    Suzhou() {
        userNameList.add("李华");
        userNameList.add("小明");
        userNameList.add("小刚");
    }

    @Override
    public void findUserName(String userName) {
        if (userNameList.contains(userName)) {
            System.out.println("苏州有这个人：" + userName );
        } else {
            System.out.println("苏州查无此人");
            if (nextHandler != null) {
                nextHandler.findUserName(userName);
            }
        }
    }

    @Override
    public void setNextHandler(Handler handler) {
        this.nextHandler = handler;
    }
}

public class Nanjing implements Handler {

    private Handler nextHandler;

    private List<String> userNameList = new ArrayList<>();

    Nanjing() {
        userNameList.add("Tony");
        userNameList.add("Lucy");
        userNameList.add("Dick");
    }

    @Override
    public void findUserName(String userName) {
        if (userNameList.contains(userName)) {
            System.out.println("南京有这个人：" + userName );
        } else {
            System.out.println("南京查无此人");
            if (nextHandler != null) {
                nextHandler.findUserName(userName);
            }
        }
    }

    @Override
    public void setNextHandler(Handler handler) {
        this.nextHandler = handler;
    }
}

public class Xuzhou implements Handler {

    private Handler nextHandler;

    private List<String> userNameList = new ArrayList<>();

    Xuzhou() {
        userNameList.add("Frank");
        userNameList.add("Lily");
        userNameList.add("翠花");
    }

    @Override
    public void findUserName(String userName) {
        if (userNameList.contains(userName)) {
            System.out.println("徐州有这个人：" + userName );
        } else {
            System.out.println("徐州查无此人");
            if (nextHandler != null) {
                nextHandler.findUserName(userName);
            }
        }
    }

    @Override
    public void setNextHandler(Handler handler) {
        this.nextHandler = handler;
    }

}

创建测试类：

public class ApplicationTest {

    private static Handler createChain() {
        Handler suzhou = new Suzhou();
        Handler nanjing = new Nanjing();
        Handler xuzhou = new Xuzhou();
        nanjing.setNextHandler(suzhou);
        suzhou.setNextHandler(xuzhou);
        return nanjing;
    }

    public static void main(String[] args) {
        Handler chain = createChain();
        chain.findUserName("李华");
        System.out.println("------------------");
        chain.findUserName("Lily");
    }
}

运行结果

优点

（1）责任链中的对象只和自己的后继是低耦合关系，和其他对象毫无关联，这使得编写处理者对象以及创建责任链变得非常容易。
（2）当在处理者中分配职责时，责任链给应用程序更多的灵活性。
（3）应用程序可以动态地增加、删除处理者或重新指派处理者的职责，可以动态地改变处理者之间的先后顺序。
（4）使用责任链的用户不必知道处理者的信息，用户不会知道到底是哪个对象处理了它的请求。

缺点

（1）代码调试变得不方便