责任链模式

责任链模式就是将请求和处理分开了， 定义一个责任链， 请求不需要关心是怎样处理的， 请求沿着责任链传递， 直到找到能处理该请求的handler为止。

先看看AbstractRequest

public abstract class Request {
	enum Type {
		NORMAL, SPECIAL
	}

	protected Type type;
	protected String desc;

	protected Request(Type type, String desc) {
		this.type = type;
		this.desc = desc;
	}
}

两个具体的Request

public class NormalRequest extends Request {

	protected NormalRequest(Type type, String desc) {
		super(type, desc);
	}
}

public class SpecialRequest extends Request {

	protected SpecialRequest(Type type, String desc) {
		super(type, desc);
	}
}

然后定义AbstractHandler

public abstract class Handler {
	private Handler nextHandler;

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

	public final void handle(Request request) {
		// 自己的责任
		if (request.type == this.getHandleType()) {
			this.execute(request);
		} else {
			// 交给下一个处理
			if (this.nextHandler != null) {
				this.nextHandler.handle(request);
			} else {
				System.out.println("No handler in the chain");
			}
		}
	}

	public abstract Type getHandleType();

	public abstract void execute(Request request);
}

再看看具体的两个handler: NormalHandler 和 SpecialHandler

public class NormalHandler extends Handler {

	@Override
	public void execute(Request request) {
		System.out.println("normal request has been handled");
	}

	@Override
	public Type getHandleType() {
		return Type.NORMAL;
	}
}

public class SpecialHandler extends Handler {

	@Override
	public void execute(Request request) {
		System.out.println("You may need some time to wait special request got handled");
	}

	@Override
	public Type getHandleType() {
		return Type.SPECIAL;
	}
}

好了， 现在看看是怎样处理Request的：

public class Client {

	public static void main(String[] args) {
		// 先定义两个Request
		Request normalRequest = new NormalRequest(Type.NORMAL, "normal request");
		Request specialRequest = new SpecialRequest(Type.SPECIAL,
				"special request");

		// 定义两个Handler
		Handler normalHandler = new NormalHandler();
		Handler specialHandler = new SpecialHandler();

		// 指定责任链的顺序
		normalHandler.setNextHandler(specialHandler);

		// 处理Request
		normalHandler.handle(normalRequest);
		normalHandler.handle(specialRequest);

		System.out.println();

		// 重新设置责任链顺序
		normalHandler.setNextHandler(null);
		specialHandler.setNextHandler(normalHandler);

		// 再处理
		specialHandler.handle(normalRequest);
		specialHandler.handle(specialRequest);
	}
}

好了， 看看执行结果：

引用

normal request has been handled
You may need some time to wait special request got handled

normal request has been handled
You may need some time to wait special request got handled