<其它设计模式介绍及案例源码下载 >

简介：责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

主要解决：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递。

优点： 1、简化了对象。使得对象不需要知道链的结构。 2、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。 3、增加新的请求处理类很方便。

缺点： 1、不能保证请求一定被接收。 2、系统性能将受到一定影响，而且在进行代码调试时不太方便。3、不容易观察运行时的特征，有碍于除错。

使用场景： 1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。

实现案例：定义一个抽象父类ExceptHandlerAbs作为职责链类的行为规范，并在该父类中定义匹配处理职责链对象方法handler（），以及给链类对象添加下一处理类对象方法addNextHandler（），具体匹配以及处理延迟到各子类中实现

例如下：

public abstract class ExceptHandlerAbs {

	ExceptHandlerAbs nextHandler;
	
	//向当前链对象中添加下一处理链对象
	public void addNextHandler(ExceptHandlerAbs nextHandler)  {
		this.nextHandler=nextHandler;
	}
	//顺序游走职责链中的所有异常处理类，直到有类处理为止
	public ExceptHandlerAbs handle( Object exhdler ) {
		ExceptHandlerAbs ret=this.judge(exhdler);
		if(ret ==null) {
			if(nextHandler!=null) {
				return nextHandler.handle(exhdler);
			} else 
				return null;
		} else {
			return (ExceptHandlerAbs)exhdler;
		}

	}
	//判断传入异常类型是否属于当前类型
	public abstract ExceptHandlerAbs judge(Object exhdler); 
	//异常处理
	public abstract void doAct();
}
public class ExceptHandler1 extends ExceptHandlerAbs {

	String name;

	public ExceptHandler1(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public ExceptHandler1() {
		super();
		// TODO Auto-generated constructor stub
	}

	@Override
	public ExceptHandler1 judge(Object exhdler) {
		if(exhdler instanceof ExceptHandler1) {
			return (ExceptHandler1)exhdler;
		} else 
			return null;
		
	}

	public void doAct() {
		System.out.println(this.getName()+"异常处理类捕获并处理");
		
	}

}
public class ExceptHandler2 extends ExceptHandlerAbs {

	String name;

	
	public ExceptHandler2() {
		super();
		// TODO Auto-generated constructor stub
	}

	public ExceptHandler2(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}
	@Override
	public ExceptHandler2 judge(Object exhdler) {
		if(exhdler instanceof ExceptHandler2) {
			return (ExceptHandler2)exhdler;
		} else
		return null;
	}

	public void doAct() {
		System.out.println(this.getName()+"异常处理类捕获并处理");
		
	}

}
public class ExceptHandler3 extends ExceptHandlerAbs {

	String name;

	
	public ExceptHandler3() {
		super();
		// TODO Auto-generated constructor stub
	}
	public ExceptHandler3(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}
	@Override
	public ExceptHandler3 judge(Object exhdler) {
		if(exhdler instanceof ExceptHandler3) {
			return (ExceptHandler3)exhdler;
		} else
		return null;
	}


	public void doAct() {
		System.out.println(this.getName()+"异常处理类捕获并处理");
		
	}

}
public class TestClass {
	//定义职责链中具体处理对象
	public static ExceptHandlerAbs setChain() {
		ExceptHandler1 eh1=new ExceptHandler1();
		ExceptHandler2 eh2=new ExceptHandler2();
		ExceptHandler3 eh3=new ExceptHandler3();
		eh2.addNextHandler(eh3);
		eh1.addNextHandler(eh2);
		return eh1;
		
	}
	public static void main(String[] args) {
		ExceptHandlerAbs eh=setChain();
		ExceptHandlerAbs ret=eh.handle(new ExceptHandler3("ExceptHandle3"));
		if(ret==null) 
			System.out.println("无法处理该类异常");
		else
			ret.doAct();
		//因为在链路中未添加Exception，所以会报“无法处理该类异常”
		ExceptHandlerAbs ret2=eh.handle(new Exception("Exception"));
		if(ret2==null) 
			System.out.println("无法处理该类异常");
		else
			ret2.doAct();

	}

}