责任链

概念：

多个事件串联成一个事件流，每个请求都会在整个事件流中流转，请求A在事件1中被处理，处理完毕后可能转向事件2或者事件3，以此类推。

自己想了一个场景：

一个新的学期，同学需要先去缴费入学，然后老师上课，遵守各种纪律，最后放假。其中在学校里的各个岗位都有不同的人，缴费对应的是会计，上课是老师，检查你纪律的可能是负责纪检的老师，那么可以将责任链分为：Accountant(会计)、Teacher(老师)、Inspector（检查员）。

抽象为如下的类：

public abstract class Handler {

	/**
	 * 后续的处理对象
	 */
	protected Handler successor;
	
	/**
	 * 具体的逻辑处理方法
	 */
	public abstract void handleRequest();
	
	/**
     * 取值方法
     */
    public Handler getSuccessor() {
        return successor;
    }
    
    /**
     * 赋值方法，设置后继的责任对象
     */
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
    
}

public class InspectorHandler extends Handler {

	@Override
	public void handleRequest() {
		
		System.out.println("检查学生是否在宿舍");
		
		/**
         * 判断是否有后继的责任对象
         * 如果有，就转发请求给后继的责任对象
         * 如果没有，则处理请求
         */
        if(getSuccessor() != null)
        {            
            getSuccessor().handleRequest();            
        }else
        {            
            System.out.println("任务结束"+getClass().getName());
        }

	}

}

public class TeacherHandler extends Handler {

	@Override
	public void handleRequest() {
		
		System.out.println("教书育人");
		
		if(getSuccessor() != null)
        {            
            getSuccessor().handleRequest();            
        }else
        {            
            System.out.println("任务结束"+getClass().getName());
        }

	}

}

public class AccountantHandler extends Handler {

	@Override
	public void handleRequest() {
		
		System.out.println("收书费");
		
		if(getSuccessor() != null)
        {            
            getSuccessor().handleRequest();            
        }else
        {            
            System.out.println("任务结束"+getClass().getName());
        }

	}

}

很明显，每个人都会在各自的handleRequest方法中做自己应该做的事情，然后通过setSuccessor传入继任者。

public class Client {

	/**
	 * @param args
	 * @throws IllegalAccessException 
	 * @throws InstantiationException 
	 */
	public static void main(String[] args) throws InstantiationException, IllegalAccessException {
				
		/**
		 * 可以改造为配置的类集合，属于基础类
		 */
		Map<String,String> handlerMap = new HashMap<String, String>();
		handlerMap.put("Inspector", "study.InspectorHandler");
		handlerMap.put("Teacher", "study.TeacherHandler");
		handlerMap.put("Accountant", "study.AccountantHandler");
		
		/**
		 * 流程配置，每一个#都单独是一个流程逻辑
		 */
		String semester = "Accountant#Teacher#Inspector#Teacher";
		
		String[] schoolFactors = semester.split("#");
		
		Class<?>[] responsibities = new Class<?>[schoolFactors.length];
		
		int i=0;
		for(String factor : schoolFactors){
			try {
				responsibities[i] = Class.forName(handlerMap.get(factor));
			} catch (ClassNotFoundException e) {
				System.out.println(factor + "类没找到");
				e.printStackTrace();
			}
			i++;
		}
		
		Handler[] handlers = new Handler[responsibities.length];
		for (int j = 0; j < responsibities.length; j++) {
			handlers[j] = (Handler) responsibities[j].newInstance();
			if(j>0){
				handlers[j-1].setSuccessor(handlers[j]);
			}
		}
		
		/**
		 * 从第一个开始处理
		 */
		handlers[0].handleRequest();

	}

}

这里抽象了一个工作类，为了简化，直接在类中就把类都罗列出来了，实际工作中可以把类的配置放在数据库或者配置文件中，用了反射能够很好的反应出当前的流程，只要变动semester中的值就可以按照一个流水中跑下去，很好的解耦和，每个类都不怎么关联。

最后运行的结果：

收书费
教书育人
检查学生是否在宿舍
教书育人
任务结束study.TeacherHandler

最后可以考虑一点的是因为代码中重重复复的判断了if(getSuccessor() != null),这里可以把它抽象出来，减少重复的代码，具体就不做了。