设计模式学习笔记——责任链模式

责任链模式

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

结构图

代码实现

请求类Request：

/**
 * 请求类
 *
 * @author xukai 2016年4月4日 下午1:13:24
 * 
 */
public class Request {

	Level level;

	public Request(Level level) {
		super();
		this.level = level;
	}

	public Level getLevel() {
		return level;
	}

}

请求等级类Level：决定请求由谁来处理

/**
 * 请求级别类
 *
 * @author xukai 2016年4月4日 下午1:20:51
 * 
 */
public class Level {

	private int level = 0;
	
	public Level(int level) {
		this.level = level;
	}
	
	/**
	 * 当前等级大于或等于	return true<br>
	 * @param level
	 * @return
	 */
	public boolean above(Level level){
		if(this.level >= level.level){
			return true;
		}
		return false;
	}
	
}

抽象处理类Handler：

/**
 * 定义一个处理请示的接口
 *
 * @author xukai 2016年4月4日 下午1:07:22
 * 
 */
public abstract class Handler {

	protected Handler nextHandler;

	/**
	 * 处理请求
	 * 
	 * @param request
	 * @return
	 */
	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;
	}

	/**
	 * 获取处理者处理等级
	 * 
	 * @return
	 */
	protected abstract Level getHandlerLevel();

	/**
	 * 处理请求，返回响应
	 * 
	 * @param request
	 * @return
	 */
	public abstract Response response(Request request);

	public void setNextHandler(Handler nextHandler) {
		this.nextHandler = nextHandler;
	}

}

具体处理请求类ConcreteHandler1：

/**
 * 具体处理者1
 *
 * @author xukai 2016年4月4日 下午1:26:31
 * 
 */
public class ConcreteHandler1 extends Handler {

	@Override
	protected Level getHandlerLevel() {
		return new Level(1);
	}

	@Override
	public Response response(Request request) {
		System.out.println("请求被处理者1处理");
		return null;
	}

}

ConcreteHandler2：

/**
 * 具体处理者2
 *
 * @author xukai 2016年4月4日 下午1:28:08
 * 
 */
public class ConcreteHandler2 extends Handler {

	@Override
	protected Level getHandlerLevel() {
		return new Level(3);
	}

	@Override
	public Response response(Request request) {
		System.out.println("请求被处理者2处理");
		return null;
	}

}

处理请求直到返回的响应Response：

/**
 * 响应类
 *
 * @author xukai 2016年4月4日 下午1:14:19
 * 
 */
public class Response {

}

客户端测试：

public class Client {

	@SuppressWarnings("unused")
	public static void main(String[] args) {

		Handler handler1 = new ConcreteHandler1();
		Handler handler2 = new ConcreteHandler2();
		Handler handler3 = new ConcreteHandler3();

		handler1.setNextHandler(handler2);
		handler2.setNextHandler(handler3);

		Response response = handler1.handleRequest(new Request(new Level(2)));
		response = handler1.handleRequest(new Request(new Level(4)));
		response = handler1.handleRequest(new Request(new Level(6)));

	}

}

控制台输出：

请求被处理者2处理
请求被处理者3处理
没有合适的处理者

总结

优点：责任链模式与if ...else相比，耦合性相对较低一些，条件判断都分散到了各个处理类中。

缺点：判定条件都要被执行一遍，当责任链较长时，性能问题严重。

*不要在链中出现循环引用的问题。