设计模式-行为型模式-责任链模式

原创

小小小___ 2021-08-02 13:54:38 ©著作权

文章标签 职责链优先级封装责任链模式 if语句 文章分类 代码人生

©著作权归作者所有：来自51CTO博客作者小小小___的原创作品，请联系作者获取转载授权，否则将追究法律责任

设计模式-行为型模式-责任链模式

定义

将请求沿着链传递，然后直到对象处理即可。

UML图

设计模式-行为型模式-责任链模式_封装

代码

基本的责任链

public class Test{
public void test(int i, Request request){
if(i == 1){
Hander1.response(request);
}

if(i == 2){
Hander2.response(request);
}

if(i == 3){
Hander3.requese(request);
}
}
}

代码逻辑如上，只处理1，2,3情况，其余的情况都不处理。

责任链

// 对象
public 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;
else
return false;
}
}
// 将对象进行封装
public class Request{
Level level;
public Request(Level level){
this.level = level;
}
public Level getLevel(){
return level;
}
}
// 返回消息
public class Response{}
public 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 handler){
this.nextHandler = handler;
}
// 当前处理器
protected abstract Level getHandlerLvel();
// 进入处理器处理
public abstract Response response(Request request);
}
// 第一个处理器
public class ConcreteHandler1 extends Handler{
protected Level getHandlerLevel(){
return new Level(1);
}
public Response response(Request request){
System.out.println("处理1处理");
return null; // 下一个处理器为空
}
}
// 第二个处理器
public class ConcreteHandler2 extends Handler{
protected Level getHandlerLevel(){
return new Level(3);
}
public Response response(Request request){
System.out.println("处理1处理");
return null; // 下一个处理器为空
}
}
// 第三个处理器
public class ConcreteHandler3 extends Handler{
protected Level getHandlerLevel(){
return new Level(5);
}
public Response response(Request request){
System.out.println("处理1处理");
return null; // 下一个处理器为空
}
}
// 最后定义场景
public class Client{
public static void main(String[] args){
// 新建处理器
Handler handler1 = new ConcreteHandler1();
Handler handler2 = new ConcreteHandler2();
Handler handler3 = new ConcreteHandler3();

// 设置下一个处理器
// 处理器处理逻辑为先处理1，再处理2，再处理3
handler1.setNextHandler(handler2);
handler2.setNextHandler(handler3);

// 进行处理
Response response = handler1.handlerRequest(new Request(new Level(4)));
}
}