java之责任链模式

　　责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

举个例子：

公司中的请假流程，当我们发起流程是给我们的直接经理发送请教请求，而不是给我们的董事长发。

但是如果当我们请教的天数较大时，直接经理可能要向董事长申请，但这不是我们小喽啰关心的问题。

于是对于请假申请的处理用责任链模式就好处理了

我们可以定义一个抽象的处理类，里面有设置当前处理类的下个处理类和处理函数（可不实现），然后让我们的直接领导和董事长来继承抽象处理类，并设置我们的直接领导的下个处理类节点为董事长处理类，在处理函数中判断是谁的职责来处理，如果不是直接领导的职责，就要向上汇报，让下个处理类来处理，知道这个请求被处理了。

1、定义抽象处理类和实现类：

package ray.com.ray;
abstract class AbstractHandler{
	private AbstractHandler absNextHandler = null;
	public final void HandleRequest(AbstractRequest ARequest){
		if (GetHandleLavel() == ARequest.GetLavel()){
			this.Handle(ARequest);
		}else{
			if (null != absNextHandler){
				System.out.println("当前Handler " + GetHandleLavel() + "不能处理该Request");
				absNextHandler.HandleRequest(ARequest);
			}else{
				System.out.println("责任链中没有匹配的责任处理！");
				return;
			}
		}
	}
	public void SetNextHandler(AbstractHandler ANextHandler){
		this.absNextHandler = ANextHandler;
	}
	public abstract int GetHandleLavel();
	protected abstract void Handle(AbstractRequest ARequest);
}
class Handler1 extends AbstractHandler{
	@Override
	protected void Handle(AbstractRequest aRequest){
		System.out.println("是" + this.getClass().getName() + "的责任, 已处理。");
	}
	@Override
	public int GetHandleLavel(){
		return Lavels.LAVEL_1;
	}
}
class Handler2 extends AbstractHandler{
	@Override
	protected void Handle(AbstractRequest aRequest){
		System.out.println("是" + this.getClass().getName() + "的责任, 已处理。");
	}
	@Override
	public int GetHandleLavel(){
		return Lavels.LAVEL_2;
	}
}
class Handler3 extends AbstractHandler{
	@Override
	protected void Handle(AbstractRequest aRequest){
		System.out.println("是" + this.getClass().getName() + "的责任, 已处理。");
	}
	@Override
	public int GetHandleLavel(){
		return Lavels.LAVEL_3;
	}
}
public class Handler {
	
}

2、定义抽象处理请求和实现类：

package ray.com.ray;
/**
 * @author
 * @注释： 抽象请求类
 **/
abstract class AbstractRequest {
	private String Content = null;
	public AbstractRequest(String AContent){
		this.Content = AContent;
	}
	public String GetContent() {
		return this.Content;
	}
	public abstract int GetLavel();
}

/**
 * @author
 * @注释： 抽象实现类
 **/
class ImplRequest1 extends AbstractRequest{
	public ImplRequest1 (String AContent) {
		super(AContent);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int GetLavel(){
		return Lavels.LAVEL_1;
	}
}
class ImplRequest2 extends AbstractRequest{
	public ImplRequest2 (String AContent) {
		super(AContent);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int GetLavel(){
		return Lavels.LAVEL_2;
	}
}
class ImplRequest3 extends AbstractRequest{
	public ImplRequest3 (String AContent) {
		super(AContent);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int GetLavel(){
		return Lavels.LAVEL_3;
	}
}
public class Request {
	
}

3、用到的工具类：

package ray.com.ray;

public interface Lavels {
	public static final int LAVEL_1 = 1;
	public static final int LAVEL_2 = 2;
	public static final int LAVEL_3 = 3; 
}

4、定义测试类：

package ray.com.ray;
public class TestChainResponsibility {

	public static void main(String[] args) {
		//直接领导
		AbstractHandler directHandler = new Handler1();
		//经理
		AbstractHandler mgrHandler = new Handler2();
		//老板
		AbstractHandler bossHandler = new Handler3();
		
		directHandler.SetNextHandler(mgrHandler);
		mgrHandler.SetNextHandler(bossHandler);
		
		AbstractRequest absRequest1 = new ImplRequest1("Request1");
		AbstractRequest absRequest2 = new ImplRequest2("Request2");
		AbstractRequest absRequest3 = new ImplRequest3("Request3");
		
		//而我们申请处理时只需要通知给我们的直接领导即可，至于内部怎么实现，不关心
		directHandler.HandleRequest(absRequest1);
		directHandler.HandleRequest(absRequest2);
		directHandler.HandleRequest(absRequest3);
	}
}

5、输出结果：

是ray.com.ray.Handler1的责任, 已处理。
当前Handler 1不能处理该Request
是ray.com.ray.Handler2的责任, 已处理。
当前Handler 1不能处理该Request
当前Handler 2不能处理该Request
是ray.com.ray.Handler3的责任, 已处理。