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签名

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