JAVA设计模式---职责链模式

一、职责链应用场景

1.java web filter拦截器的实现，客户端发送的请求会沿着filter拦截器的链式结构传递，进行相应的处理。
2.Java 异常处理机制，可以观察java异常抛出的日志，可以看到异常的抛出是以链式结构层层抛出。
　　某场景下，员工向公司请假或者请求涨薪，如果员工先向经理申请，主管表示没有权限，需要总监批准。而员工再向总监请示，总监表示也没有权限，需要总经理授权。模拟这种情景的代码，如果写在一个类中会发现会出现很多的分支结构。而职责链的出现，能够改善这种情况下的代码，而且员工不需要一个一个向上级请示（员工只是提交申请，并不知道是谁处理他的申请），而是系统根据链式结构进行处理，如果当级管理者没有权限处理该事务，则会传递给其上级进行处理，从而实现了代码之间的低耦合。

二、职责链模式定义

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

三、职责链模式类图

  此类图来自程杰的《大话设计模式》。

四、简单实例

1. 抽象处理者类

package com.cn.itcast.ChainofResponsibility;

/**
 * Created by LJP on 2019/4/21.
 */
public abstract class Handler {
    /**
     * 具体执行者
     */
    protected Handler successor;

    /**
     * 设置继承者
     * @param successor
     */
    public void setSuccessor (Handler successor) {
        this.successor = successor;
    }

    /**
     * 抽象处理方法
     * @param request
     */
    public abstract void HandleRequest(int request);

}

2.实际处理者
  实际处理者有三个。

package com.cn.itcast.ChainofResponsibility;

/**
 * Created by LJP on 2019/4/21.
 */
public class ConcreteHandler1 extends Handler {

    /**
     *
     * @param request
     */
    @Override
    public void HandleRequest(int request) {
        if (request >= 0 && request < 10) {
            System.out.println(this.getClass().getSimpleName() + "---" + request);
        } else if (successor != null){
            successor.HandleRequest(request);
        }
    }
}

package com.cn.itcast.ChainofResponsibility;

/**
 * Created by LJP on 2019/4/21.
 */
public class ConcreteHandler2 extends Handler {

    @Override
    public void HandleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println(this.getClass().getSimpleName() + "---" + request);
        } else if (successor != null){
            successor.HandleRequest(request);
        }
    }
}

package com.cn.itcast.ChainofResponsibility;

/**
 * Created by LJP on 2019/4/21.
 */
public class ConcreteHandler3 extends Handler{

    @Override
    public void HandleRequest(int request) {
        if (request >= 20 && request < 30) {
            System.out.println(this.getClass().getSimpleName() + "---" + request);
        } else {
            System.out.println("该数字无法处理" + "---" + request);
        }
    }
}

3.测试代码

package com.cn.itcast.ChainofResponsibility;

/**
 * Created by LJP on 2019/4/21.
 */
public class test {
    public static void main(String[] args) {
        Handler h1 = new ConcreteHandler1();
        Handler h2 = new ConcreteHandler2();
        Handler h3 = new ConcreteHandler3();
        h1.setSuccessor(h2);
        h2.setSuccessor(h3);

        int[] requests = {2,3,5,11,20,1,35,28};
        for (int i = 0; i < requests.length; i++) {
            h1.HandleRequest(requests[i]);
        }
        System.out.println("执行结束");
    }
}

4.输出结果

ConcreteHandler1---2
ConcreteHandler1---3
ConcreteHandler1---5
ConcreteHandler2---11
ConcreteHandler3---20
ConcreteHandler1---1
该数字无法处理---35
ConcreteHandler3---28
执行结束

Process finished with exit code 0

  根据程序输出可知，请求会随着链的传递而进行处理。注意：在实际处理类中要判断sucessor是否为空，否则如果没有进行h2.setSuccessor（h3）的情况下会出现空指针异常。异常如下：

ConcreteHandler1---3
ConcreteHandler1---5
ConcreteHandler2---11
Exception in thread "main" java.lang.NullPointerException
	at com.cn.itcast.ChainofResponsibility.ConcreteHandler2.HandleRequest(ConcreteHandler2.java:13)
	at com.cn.itcast.ChainofResponsibility.ConcreteHandler1.HandleRequest(ConcreteHandler1.java:17)
	at com.cn.itcast.ChainofResponsibility.test.main(test.java:15)

Process finished with exit code 1

  通过异常信息也可以看出异常的抛出也是链式的结构。可以看到主程序中，客户端只要向h1提出申请，不需要关心是谁帮它处理了请求，这样降低了客户端与服务器之间的耦合度。

五、请假加薪代码实现

1.请求类

package com.cn.itcast.ChainofResponsibility1;

/**
 * 请求实体类，用于存储请求类型，请求内容，请求数量
 * Created by LJP on 2019/4/21.
 */
public class Request {
    private String requestType;

    private String requestContent;

    private Integer number;

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

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

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

    public String getRequestType() {
        return requestType;
    }

    public String getRequestContent() {
        return requestContent;
    }

    public Integer getNumber() {
        return number;
    }
}

2.管理者抽象类

package com.cn.itcast.ChainofResponsibility1;

/**
 * Created by LJP on 2019/4/21.
 */
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);
}

3.管理者具体类

package com.cn.itcast.ChainofResponsibility1;

/**
 * 经理
 * Created by LJP on 2019/4/21.
 */
public class CommonManager extends Manager {

    public CommonManager(String name) {
        super(name);
    }

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

package com.cn.itcast.ChainofResponsibility1;

/**
 * 总监类
 * Created by LJP on 2019/4/21.
 */
public class Majordomo extends Manager {

    public Majordomo (String name) {
        super(name);
    }

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

package com.cn.itcast.ChainofResponsibility1;

/**
 * 总经理类
 * Created by LJP on 2019/4/21.
 */
public class GeneralManager extends Manager{

    public GeneralManager (String name) {
        super(name);
    }

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

4.测试类

package com.cn.itcast.ChainofResponsibility1;

/**
 * 测试类
 * Created by LJP on 2019/4/21.
 */
public class test {
    public static void main(String[] args) {
        //创建管理者类
        Manager commonManager = new CommonManager("张经理");
        Manager majordomo = new Majordomo("王总监");
        Manager generalManager = new GeneralManager("马总经理");
        commonManager.setSuperior(majordomo);
        majordomo.setSuperior(generalManager);

        //创建请求
        Request request = new Request();
        request.setRequestType("请假");
        request.setRequestContent("小李请假");
        request.setNumber(1);
        commonManager.requestApplications(request);

        Request request1 = new Request();
        request1.setRequestType("请假");
        request1.setRequestContent("小李请假");
        request1.setNumber(4);
        commonManager.requestApplications(request1);

        Request request2 = new Request();
        request2.setRequestType("加薪");
        request2.setRequestContent("小李请求加薪");
        request2.setNumber(500);
        commonManager.requestApplications(request2);

        Request request3 = new Request();
        request3.setRequestType("加薪");
        request3.setRequestContent("小李请求加薪");
        request3.setNumber(1000);
        commonManager.requestApplications(request3);

        System.out.println("执行结束");
    }
}

5.测试结果

张经理---小李请假---1,被批准
王总监---小李请假---4,被批准
马总经理---小李请求加薪---500,被批准
马总经理---小李请求加薪---1000,再说吧
执行结束

Process finished with exit code 0

  客户端的申请都是通过经理进行发起，但具体的操作者对于客户端来说并不知道。注意在编写具体实现类一定要重写构造方法，这是因为管理者抽象类中有有参构造方法。

六、模式总结

  优点：1.降低应用程序之间耦合。2.将多种判定分散到各个处理类中，程序更加清晰，各类职责更加明确
  缺点：1.在找到正确的处理对象之前，所有条件判定都要执行一遍，当责任链过长，可能会影响性能问题。2.可能会造成某个请求不被处理，所以在程序设计时需要考虑全面。
  除了上述关于一个请求可能需要多级审批的情况下，另外，if-else判断较多的情况下也可考虑责任链模式。这里奉上github项目地址，仅供参考。