Java 设计模式系列(15) —— 责任链模式

责任链模式

责任链模式的定义：
使多个对象都有机会处理请求，从而避免了请求发送者和请求接受者之间的耦合关系，将这些对象连城一条链，并沿着这条链传递请求，直到有对象处理它为止。

责任链模式涉及的角色：

• Handler 抽象处理者：该角色对请求进行抽象，并定义一个方法以设定和返回对下一个处理者的引用
• Concrete Handler 具体处理者：该角色接到请求后，可以选择将请求处理掉，或者将请求传给下一个处理者

责任链模式的简单示例

抽象处理者

抽象处理者一般采用抽象类，抽象类中有指向下一个抽象处理者的指针，并且定义在何种情况下会将请求转交到下一处理者，并且定义了请求处理的接口

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);

}

具体处理者

具体处理者主要完成对请求的处理

1. ConcreteHandler1

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();
		
	}

}

3. ConcreteHandler3

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();
		
	}

}

请求响应对象

1. Request

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;
	}
	
}

2. Response

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());
	}

}

责任链模式的优缺点和应用场景

责任链模式优点：

• 将请求和处理分开，请求者不知道处理者是谁，处理者也不知道请求者的全貌
• 提高了系统的灵活性

责任链模式的缺点：

• 性能低下，任何一个请求都是从头到尾的执行
• 调试不方便

责任链模式要尽量避免链中节点数量过多的情况，避免出现超长链的情况。