一天一种设计模式之十-----职责链模式

一.职责链模式简介

1.  职责链模式属于行为型模式。

2. 使多个对象都有机会处理请求，从而避免了请求的发送者与接收者之间的耦合关系。将这些对象连城一条链，并沿着这条链传递该请求，直到有对象处理它为止。

3. 先看一段简单的代码

4. public void test(int i,Request request){
           if(i==1){
               Handler1.doHandle(request);
           }else if(i==2){
               Handler2.doHandle(request);
           }else if(i==3){
               //xxx
           }else if(i==4){
           }
           //......
       }

5. 上述代码存在如下硬伤

1. 代码臃肿：实际应用中的断定条件一般不是简单的判断1或者2，而是须要复杂的计算以及对数据库的查询。这样会有不少判断条件ifelse，代码可读性低。
   

2. 耦合度高

6. 职责链模式就是为了解决上述硬伤的。它的结构以下

1. 抽象处理类：抽象处理类中主要包含一个指向下一处理类的成员变量nextHandler和一个处理请求的方法handRequest，handRequest方法的主要思想是，若是知足处理条件，则由本类来进行处理类，若是不知足，则由nextHandler处理。

2. 具体处理类：具体处理类主要是对具体的处理逻辑进行判断和处理。

7. 职责链模式优势

1. 与if else 相比，它的耦合度要低，由于它把条件断定都分散到了各个处理类中，而且这些处理类的优先处理顺序能够随意设定。

8. 职责链模式缺点

1. 在找到正确的处理类以前，全部的断定条件都要被执行一遍，当职责链比较长时，性能问题比较严重。

9. 适用场景主要是替换ifelse。

10. 感受职责链模式比属于结构型模式的装饰模式只多了一个判断类，用于判断是否由本个handler处理仍是由下一个处理。（我的理解，欢迎指正）
    

11. 当心引发死循环。
    

二.测试代码

1. 测试代码以下：

2. public class ZhizelianTest {
       public static void main(String[] args) {
           Handler handler1=new ConcreteHandler1();
           Handler handler2=new ConcreteHandler2();
           Handler handler3=new ConcreteHandler3();
           handler1.setNextHandler(handler2);
           handler2.setNextHandler(handler3);
           Response response=handler1.handleRequest(new Request(new Level(4)));
           
       }
   }
   class Level{
       private int level =0;
       public Level(int level){
           this.level=level;
       }
       public boolean above(Level level){
           if(this.level>=level.level){
               return true;
           }
           return false;
       }
   }
   class Request{
       Level level;
       public Request(Level level){
           this.level=level;
       }
       public Level getLevel() {
           return level;
       }
   }
   class Response{
       
   }
   abstract class Handler{
       private Handler nextHandler;
       public final Response handleRequest(Request request){
           Response response=null;
           if(this.getHandlerLevel().above(request.getLevel())){
               response=this.response(request);
           }else {
               if(this.nextHandler!=null){
                   this.nextHandler.handleRequest(request);
               }else {
                   System.out.println("没有合适的处理器处理");
               }
           }
           return response;
       }
       public void setNextHandler(Handler nextHandler) {
           this.nextHandler = nextHandler;
       }
       protected abstract Level getHandlerLevel();
       public abstract Response response(Request request); 
   }
   class ConcreteHandler1 extends Handler{
   
       @Override
       protected Level getHandlerLevel() {
           return new Level(1);
       }
       @Override
       public Response response(Request request) {
           System.out.println("---请求由处理器1进行处理");
           return null;
       }
   
   }
   class ConcreteHandler2 extends Handler{
   
       @Override
       protected Level getHandlerLevel() {
           return new Level(3);
       }
       @Override
       public Response response(Request request) {
           System.out.println("---请求由处理器3进行处理");
           return null;
       }
   
   }
   class ConcreteHandler3 extends Handler{
   
       @Override
       protected Level getHandlerLevel() {
           return new Level(5);
       }
       @Override
       public Response response(Request request) {
           System.out.println("---请求由处理器5进行处理");
           return null;
       }
   
   }

3. 代码中level类是模拟的判断条件；request，response分别对应请求和相应；抽象类Handler中主要进行条件的判断，这里模拟一个处理等级，只有处理类的处理等级高于request的等级才进行处理。完成ifelse功能。