责任链模式的定义: 使多个对象都有机会处理请求,从而避免了请求发送者和请求接受者之间的耦合关系,将这些对象连城一条链,并沿着这条链传递请求,直到有对象处理它为止。
责任链模式涉及的角色:
抽象处理者
抽象处理者一般采用抽象类,抽象类中有指向下一个抽象处理者的指针,并且定义在何种情况下会将请求转交到下一处理者,并且定义了请求处理的接口
public abstract class Handler {
private Handler nexthandler;
public void setNextHandler(Handler handler) {
this.nexthandler = handler;
}
public Response processRequest(Request req) {
Response res = null;
if(req.getReqLevel() == this.getRequestLevel()) {
res = new Response();
res.setRescode(-1);
res.setRes(this.handleRequest(req));
}else {
if (this.nexthandler != null) {
res = this.nexthandler.processRequest(req);
}else {
System.out.println("常规处理");
res = new Response();
res.setRescode(-1);
res.setRes("此请求未得到相应对象进行处理");
}
}
return res;
}
protected abstract int getRequestLevel();
protected abstract String handleRequest(Request req);
}
具体处理者
具体处理者主要完成对请求的处理
public class ConcreteHandller1 extends Handler {
@Override
protected int getRequestLevel() {
return HandleLevel.Min.getLevel();
}
@Override
protected String handleRequest(Request req) {
System.out.println("第一节点开始处理");
System.out.println(req.getVar());
System.out.println("第一节点处理结束");
return "res of " + req.toString();
}
}
2 ConcreteHandler2
public class ConcreteHandller2 extends Handler {
@Override
protected int getRequestLevel() {
return HandleLevel.Mid.getLevel();
}
@Override
protected String handleRequest(Request req) {
System.out.println("第二节点开始处理");
System.out.println(req.getVar());
System.out.println("第二节点处理结束");
return "res of " + req.toString();
}
}
public class ConcreteHandller3 extends Handler {
@Override
protected int getRequestLevel() {
return HandleLevel.Max.getLevel();
}
@Override
protected String handleRequest(Request req) {
System.out.println("第三节点开始处理");
System.out.println(req.getVar());
System.out.println("第三节点处理结束");
return "res of " + req.toString();
}
}
请求响应对象
public class Request {
private int reqLevel;
private String var;
public int getReqLevel() {
return reqLevel;
}
public void setReqLevel(int reqLevel) {
this.reqLevel = reqLevel;
}
public String getVar() {
return var;
}
public void setVar(String var) {
this.var = var;
}
}
public class Response {
private int rescode;
private String res;
public int getRescode() {
return rescode;
}
public void setRescode(int rescode) {
this.rescode = rescode;
}
public String getRes() {
return res;
}
public void setRes(String res) {
this.res = res;
}
}
处理等级枚举
public enum HandleLevel {
Min(1),Mid(5),Max(9);
private int level;
HandleLevel(int level){
this.level = level;
}
public int getLevel() {
return level;
}
}
客户端调用
在客户端的调用中,我们发现,具体处理对象连城了一条链。
public class Client {
public static void main(String[] args) {
Handler responseChain = new ConcreteHandller1();
Handler node2 = new ConcreteHandller2();
Handler node3 = new ConcreteHandller3();
node2.setNextHandler(node3);
responseChain.setNextHandler(node2);
Request req = new Request();
req.setReqLevel(HandleLevel.Max.getLevel());
req.setVar("req1");
Response res = responseChain.processRequest(req);
System.out.println(res.getRes());
}
}
责任链模式优点:
责任链模式的缺点:
责任链模式要尽量避免链中节点数量过多的情况,避免出现超长链的情况。