Java设计模式-责任链模式

责任链模式

1.责任链模式含义

责任链模式，有的地方也会叫职责链模式。它指的是，为请求者和被请求者之间创建一条对象处理链路，避免请求发送者与接受者耦合在一起。

在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任

责任链模式里的责任，指的是类对象所承担的职责，当每一个对象对其下家引用，就会形成一条链路，那么这一条链上的所有的对象的职责也就串起来了，这样就形成了责任链，责任链的名字就是这样来的。

2.责任链代码示例

2.1Request类

Request类用于封装请求的相关内容

public class Request {
    private String requestType;

    private String requestContent;

    private int number;

    public String getRequestType() {
        return requestType;
    }

    public void setRequestType(String requestType) {
        this.requestType = requestType;
    }

    public String getRequestContent() {
        return requestContent;
    }

    public void setRequestContent(String requestContent) {
        this.requestContent = requestContent;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
}

2.2Manager类

Manager类是被请求类，用于处理请求

public class Manager {
    protected String name;

    public Manager(String name) {
        this.name = name;
    }

    public void getResult(String managerLevel, Request request){
        if ("经理".equals(managerLevel)) {
            if ("请假".equals(request.getRequestType()) && request.getNumber() <= 2){
                System.out.println(String.format("%s%s请假%d被批准", name, request.getRequestContent(), request.getNumber()));
            } else {
                System.out.println(String.format("%s%s请假%d我无权处理", name, request.getRequestContent(), request.getNumber()));
            }
        } else if ("总监".equals(managerLevel)) {
            if ("请假".equals(request.getRequestType()) && request.getNumber() <= 5){
                System.out.println(String.format("%s%s请假%d被批准", name, request.getRequestContent(), request.getNumber()));
            } else {
                System.out.println(String.format("%s%s请假%d我无权处理", name, request.getRequestContent(), request.getNumber()));
            }
        } else if ("总经理".equals(managerLevel)) {
            if ("请假".equals(request.getRequestType()) ){
                System.out.println(String.format("%s%s请假%d被批准", name, request.getRequestContent(), request.getNumber()));
            } else if ("加薪".equals(request.getRequestType()) && request.getNumber() <= 500){
                System.out.println(String.format("%s%s数量%d被批准", name, request.getRequestContent(), request.getNumber()));
            } else if ("加薪".equals(request.getRequestType()) && request.getNumber() > 500){
                System.out.println(String.format("%s%s数量%d再说吧", name, request.getRequestContent(), request.getNumber()));
            }
        }
    }
}

可以看到，Manager类的getResult方法里面，有大量的条件判断分支，这就导致了Manager这个类的职责太大了，违反了单一职责的原则，如果增加新的职位，比如总经理秘书，那么就要修改原代码，并对这个复杂的分支再加上新的条件分支，也违背了开闭原则。所以需要对这个类进行改造，而改造这个类，就使用责任链模式。

2.3Manager类重构

1.首先将Manager类改为抽象类，抽象类中设置一个Manage属性，并定义抽象的请求处理方法。

public abstract class Manager {
    protected String name;

    protected Manager superior;

    public Manager(String name) {
        this.name = name;
    }

    public void setSuperior(Manager superior) {
        this.superior = superior;
    }

    public abstract void requestApplications(Request request);
}

2.新建Manager的子类CommonManger，负责处理原Manager类中的第一个if条件分支

public class CommonManager extends Manager{
    public CommonManager(String name) {
        super(name);
    }

    @Override
    public void requestApplications(Request request) {
        if ("请假".equals(request.getRequestType()) && request.getNumber() <= 2){
            System.out.println(String.format("%s%s请假%d被批准", name, request.getRequestContent(), request.getNumber()));
        } else {
            if (superior != null) {
                superior.requestApplications(request);
            }
        }
    }
}

3.新建Manager的子类Majordomo类，负责处理原Manager类中的第二个if条件分支

public class Majordomo extends Manager{
    public Majordomo(String name) {
        super(name);
    }

    @Override
    public void requestApplications(Request request) {
        if ("请假".equals(request.getRequestType()) && request.getNumber() <= 5){
            System.out.println(String.format("%s%s请假%d被批准", name, request.getRequestContent(), request.getNumber()));
        } else {
            if (superior != null) {
                superior.requestApplications(request);
            }
        }
    }
}

4.新建Manager的子类GeneralManager类，负责处理原Manager类中的第三个if分支

public class GeneralManager extends Manager{
    public GeneralManager(String name) {
        super(name);
    }

    @Override
    public void requestApplications(Request request) {
        if ("请假".equals(request.getRequestType()) ){
            System.out.println(String.format("%s%s请假%d被批准", name, request.getRequestContent(), request.getNumber()));
        } else if ("加薪".equals(request.getRequestType()) && request.getNumber() <= 500){
            System.out.println(String.format("%s%s数量%d被批准", name, request.getRequestContent(), request.getNumber()));
        } else if ("加薪".equals(request.getRequestType()) && request.getNumber() > 500){
            System.out.println(String.format("%s%s数量%d再说吧", name, request.getRequestContent(), request.getNumber()));
        }
    }
}

5.测试类

public class MainApp {
    public static void main(String[] args) {
        CommonManager jingli = new CommonManager("经理");
        Majordomo zongjian = new Majordomo("总监");
        GeneralManager zjingli = new GeneralManager("总经理");

        jingli.setSuperior(zongjian);
        zongjian.setSuperior(zjingli);

        Request request = new Request();
        request.setRequestType("请假");
        request.setRequestContent("秋秋请假");
        request.setNumber(1);
        jingli.requestApplications(request);

        Request request2 = new Request();
        request2.setRequestType("请假");
        request2.setRequestContent("秋秋请假");
        request2.setNumber(4);
        jingli.requestApplications(request2);

        Request request3 = new Request();
        request3.setRequestType("加薪");
        request3.setRequestContent("秋秋要加薪");
        request3.setNumber(500);
        jingli.requestApplications(request3);

        Request request4 = new Request();
        request4.setRequestType("加薪");
        request4.setRequestContent("秋秋要加薪");
        request4.setNumber(10000);
        jingli.requestApplications(request4);

    }
}

运行结果

经理秋秋请假请假1被批准
总监秋秋请假请假4被批准
总经理秋秋要加薪数量500被批准
总经理秋秋要加薪数量10000再说吧

从Manager类的改造结果来看，原来Manager类的条件分支被均匀的分散到新Manager类的三个子类中，新的Manager的三个子类中又相继调用了条件分支的下一个子类，最终三个子类串联起来，形成了一个责任链。这样每个子类所承担的职责仅有一个if条件分支，职责单一，如果要新增新的条件分支，比如新增总经理秘书的分支，此时只需要新建一个Manager的子类，总经理秘书类，即可完成新分支的创建，不会修改原来的分支，符合开闭原则。

3.总结

责任链中最关键的就是，当客户提交一个请求的时候，请求是沿着链传递下去的，直到有一个对象来处理这个请求。请求者不用管哪个对象来处理，反正请求最终会被这个责任链给处理掉。

这就使得接收者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是责任链可以简化为对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需要保持它所有的候选接受者的引用，这就大大降低了耦合度。

由于链式结构是在客户端定义的，所以客户端可以随时地增加或修改处理一个请求的结构，增强了给对象指派职责的灵活性。

不过责任链处理也要考虑全面，防止某个请求一直到链的末端都没有被正确处理。

以上就是责任链模式的内容了，责任链这个名字听着高大上，但其实原理还是很简单的，不要被名字吓到。