Java内功修炼系列一责任链模式

在上一节的拦截器中提到，程序的设计者一般会用拦截器替替代动态代理，将动态代理的逻辑隐藏起来，而把拦截器接口提供给开发者，使开发者不需要关系动态代理的具体实现过程，但是有时候需要多个拦截器，而且拦截器之间会相互依赖，比如我们从公司的OA上提交一个请假单的时候，这个请假单会经过直接主管、部门经理、人力资源的层层审核，在请假被批准之前会被各级部门领导进行拦截，而且人力的审核依赖部门经理的审核结果，部门经理的审核又依赖直接主管的审核结果，这里的直接主管、部门经理和人力资源就像是三个拦截器，请假单这个对象在这一条拦截器链上进行传递，由此可以抽象地得出责任链模式的定义：

当一个对象在一条链上被多个拦截器拦截处理（拦截器也可以不处理）时，我们把这样的设计模式称为责任链模式，它用于一个对象在多个角色中传递的场景。－－－以上定义摘自《互联网轻量级框架整合开发》。

下面以员工请假为例，在请假单审核通过之前，需要被直接主管、部门经理和HR审核，这里面传递的对象是请假单，拦截器是三个领导。

第一步：创建审核请假单的拦截器接口

 /*
  * 定义一个审核请假单的拦截器接口
  */
 public interface ExamineLeaveInteceptor {
     //审批之前检查上一流程是否走完
     public boolean before(Object proxy,Object target,Method method,Object[] args);

     //如果上一个拦截器未处理完，则当前拦截器不予处理
     public void around(Object proxy,Object target,Method method,Object[] args);

     //审批之后签名
     public void after(Object proxy,Object target,Method method,Object[] args);
 }

第二步：创建三个拦截器类，实现上面定义的接口

 /*
  * 定义一个直接主管审核拦截器，实现审核请假单接口
  */
 public class DirectorExamineInterceptor implements ExamineLeaveInteceptor {
     public boolean before(Object proxy, Object target, Method method, Object[] args) {
         boolean result = true;
         System.out.println("主管同意之前检查信息是否填写完整");
         return result;
     }

     public void around(Object proxy, Object target, Method method, Object[] args) {
         System.out.println("打回重新填写");

     }

     public void after(Object proxy, Object target, Method method, Object[] args) {
         System.out.println("审核完毕，主管签名");
     }
 }

 /*
  * 部门经理审核拦截器
  */
 public class ManagerExamineInterceptor implements ExamineLeaveInteceptor {

     public boolean before(Object proxy, Object target, Method method, Object[] args) {
         boolean result = true;
         System.out.println("部门经理审核之前检查是否通过员工主管审核");
         return result;
     }

     public void around(Object proxy, Object target, Method method, Object[] args) {
         System.out.println("员工主管没通过，部门经理不予审核");

     }

     public void after(Object proxy, Object target, Method method, Object[] args) {
         System.out.println("审核完毕，经理签名");
     }

 }

 *
  * hr审核拦截器
  */
 public class HrExamineInterceptor implements ExamineLeaveInteceptor {

     public boolean before(Object proxy, Object target, Method method, Object[] args) {
         boolean result = true;
         System.out.println("hr审核之前检查部门经理是否通过");
         return result;
     }

     public void around(Object proxy, Object target, Method method, Object[] args) {
         System.out.println("部门经理没通过，hr不予审核");

     }

     public void after(Object proxy, Object target, Method method, Object[] args) {
         System.out.println("审核完毕，hr签名");
     }

 }

第三步：创建请假单类

 /*
  * 请假单类
  */
 public class LeaveFile {
     public String name;     //请假单名称
     public String userName; //请假人
     public int leavel;      //请假类型

     public LeaveFile(String name, String userName, int leavel) {
         this.name = name;
         this.userName = userName;
         this.leavel = leavel;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getUserName() {
         return userName;
     }

     public void setUserName(String userName) {
         this.userName = userName;
     }

     public int getLeavel() {
         return leavel;
     }

     public void setLeavel(int leavel) {
         this.leavel = leavel;
     }
 }

第四步：创建审核请假单接口及实现类

 /*
  * 审核请假单接口
  */
 public interface ExamineLeaveInterface {

     public void examine(LeaveFile file);
 }

 /*
  * 审核请假单实现类
  */
 public class ExamineLeaveInterfaceImpl implements ExamineLeaveInterface {
     /**
      * file:请假单
      */
     public void examine(LeaveFile file) {
         System.out.println("员工" + file.getUserName() + "的请假单审核完毕");
     }
 }

第五步：创建动态代理类，代理真是对象方法

 /*
  * 动态代理类，代理拦截器方法
  */
 public class DynamicProxyInterceptor implements InvocationHandler {
     private Object target;// 真实对象
     private String interceptorName;// 拦截器全限定名

     public DynamicProxyInterceptor(Object target, String interceptorName) {
         this.target = target;
         this.interceptorName = interceptorName;
     }

     // 返回代理对象
     public static Object bind(Object target, String interceptorName) {
         return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                 new DynamicProxyInterceptor(target, interceptorName));
     }

     // 动态生成拦截器，并执行方法
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         if (interceptorName == null) {
             return method.invoke(target, args);
         }

         Object result = null;
         ExamineLeaveInteceptor examineInterceptor = (ExamineLeaveInteceptor) Class.forName(interceptorName)
                 .newInstance();
         // 如果拦截器中的before方法执行成功，则执行真实对象的方法，否则不能通过
         if (examineInterceptor.before(proxy, target, method, args)) {
             result = method.invoke(target, args);
             examineInterceptor.after(proxy, target, method, args);
         } else {
             examineInterceptor.around(proxy, target, method, args);
         }
         return result;
     }

 }

第六步：申请请假

 /*
  * 用户提交请假单
  */
 public class AskForLeave {
     public static void main(String[] args) {
         LeaveFile file = new LeaveFile("请假单", "张三", 0);
         //获取直接主管动态代理对象
         ExamineLeaveInterface directProxy = (ExamineLeaveInterface) DynamicProxyInterceptor.bind(new ExamineLeaveInterfaceImpl(),"com.daily.dutychain.DirectorExamineInterceptor");
         //获取部门经理动态代理对象，依赖直接主管
         ExamineLeaveInterface managerProxy = (ExamineLeaveInterface) DynamicProxyInterceptor.bind(directProxy,"com.daily.dutychain.ManagerExamineInterceptor");
         //获取人力资源动态代理对象，依赖部门经理
         ExamineLeaveInterface hrProxy = (ExamineLeaveInterface) DynamicProxyInterceptor.bind(managerProxy,"com.daily.dutychain.HrExamineInterceptor");
         hrProxy.examine(file);

     }
 }

第七步：查看执行结果

 hr审核之前检查部门经理是否通过
 部门经理审核之前检查是否通过员工主管审核
 主管同意之前检查信息是否填写完整
 员工张三的请假单审核完毕
 审核完毕，主管签名
 审核完毕，经理签名
 审核完毕，hr签名

从结果可以看到，一个请假单需要经过不同层级的审核，最终才能通过，这就是责任链模式，每个拦截器负责自身人物的同时又要依赖上一级拦截器的处理结果。