java设计模式--责任链模式

对于一个业务的处理，当前的处理者要么处理完毕做出回应，要么把请求转发到后序环节处理（最后的都没处理不了，就不处理了呗）。这些处理者组成一个处理的链表，就是责任链模式。
示例：
有一个订单打折的审批流程，销售人员最多能打折97% 为1级，销售主管打折不能大于95% 为2级，打折大于95%要经理审批为3级。如果不使用责任链模式，那么就会有如下代码：

    public static void main(String[] args) {
        int level=1;
        if( level == 1 ){
            //销售员审批
        }else if( level == 2 ){
            //销售经理审批
        }else if( level == 3 ){
            //老板审批
        }else{
            //审批不过
        }
    }

代码中充满了if...else，还不美观。

责任链代码实现：

public class Test {

    /**
     * 处理类
     * 有三个级别，分别对应 销售，经理，老板
     */
    static abstract class Handler{

        //下一个处理者
        private Handler nextHandler;
        //当前的级别
        private int level;
        public Handler() {}
        public Handler(int level) {
            this.level = level;
        }

        public void setLevel(int level) {
            this.level = level;
        }
        public void setNextHandler(Handler nextHandler) {
            this.nextHandler = nextHandler;
        }

        //处理模板
        public void handler(Order order){
            if(order.getLevel() == this.level){
                this.approve();
            }else{
                if(this.nextHandler!=null){
                    nextHandler.handler(order);
                }else{
                    System.out.println("----不同意----");
                }
            }
        }
        //真正的处理，留给子类处理
        public abstract void approve();
    }

    static class SellerHandler extends Handler{
        public SellerHandler() {
            super(1);
        }
        @Override
        public void approve() {
            System.out.println("---销售审批---");
        }
    }

    static class ManagerHandler extends Handler{
        public ManagerHandler() {
            super(2);
        }

        @Override
        public void approve() {
            System.out.println("---经理审批---");
        }
    }

    static class BossHandler extends Handler{
        public BossHandler() {
            super(3);
        }

        @Override
        public void approve() {
            System.out.println("---老板审批---");
        }
    }

    /**
     * 订单业务
     */
    static class Order{
        private int level;
        public int getLevel() {
            return level;
        }
        public Order(int level) {
            this.level = level;
        }
    }

    public static void main(String[] args) {

        //订单等级
        Order order = new Order(4);

        //审批对象
        SellerHandler sellerHandler = new SellerHandler();
        ManagerHandler managerHandler = new ManagerHandler();
        BossHandler bossHandler = new BossHandler();

        //责任链
        sellerHandler.setNextHandler(managerHandler);
        managerHandler.setNextHandler(bossHandler);


        sellerHandler.handler(order);

    }
    
}

说明：

 1、处理类 Handler  ，有级别 level 属性，标识当前handler 能够处理的级别；Handler nextHandler 属性标识下一个处理的handler。还有一个模板方法handler 定义了审批的流程；approve 方法是审批方法是子类实现的，不同的处理者审批实现不同。
 2、接下来就是销售人员，销售经理，老板的审批实现。
 3、在测试时，要设置handler 的下一个处理者是谁，当前处理者不能处理的业务级别就流转到下一个处理者处理

类图：

enum 实现：

 责任链主要的是定义了处理者的链条，enum定义完了，就是自带顺序的，所有enum 定义完了就是一个责任链。

代码：

public class Test2 {


    interface Handler{
        boolean approve(int level);
    }

    enum  HandlerEnum implements Handler{
        Seller{
            int level=1;
            @Override
            public boolean approve(int level) {
                if(level==this.level){
                    System.out.println("Seller approve");
                    return true;
                }
                return false;
            }
        },
        Manager{
            int level=2;
            @Override
            public boolean approve(int level) {
                if(level==this.level){
                    System.out.println("Manager approve");
                    return true;
                }
                return false;
            }
        },
        Boss{
            int level=3;
            @Override
            public boolean approve(int level) {
                if(level==this.level){
                    System.out.println("Boss approve");
                    return true;
                }
                return false;
            }
        };

        /**
         * 审批
         * enum 默认是有序的，在遍历是就是声明enum的顺序
         * @param order
         * @return
         */
        public static boolean approve(Order order){
            for (HandlerEnum handlerEnum : HandlerEnum.values()) {
                if(handlerEnum.approve(order.level)){
                    return true;
                }
            }
            return false;
        }
    }

    /**
     * 订单业务
     */
    static class Order{
        private int level;
        public int getLevel() {
            return level;
        }
        public Order(int level) {
            this.level = level;
        }
    }

    public static void main(String[] args) {
        Order order = new Order(3);
        boolean approve = HandlerEnum.approve(order);
        System.out.println(approve==true?"审核通过":"审核不通过");
    }

优点：
无法预知来自外界折扣是属于哪种类型，每个类如果碰到它不能处理的折扣信息只要放弃就可以。
缺点：
扩展性差，一定要有一个统一的接口。
缺点是效率低，因为一个请求的完成可能要遍历到最后才可能完成。