设计模式-责任链模式

1.定义

针对一个请求，多个对象都有机会处理该请求，具体要根据条件来判断；将这些对象练成一个链，并沿着链传递请求，直到有对象处理这个请求，请求不再往下传递；责任链模式是一种行为类模式；

2.组成

类图比较简单，基本就是一个抽象类，类中包含一个自己得引用指向下一个处理的对象；

我们来看一段很常见的代码

public void test(int i, Request request){  
   if(i==1){  
       Handler1.response(request);  
   }else if(i == 2){  
       Handler2.response(request);  
   }else if(i == 3){  
       Handler3.response(request);  
   }else if(i == 4){  
       Handler4.response(request);  
   }else{  
       Handler5.response(request);  
   }  
}

这段代码是我们开发中很常见的，根据传递的请求，决定哪个类来处理当前的请求；这样写的问题是，太多if else了；这里演示的情况是比较简单的，就是i值的判断，在实际的开发中，情况要复杂的多，会显得代码很耦合，很臃肿；这种情况，可以用责任链模式来重构；将所有的判断的处理逻辑分散到具体的处理类中；

3.例子

首先，定义一个抽象Handler类，这个抽象类中定义个抽象的方法isHandle,所有的处理类要去实现，返回当前的处理类是否满足条件处理，如果处理的话调用具体的处理方法operate方法去处理；如果不处理的话，交给下个处理类去处理，调用nextHandler去处理；

public abstract class Handler {

    public abstract boolean isHandle(HandleRequest request);

    public abstract void operate(HandleRequest request);

    private Handler nextHandler;

    public void nextHandle(Handler handler) {
        this.nextHandler = handler;
    }

    public void doHandle(HandleRequest request) {
        if (isHandle(request)) {
            this.operate(request);
        } else if (this.nextHandler != null) {
            this.nextHandler.doHandle(request);
        } else {
            System.out.println("没有处理器可以处理这个请求");
        }
    }
}

HandleRequest用于模拟请求类；具体如下所示

public class HandleRequest {

    private int i;

    private String str;

    public HandleRequest(int i) {
        this.i = i;
    }

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }
}

然后分别定义三个处理类

public class Handler1 extends Handler {

    @Override
    public boolean isHandle(HandleRequest request) {
        return request.getI() == 1;
    }

    @Override
    public void operate(HandleRequest request) {
        System.out.println("Handler1 处理请求");
    }

}

public class Handler2 extends Handler {

    @Override
    public boolean isHandle(HandleRequest request) {
        return request.getI() == 2;
    }

    @Override
    public void operate(HandleRequest request) {
        System.out.println("Handler2 处理请求");
    }

}

public class Handler3 extends Handler {

    @Override
    public boolean isHandle(HandleRequest request) {
        return request.getI() == 3;
    }

    @Override
    public void operate(HandleRequest request) {
        System.out.println("Handler3 处理请求");
    }

}

分别模拟不同的对象来处理当前的请求，分别要实现判断当前对象是否处理请求，以及具体对请求进行操作的operate方法；最后是测试代码

public static void main(String[] args) {
        HandleRequest request = new HandleRequest(3);
        Handler handler1 = new Handler1();
        Handler handler2 = new Handler2();
        Handler handler3 = new Handler3();
        handler1.nextHandle(handler2);
        handler2.nextHandle(handler3);
        handler1.doHandle(request);
    }

这里主要要设置对象的nexHandle，下一个处理对象；

总结：责任链模式是优化版的if else；把所有的判断都放在具体的对象中去处理，当满足条件的时候，调用对象的操作方法，不满足条件的时候把请求向下传递，交给下面的对象继续处理请求；