设计模式-责任链的应用

责任链介绍

责任链模式（Chain of Responsibility）又名 职责链模式，是一种行为设计模式，它允许你构建一个由多个对象组成的链，每个对象都有机会处理请求，或者将请求传递给链中的下一个对象。这种模式常用于处理请求的对象之间存在 层次关系 的情况。责任链模式的主要目的是解耦发送者和接收者，使多个对象都有机会处理请求，而不是将请求发送者与接收者硬编码在一起。

在责任链模式中，每个处理者都包含一个对下一个处理者的引用，形成一个链条。当请求进入链条时，从链条的头部开始逐个处理，直到找到能够处理该请求的对象为止。如果没有找到合适的处理者，请求可以被忽略或者采取默认的处理方式。

责任链的执行流程

1、定义一个抽象的Handler，可以是接口也可以是抽象类。
2、让每一个子类去实现这个抽象Handler，然后做具体的实现。
3、只要指定第一个Handler，然后第一个Handler处理完之后，在指向下一个Handler即可。这样就组成了一个双向链表的形式进行执行。

责任链的角色

抽象处理者（Handler）： 定义一个处理请求的接口，包含抽象处理方法并维护一个对下一个处理者的引用；
具体处理者（Concrete Handler）： 实现处理请求的接口，判断能否处理本次请求，如果能够处理则处理，否则将请求传递给下一个处理者。
客户端类（Client）： 创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

责任链的demo实现

创建责任链表

//handler上下文，维护链表和负责链表的执行
    class HandlerChainContext {
        HandlerChainContext next;// 持有下一个节点:单链表
        AbstractHandler handler;
        public HandlerChainContext(AbstractHandler handler) {
            this.handler = handler;
        }
        // 将节点持有下去
        void handler(Object arg0) {
            this.handler.doHandler(this, arg0);
        }
        // 继续执行下一个
        void runNext(Object arg0) {
            if (this.next != null) {
                this.next.handler(arg0);
            }
        }
    }

抽先类，保证后续的不同的实现：

    //处理器抽象类
    static abstract class AbstractHandler {
        abstract void doHandler(HandlerChainContext context, Object arg0);
    }

责任链的添加和删除：

class Pipeline {
    // 持有上下文(可以获得需要的数据,属性)
    public HandlerChainContext context = new HandlerChainContext(new AbstractHandler() {
        @Override
        void doHandler(HandlerChainContext context, Object arg0) {
            System.out.println("折扣前"+arg0);
            context.runNext(arg0);
        }
    });

    // 添加责任链
    public void addLast(AbstractHandler handler) {
        HandlerChainContext next = context;
        while (next.next != null) {
            next = next.next;
        }
        next.next = new HandlerChainContext(handler);
    }

    // 开始调用
    public void requestProcess(Object arg0) {
        context.handler(arg0);
    }
    //具体的处理器实现类（购物折扣1）
    static class Handler1 extends AbstractHandler {
        @Override
        void doHandler(HandlerChainContext handlerChainContext, Object arg0) {
            System.out.println("--首次购买打9折！");
            arg0 = new DecimalFormat("0.00").format(Double.valueOf(arg0.toString())*0.9);
            System.out.println("折扣后金额："+arg0);
            // 继续执行下一个
            handlerChainContext.runNext(arg0);
        }
    }
    //具体的处理器实现类（购物折扣2）
    static class Handler2 extends AbstractHandler {
        @Override
        void doHandler(HandlerChainContext handlerChainContext, Object arg0) {
            System.out.println("--满200减20！");
            if(Double.valueOf(arg0.toString()) >= 200){
                arg0 = Double.valueOf(arg0.toString())-20;
                // 继续执行下一个
                System.out.println("折扣后金额："+arg0);
                handlerChainContext.runNext(arg0);

            }else{
                System.out.println("不满足条件，折扣结束："+arg0);
            }
        }
    }
    //具体的处理器实现类（购物折扣3）
    static class Handler3 extends AbstractHandler {
        @Override
        void doHandler(HandlerChainContext handlerChainContext, Object arg0) {
            System.out.println("--第二件减10元！");
            arg0 = Double.valueOf(arg0.toString())-10;
            System.out.println("折扣后金额："+arg0);
            // 继续执行下一个
            handlerChainContext.runNext(arg0);
        }
    }
      public static void main(String[] args) {
        Pipeline p = new Pipeline();
        p.addLast(new Handler1());
        p.addLast(new Handler2());
        p.addLast(new Handler3());

        p.requestProcess("150");
    }

}

责任链模式的优缺点

优点：
1.松散耦合： 责任链模式使得请求发送者和接收者解耦，每个处理者仅需关心自己能否处理请求，而不需要知道整个处理流程的细节。
2.灵活性： 可以动态地改变处理者之间的关系和顺序，新增或删除处理者，以适应不同的需求和场景。
3.可扩展性： 容易添加新的处理者，无需修改现有的代码，符合开闭原则。
4.单一职责原则： 每个具体处理者只负责处理特定类型的请求，符合单一职责原则，使得代码更清晰和可维护。

缺点：
1.性能问题： 在责任链比较长的情况下，请求可能需要遍历整个链条才能找到合适的处理者，可能影响性能。
2.可能导致请求无法处理： 如果责任链没有被正确配置，或者某个请求没有得到处理，可能导致请求无法被处理。
3.不容易观察运行时的特征： 由于责任链的处理者是动态组合的，难以在运行时直观地观察到整个处理流程。
4.可能引入安全问题： 如果责任链的配置不当，某个处理者可能被滥用，导致安全问题。

使用场景

1.审批流程： 当一个请求需要经过多个处理者进行审批时，可以使用责任链模式。每个处理者负责不同级别的审批，直到找到合适的处理者为止。
2.日志记录： 在日志系统中，可以使用责任链模式处理不同级别的日志信息。每个处理者对应一个日志级别，形成责任链，便于灵活控制日志的输出。
3.事件处理： 当系统中存在多个对象负责处理不同类型的事件时，可以使用责任链模式。每个处理者处理特定类型的事件，形成事件处理链。
4.过滤器链： 在需要按顺序执行多个过滤操作的场景中，可以使用责任链模式。每个过滤器负责一个过滤操作，形成过滤器链。
5.异常处理： 在异常处理中，可以使用责任链模式处理不同类型的异常。每个处理者负责处理特定类型的异常，形成异常处理链。
6.请求转发： 在 Web 开发中，可以使用责任链模式实现请求的转发。每个处理者负责处理特定类型的请求，如果无法处理，则将请求转发给下一个处理者。
7.工作流程引擎： 责任链模式可以用于实现工作流程引擎，其中每个节点负责执行一部分工作，流程按照责任链顺序逐步执行。