设计模式（六）——责任链模式

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

类图

类图比较简单

模板

抽象处理者

package ResponseChain;

public abstract class Handler {

	private Handler nextHandler;//

	//设置下一个处理者是谁
	public void seNext(Handler handler){
		this.nextHandler=handler;
	}

	//每个处理者都有一个处理级别
	protected abstract Level getHandlerLevel();

	//每个处理者都必须实现处理任务
	protected abstract Response echo(Request request);

	public final Response handleMsg(Request request){
		Response response=null;
		if(this.getHandlerLevel().equals(request.getRequestLevel())){
			response=this.echo(request);
		}else{
			if(this.nextHandler!=null){
				response = this.nextHandler.handleMsg(request);
			}else{
				//没有合适的处理者,业务自行处理
			}
		}
		return response;
	}

}

抽象处理者有三个职责：

   1. 定义一个请求的处理方法handleMsg，唯一对外开放的方法；

   2. 定义一个链的编排方法setNext，设置下一个处理者；

   3. 定义具体的请求者必须实现的两个方法：

       3.1 定义自己的处理级别

       3.2 定义具体处理任务echo

具体实现类<举一例>

package ResponseChain;


public class ConcreteHandler1 extends Handler{

	@Override
	protected Level getHandlerLevel() {
		return Level.FIRST_LEVEL;
	}

	@Override
	protected Response echo(Request request) {

		return new Response("ConcreteHandler1");
	}
}

在处理者中涉及三个类：

    1. Level负责定义请求和处理级别；

    2. Request类负责封装请求；

    3. Response类负责封装结果；

这三个类需要根据业务进行实习。

Level

package ResponseChain;

public enum Level {

	FIRST_LEVEL,
	SECOND_LEVEL,
	THIRD_LEVEL;
}

Request

public class Request {

	private int level;
	public Request(int i){
		this.level=i;
	}

	//请求的等级
	public Level getRequestLevel(){
		if(1==level)
			return Level.FIRST_LEVEL;
		if(2==level)
			return Level.SECOND_LEVEL;
		else
			return Level.THIRD_LEVEL;
	}
}

Response

public class Response {

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

	private String content;

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	@Override
	public String toString() {
		return "我是~~ [content=" + content + "]";
	}
}

场景类

public class Client {

	public static void main(String[] args) {
		Handler handler1 = new ConcreteHandler1();
		Handler handler2 = new ConcreteHandler2();
		Handler handler3 = new ConcreteHandler3();

		handler1.seNext(handler2);
		handler2.seNext(handler3);

		Response res1 = handler1.handleMsg(new Request(1));
		Response res2 = handler1.handleMsg(new Request(2));
		Response res3 = handler1.handleMsg(new Request(3));
		System.out.println(res1);
		System.out.println(res2);
		System.out.println(res3);

	}
}

输出

我是~~ [content=ConcreteHandler1]
我是~~ [content=ConcreteHandler2]
我是~~ [content=ConcreteHandler3]

在实际应用中，一般会有一个封装类负责对责任链模式进行封装，也就是替代Client类，直接返回责任链中的第一个处理者，类似下面：

	public static Handler getConcreteHandler(){
		Handler handler1 = new ConcreteHandler1();
		Handler handler2 = new ConcreteHandler2();
		Handler handler3 = new ConcreteHandler3();

		handler1.seNext(handler2);
		handler2.seNext(handler3);
		return handler1;
	}

优缺点

优点：把请求和处理分开，请求者可以不需要知道是谁处理的，处理者可以不用知道请求的全貌（在J2EE的开发中，可以剥离出无状态Bean由责任链处理），两者解耦，提高系统灵活性；

缺点：性能问题：从头到尾遍历，若链比较长时性能较低，且调试不方便。

使用举例

   1.  一个请求（如银行客户存款货币），一个处理者（只处理人民币），随着业务增长（需处理美元、日元等），处理者数量和类型都增加，这时就可以在处理者后面建立一个链，只需要通过扩展实现类就可以很好地解决这些需求的变更。

  2. 业务用户有两种，VIP和普通，两者处理不同，信息也不同，这个时候就可以用责任链模式，统一传递到一个处理入口，这样无论哪种用户只需要传入相关参数即可，扩展即QQ的各种会员啊之类的~只需要添加设置级别、添加实现类就可以实现了。

代码源自设计模式之禅