1. 说明

责任链模式（Chain of Responsibility）将请求的发送者和处理者分开，使得客户端无需关心具体由谁处理，实现了解耦。责任链模式应用场景广泛，如拦截器、过滤器等，如日常生活中，客户需要购买一件商品，销售人员只有5%折扣权限，如需要更高则需要转给自己的上级处理，依次类推，进而产生一个“链”。

实现步骤：

• 定义一个数据结构Handler负责处理请求，Handler中保存自己的下一个节点Handler，进而形成一个链表；
• 第一个处理请求的Handler，在某些情况下（或自己无法完成处理时），将请求传给下一个节点继续处理；
• 最后一个节点无后续节点，因此需要对请求做最终处理；

2. 示例

Handler抽象类，负责受理请求：

public abstract class AbstracetPriceHandler {
    /**
     * 直接后继，用于传递请求
     */
    protected AbstracetPriceHandler successor;

    protected void setSuccessor(AbstracetPriceHandler successor) {
        this.successor = successor;
    }

    public abstract void processDiscount(float discount);
}

销售人员，可以批准 5% 以内的折扣：

public class Sales extends AbstracetPriceHandler {
    @Override
    public void processDiscount(float discount) {
        if(discount <= 0.05) {
            System.out.format("%s 批准了折扣：%.4f%n", this.getClass().getSimpleName(), discount);
        } else {
            this.successor.processDiscount(discount);
        }
    }
}

销售小组长，可以批准 15% 的折扣：

public class Lead extends AbstracetPriceHandler {
    @Override
    public void processDiscount(float discount) {
        if(discount <= 0.15) {
            System.out.format("%s 批准了折扣：%.4f%n", this.getClass().getSimpleName(), discount);
        } else {
            this.successor.processDiscount(discount);
        }
    }
}

销售经理，可以批准 30% 以内的折扣：

public class Manager extends AbstracetPriceHandler {
    @Override
    public void processDiscount(float discount) {
        if(discount <= 0.3) {
            System.out.format("%s 批准了折扣：%.4f%n", this.getClass().getSimpleName(), discount);
        } else {
            this.successor.processDiscount(discount);
        }
    }
}

销售总监，可以批准 40% 的折扣，高于 40% 予以拒绝：

public class Director extends AbstracetPriceHandler {
    @Override
    public void processDiscount(float discount) {
        if(discount <= 0.4) {
            System.out.format("%s 批准了折扣：%.4f%n", this.getClass().getSimpleName(), discount);
        } else {
            System.out.format("%s 拒绝了折扣：%.4f%n", this.getClass().getSimpleName(), discount);
        }
    }
}

定制Handler链：

public class PriceHandlerFactory {
    public static AbstracetPriceHandler createPriceHandler() {
        AbstracetPriceHandler sales = new Sales();
        AbstracetPriceHandler lead = new Lead(); // 需求变化时，在中间环节新增节点，此时变化已有节点的上下游即可
        AbstracetPriceHandler manager = new Manager();
        AbstracetPriceHandler director = new Director();

        sales.setSuccessor(lead); // 修改
        lead.setSuccessor(manager); // 新增
        manager.setSuccessor(director);

        return sales;
    }
}

---

测试类：

public class CORTest {
    public static void main(String[] args) {
        AbstracetPriceHandler priceHandler = PriceHandlerFactory.createPriceHandler();

        for (int i = 0; i < 20; i++) {
            System.out.print(i + " : ");

            float discount = ThreadLocalRandom.current().nextFloat();
            priceHandler.processDiscount(discount);
        }
    }
}

测试结果：

0 : Director 拒绝了折扣：0.5752
1 : Director 拒绝了折扣：0.5990
2 : Lead 批准了折扣：0.0532
3 : Director 拒绝了折扣：0.7426
4 : Director 批准了折扣：0.3612
5 : Director 拒绝了折扣：0.7017
6 : Director 拒绝了折扣：0.4889
7 : Director 批准了折扣：0.3830
8 : Manager 批准了折扣：0.1825
9 : Director 批准了折扣：0.3966
10 : Sales 批准了折扣：0.0171
11 : Lead 批准了折扣：0.1206
12 : Director 批准了折扣：0.3498
13 : Director 拒绝了折扣：0.6031
14 : Sales 批准了折扣：0.0300
15 : Director 拒绝了折扣：0.7298
16 : Director 拒绝了折扣：0.8698
17 : Manager 批准了折扣：0.2091
18 : Director 拒绝了折扣：0.8249
19 : Director 拒绝了折扣：0.5923

3. 总结

责任链模式的实现，关键在于当前处理节点中，保存了下一个处理节点的指针，进而产生了链式处理，同时，不同的处理节点可灵活调整次序，降低了耦合性。