Design Patterns (9) - Detailed Explanation of Chain of Responsibility Patterns (Easy to Understand)

Definition of Chain of Responsibility Pattern

The Chain of Responsibility pattern is a design pattern. In the Chain of Responsibility pattern, many objects are connected to form a chain by each object's reference to its subordinate. Requests are passed along this chain until an object on the chain decides to handle the request. The client making the request does not know which object on the chain ultimately handles the request, which allows the system to dynamically reorganize and assign responsibilities without affecting the client.

Model:

• Handler: abstract handler

• ConcreteHander: Concrete handler
  

The following model code is as follows:

1. Design class

 

public class Level {
   private  int level=1;


   public  Level(int level){
       this.level=level;
   }

   public int getLevel() {
       return level;
   }
}

2. Request class

public class MyRequest {

   Level level;
   public  MyRequest(Level level){
       this.level=level;
   }
   public int  getLevel(){

       return level.getLevel();
   }

}

3.响应类

public class Response {
   private String message;
   public Response(String message) {
       Log.d("qzs","处理完成");
       this.message = message;
   }
   public String getMessage() {
       return message;
   }
}

4.抽象处理者类

public abstract class AbstractHandler  {
   //判断下一个处理者是谁
   private AbstractHandler nextHandler = null;

   public final Response handlerRequest(MyRequest request) {
       Response response = null;

       if(this.getHandlerLevel()==request.getLevel()) {
           response = this.response(request);
       }else {
           if(this.nextHandler != null) {
               Log.d("qzs","转到下一个处理者中...");
               response = this.nextHandler.handlerRequest(request);
           }else {
          Log.d("qzs","后面没有处理请求了...");
           }
       }
       return response;
   }
   public void setNextHandler(AbstractHandler handler) {
       nextHandler = handler;
   }
   //拿到等级
   protected abstract int getHandlerLevel();
   //响应
   protected abstract Response response(MyRequest request);
}

5.定义具体的处理者，这里就定义了两个：

public class ConcreteHandlerA extends AbstractHandler {
   @Override
   protected int getHandlerLevel() {
       return 0;
   }

   @Override
   protected Response response(MyRequest request) {
       Log.d("qzs","正在处理中“ConcreteHandlerA");
       return new Response("响应处理结果A") ;
   }
}


public class ConcreteHandlerB extends AbstractHandler {
   @Override
   protected int getHandlerLevel() {
       return 1;
   }

   @Override
   protected Response response(MyRequest request) {
       Log.d("qzs","正在处理中“ConcreteHandlerB");
       return new Response("响应处理结果B") ;
   }
}

6.调用：

前提是A到B组成了一个链，并且上面A的等级是0，B是1；发出的请求先经过A如果不能处理就交给B：

       AbstractHandler handler1=new ConcreteHandlerA();
       AbstractHandler handler2=new ConcreteHandlerB();
       //A到B组成一个链
       handler1.setNextHandler(handler2);
       Response response=handler1.handlerRequest(new MyRequest(new Level(1)));

上面代码我传送的等级是1，结果应该是由B解决的，下面是运行结果：

 

如果你传入的等级不在A和B的范围，运行结果如下：

说明没有适合的了。

实例说明

如果上面的定义不是很明白，下面直接实例说明一下。

例子：家里的小孩想出去玩，需要请示一下，这里规定一级请示爸爸，爸爸同意了就可以出去玩了；如果爸爸不在家就请示(二级)妈妈，妈妈同意了也可以出去玩；如果都不在家就不允许出去玩。

1.编写等级类，响应类，请求类，这些都没有变化可以直接去上面看就可以了。

2.抽象处理类：

public abstract class AbstractHandler  {
   //判断下一个处理者是谁
   private AbstractHandler nextHandler = null;

   public final Response handlerRequest(MyRequest request) {
       Response response = null;

       if(this.getHandlerLevel()==request.getLevel()) {
           response = this.response(request);
       }else {
           if(this.nextHandler != null) {
               Log.d("qzs","转到下一个处理者中...");
               response = this.nextHandler.handlerRequest(request);
           }else {
          Log.d("qzs","爸爸妈妈不在家...");
           }
       }
       return response;
   }
   public void setNextHandler(AbstractHandler handler) {
       nextHandler = handler;
   }
   //拿到等级
   protected abstract int getHandlerLevel();
   //响应
   protected abstract Response response(MyRequest request);
}

 

3.具体处理者，也就是爸爸和妈妈：

public class Father extends AbstractHandler {
   @Override
   protected int getHandlerLevel() {
       return 1;
   }

   @Override
   protected Response response(MyRequest request) {
       Log.d("qzs","正在处理中“Father”");
       Log.d("qzs","爸爸同意孩子出去玩了");
       return  new Response("") ;
   }
}

public class Mother extends  AbstractHandler{
   @Override
   protected int getHandlerLevel() {
       return 2;
   }

   @Override
   protected Response response(MyRequest request) {
       Log.d("qzs","正在处理中“Mother”");
       Log.d("qzs","妈妈同意孩子出去玩了");
       return new Response("") ;
   }
}

 

4.调用

如果传入的等级1：

       AbstractHandler handler1=new Father();
       AbstractHandler handler2=new Mother();
       //先问爸爸，爸爸不在家再问妈妈
       handler1.setNextHandler(handler2);
       Response response=handler1.handlerRequest(new MyRequest(new Level(1)));

运行结果：

传入其他的等级也可以，这个大家可以自己去试一试。

责任链模式的优缺点及其他

1.优点

• 耦合度降低，请求和处理是分开的

2.缺点

• 责任链太长或者每条链判断处理的时间太长会影响性能。特别是递归循环的时候

• 不一定被处理，每个职责类的职责很明确，这就需要对写默认的处理了

责任链模式重要的两点：分离职责，动态组合

本文部分定义参考了网上博文和网上信息...