通知 网站从因情语写改为晴雨,这个网站的模板也从calmlog_ex改为 whimurmur

行为型模式-责任链模式

5004人浏览 / 0人评论 / | 作者:因情语写  | 分类: 设计模式与算法  | 标签: 设计模式与算法  | 

作者:因情语写

链接:https://www.proprogrammar.com/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);  
 }  
}

  运行结果


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

点赞(0) 打赏

全部评论

还没有评论!
广告位-帮帮忙点下广告