作者：whisper

链接：http://proprogrammar.com:443/article/454

声明：请尊重原作者的劳动，如需转载请注明出处

　　行为型模式又可以分成以下四类：第一类：通过父类与子类的关系进行实现。第二类：两个类之间。第三类：类的状态。第四类：通过中间类

　　责任链模式属于第二类，两个类之间的关系

　　责任链即一项工作可能由多个实体中的一个完成，在工作未确定时，是不知道会由谁来完成的

　　下面来看一下代码

　　先看请求

package behavior.pattern.betweenclass.chainofresponsibility;

//抽象请求类  
public abstract class AbstractRequest {  
 private String content = null;  

 public AbstractRequest(String content) {  
     this.content = content;  
 }  

 public String getContent() {  
     return this.content;  
 }  

 // 获得请求的级别  
 public abstract int getRequestLevel();  
} 

package behavior.pattern.betweenclass.chainofresponsibility;

//具体请求类01  
public class Request01 extends AbstractRequest {  
 public Request01(String content) {  
     super(content);  
 }  

 @Override 
 public int getRequestLevel() {  
     return Levels.LEVEL_01;  
 }  
}  

package behavior.pattern.betweenclass.chainofresponsibility;

//具体请求类02  
public class Request02 extends AbstractRequest {  
 public Request02(String content) {  
     super(content);  
 }  

 @Override 
 public int getRequestLevel() {  
     return Levels.LEVEL_02;  
 }  
}

package behavior.pattern.betweenclass.chainofresponsibility;

//具体请求类03  
public class Request03 extends AbstractRequest {  
 public Request03(String content) {  
     super(content);  
 }  

 @Override 
 public int getRequestLevel() {  
     return Levels.LEVEL_03;  
 }  
} 

　　再看一下处理者

package behavior.pattern.betweenclass.chainofresponsibility;

//抽象处理者类，  
public abstract class AbstractHandler {  
 // 责任链的下一个节点，即处理者  
 private AbstractHandler nextHandler = null;  

 // 捕获具体请求并进行处理，或是将请求传递到责任链的下一级别  
 public final void handleRequest(AbstractRequest request) {  
     System.out.println("进入当前 处理者-0" + this.getHandlerLevel());
     // 若该请求与当前处理者的级别层次相对应，则由自己进行处理  
     if (this.getHandlerLevel() == request.getRequestLevel()) {  
         this.handle(request);  
     } else {  
         // 当前处理者不能胜任，则传递至职责链的下一节点  
         if (this.nextHandler != null) {  
             System.out.println("当前 处理者-0" + this.getHandlerLevel()  
                     + " 不足以处理 请求-0" + request.getRequestLevel());  
               
             // 这里使用了递归调用  
             this.nextHandler.handleRequest(request);  
             
         } else {  
             System.out.println("职责链上的所有处理者都不能胜任该请求...");  
         }  
     }
     System.out.println("离开当前 处理者-0" + this.getHandlerLevel());
 }  

 // 设置责任链中的下一个处理者  
 public void setNextHandler(AbstractHandler nextHandler) {  
     this.nextHandler = nextHandler;  
 }  

 // 获取当前处理者的级别  
 protected abstract int getHandlerLevel();  

 // 定义链中每个处理者具体的处理方式  
 protected abstract void handle(AbstractRequest request);  
}

package behavior.pattern.betweenclass.chainofresponsibility;

//具体处理者-01  
public class Handler01 extends AbstractHandler {  
 @Override 
 protected int getHandlerLevel() {  
     return Levels.LEVEL_01;  
 }  

 @Override 
 protected void handle(AbstractRequest request) {  
     System.out.println("处理者-01 处理 " + request.getContent());  
 }  
} 

package behavior.pattern.betweenclass.chainofresponsibility;

//具体处理者-02  
public class Handler02 extends AbstractHandler {  
 @Override 
 protected int getHandlerLevel() {  
     return Levels.LEVEL_02;  
 }  

 @Override 
 protected void handle(AbstractRequest request) {  
     System.out.println("处理者-02 处理 " + request.getContent());  
 }  
}

package behavior.pattern.betweenclass.chainofresponsibility;

//具体处理者-03  
public class Handler03 extends AbstractHandler {  
 @Override 
 protected int getHandlerLevel() {  
     return Levels.LEVEL_03;  
 }  

 @Override 
 protected void handle(AbstractRequest request) {  
     System.out.println("处理者-03 处理 " + request.getContent());  
 }  
}

package behavior.pattern.betweenclass.chainofresponsibility;

//全局变量，接口类型  
/**  
* 使用Java中的interface定义全局变量，可根据具体需要在   
* 具体的包中使用静态导入相关的全局变量，语法如下：   
*  import static package01.package02.*;  
*/ 
public interface Levels {  
 public static final int LEVEL_01 = 1;  
 public static final int LEVEL_02 = 2;  
 public static final int LEVEL_03 = 3;  
} 

　　测试代码

package behavior.pattern.betweenclass.chainofresponsibility;

//测试类  
public class Client {  
 public static void main(String[] args) {  
     // 创建指责链的所有节点  
     AbstractHandler handler01 = new Handler01();  
     AbstractHandler handler02 = new Handler02();  
     AbstractHandler handler03 = new Handler03();  

     // 进行链的组装，即头尾相连，一层套一层  
     handler01.setNextHandler(handler02);  
     handler02.setNextHandler(handler03);  

     // 创建请求并提交到指责链中进行处理  
     AbstractRequest request01 = new Request01("请求-01");  
     AbstractRequest request02 = new Request02("请求-02");  
     AbstractRequest request03 = new Request03("请求-03");  
       
     // 每次提交都是从链头开始遍历  
     handler01.handleRequest(request01);  
     handler01.handleRequest(request02);  
     handler01.handleRequest(request03);  
 }  
}

　　运行结果

亲爱的读者：有时间可以点赞评论一下