责任链模式

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

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

下面的例子是一个关于“开会，请假，出差”的例子，这三个业务处理器执行起来有顺序。开会的处理器可以执行开会，请假，出差。请假的处理器可以执行请假，出差。而出差的处理器只能处理出差，不能执行请假和开会。

/**
 *定义一个业务，该业务有三种类型，分别是开会，请假，出差。这三种业务类型有严格的次序，分别是开会->请假->出差，
 *或者开会—>出差，或者请假->出差，或者开会->请假。不能反向执行！
 */
public class Task {
	private String name;
	private Integer type;//1代表开会，2代表请假，3代表出差
	
	
	public String getName() {
		return name;
	}
	public Integer getType() {
		return type;
	}
	public void setType(Integer type) {
		this.type = type;
		if(type==1){
			this.name="开会";
		}
		
		if(type==2){
			this.name="请假";
		}
		
		if(type==3){
			this.name="出差";
		}
	}
	@Override
	public String toString() {
		return "Task [name=" + name + ", type=" + type + "]";
	}
	
}

/**
 *创建一个抽象的处理器
 */
abstract  class AbstractHandler {
	public static int MEET = 1;//开会
	public static int LEAVE = 2;//请假
	public static int TRAVEL = 3;//出差
	public int level;//处理器等级
	// 下一个处理器
    private AbstractHandler nextHandler;
    
    //设置下一个处理器
    public AbstractHandler setNextHandler(AbstractHandler handler){
    	this.nextHandler=handler;
    	return nextHandler;
    }
    
    public void doHandler(Task task){
    	
    	if(this.level<=task.getType()){
    		doTask(task);
    	}
    	
    	//如果存在下一个处理器，那么重新执行业务。
    	if(nextHandler!=null){
    		nextHandler.doHandler(task);
    	}
    }
    
    public String getHandlerName(){
    	if(this.level==MEET){
    		return "开会handler";
    	}else if(this.level==LEAVE){
    		return "请假handler";
    	}else if(this.level==TRAVEL){
    		return "出差handler";
    	}else{
    		return "不存在的handler";
    	}
    }
    
    //抽象的方法，因处理器而异
    abstract  void doTask(Task task);
}

/**
 *开会处理器
 */
class MeetHandler extends AbstractHandler{
	
	
	public MeetHandler(int level) {
		this.level=level;
	}

	@Override
	protected void doTask(Task task) {
		System.err.println("处理器是"+getHandlerName()+", 处理等级是"+level+", task是："+task);
		
	}
	
}

/**
 * 请假处理器
 */
class LeaveHandler extends AbstractHandler{
	
	
	public LeaveHandler(int level) {
		this.level=level;
	}

	@Override
	protected void doTask(Task task) {
		System.err.println("处理器是"+getHandlerName()+", 处理等级是"+level+", task是："+task);
		
	}
	
}

/**
 *出差处理器
 */
class TravelHandler extends AbstractHandler{
	
	public TravelHandler(int level) {
		this.level=level;
	}

	@Override
	protected void doTask(Task task) {
		System.err.println("处理器是"+getHandlerName()+", 处理等级是"+level+", task是："+task);
		
	}
	
}

主程序：

	public static void main(String[] args) {
		AbstractHandler handler=new MeetHandler(1);
		handler.setNextHandler(new LeaveHandler(2)).setNextHandler(new TravelHandler(3));
		
		Task task=new Task();
		task.setType(1);
		handler.doHandler(task);
	}

运行结果：

处理器是开会handler, 处理等级是1, task是：Task [name=开会, type=1]

主程序：

	public static void main(String[] args) {
		AbstractHandler handler=new MeetHandler(1);
		handler.setNextHandler(new LeaveHandler(2)).setNextHandler(new TravelHandler(3));
		
		Task task=new Task();
		task.setType(2);
		handler.doHandler(task);
	}

运行结果：

处理器是开会handler, 处理等级是1, task是：Task [name=请假, type=2]
处理器是请假handler, 处理等级是2, task是：Task [name=请假, type=2]

主程序：

	public static void main(String[] args) {
		AbstractHandler handler=new MeetHandler(1);
		handler.setNextHandler(new LeaveHandler(2)).setNextHandler(new TravelHandler(3));
		
		Task task=new Task();
		task.setType(3);
		handler.doHandler(task);
	}

运行结果：

处理器是开会handler, 处理等级是1, task是：Task [name=出差, type=3]
处理器是请假handler, 处理等级是2, task是：Task [name=出差, type=3]
处理器是出差handler, 处理等级是3, task是：Task [name=出差, type=3]

参考的文章： 菜鸟教程：责任链模式， coshaho的博客