Java中使用责任链模式

一、问题引入

    在生活中，我们会遇到填写调查问卷的情况，比如中国移动推送的通话质量问卷、京东的购物体验问卷等等，这些问卷在生成之前往往会有一套复杂的逻辑，比如题目的跳转设置、不同题目之间的互斥设置、多选题的选项之间互斥设置，以及对答案的通过性判断等等。在这些背后，某些业务的实现就可以使用到本文所介绍的责任链模式，本文也将以保存用户答题作为模拟实例引入责任链模式。

二、责任链设计模式理论知识

2.1，责任链概念

    顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为模式。

    它的意图的是：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。主要解决的问题是：职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

从概念中我们可以知道，责任链模式的核心思想是，按照设计好的有序链条逐个自动执行每一个任务。这种设计模式在分类上属于行为设计模式。

2.2，责任链类图

 2.3，链的实现方式

责任链模式中的链，可以使用单向链表、List集合实现。个人感觉，单项链表在每个节点中包含下个节点的引用，在使用起来会比较方便，而且稳定。

三、责任链设计模式的应用

保存答题的具体场景为：先保存答题者，然后每个答题者可以回答多个问卷，所以答题者保存完成之后需要保存回答的是哪个答卷，最后保用户的答案。

我们用respondent单词表示答题者，用questionnaire表示答卷，用answer表示答案，在下面的代码实例中可根据单词的直译表示类的作用

下面将用实际的代码例子演示如何实现责任链，且默认使用的是SpringBoot框架。

首先我们创建责任链的处理类：RespondChainHandler

/**
 * @Author Administrator
 * @Date 2021-02-17 15:30:01
 * @Version 1.0
 * @Description 责任链模式的具体执行handler
 */
public abstract class RespondChainHandler {
    /**
     * 节点排序字段
     * */
    private int order;

    /**
     * 下一个节点
     * */
    private RespondChainHandler next;

    /**
     * 执行具体任务
     *
     * @param chainEntity 任务数据
     */
    protected abstract void doHandler(ChainEntity chainEntity);


    public int getOrder() {
        return order;
    }

    public void setOrder(int order) {
        this.order = order;
    }

    public RespondChainHandler getNext() {
        return next;
    }

    public void setNext(RespondChainHandler next) {
        this.next = next;
    }
}

 然后创建责任链的核心类，即责任链调用类：RespondChain

/**
 * @Author Administrator
 * @Date 2021-02-17 15:29:39
 * @Version 1.0
 * @Description 责任链模式执行保存答题任务
 */
public class RespondChain {
    /**
     * 头节点
     * */
    private RespondChainHandler header;

    /**
     * 任务执行入口
     *
     * @param chainEntity 数据
     */
    public void proceed(ChainEntity chainEntity) {
        RespondChainHandler respond = header;
        while (respond != null) {
            respond.doHandler(chainEntity);
            respond = respond.getNext();
        }
    }

    /**
     * 添加具体任务handler到单向链表
     *
     * @param respond 任务handler
     * @param order   排序，越小越靠前
     */
    public void addFilter(RespondChainHandler respond, int order) {
        respond.setOrder(order);

        if (header == null) {
            header = respond;
            respond.setNext(null);
        } else if (respond.getOrder() <= header.getOrder()) {//如果当前插入的排序小于header的排序，则插入到链表的头
            //插入到链表的队首位置
            respond.setNext(header);
            header = respond;
        } else {//插入到中间某一个位置
            RespondChainHandler previous = header;
            RespondChainHandler current = previous.getNext();
            //寻找链表中符合当前order排序的位置
            while (current != null) {
                if (respond.getOrder() <= current.getOrder()) {
                    previous.setNext(respond);
                    respond.setNext(current);
                    break;
                } else {
                    previous = current;
                    current = previous.getNext();
                }
            }
            //队尾
            if (current == null) {
                respond.setNext(null);
                previous.setNext(respond);
            }
        }
    }
}

创建责任链处理的数据类：ChainEntity（这里名字起的不好，或许用DTO表示会更清晰）

/**
 * @Author Administrator
 * @Date 2021-02-17 15:32:36
 * @Version 1.0
 * @Description 责任链需要处理的数据
 */
@Data
public class ChainEntity {
    //示例字段
    private Integer id;
    //示例字段
    private String str1;
    //示例字段
    private String str2;
    //示例字段
    private List<Question> questions;

    @Data
    public static class Question {
        //示例字段
        private Long questionId;
        //示例字段
        private String questionName;
        //示例字段
        private List<Answer> answers;

        @Data
        public static class Answer{
            //示例字段
            private Long itemId;
            //示例字段
            private String itemContent;
        }
    }
}

处理类：RespondChainHandler是一个抽象类，具体的任务处理处理类要继承该类。RespondChainHandler处理类中有两个关键的地方：order和next，order用于加入单向链表时排序使用，next指向的是下一个节点。

调用类：RespondChain，header是单向链表的头节点，processd是任务执行入口，其中参数ChainEntity是外部传入的数据，作为责任链要处理的数据的载体。processd方法从header开始，先执行header节点里的doHandler任务，然后指向next节点，用while循环执行下去，直到没有更多的next节点。

下面我们创建具体的任务子类：

创建保存答题者任务子类：SaveRespondentClient

/**
 * @Author Administrator
 * @Date 2021-02-17 15:30:22
 * @Version 1.0
 * @Description 保存答题者任务
 */
@Component
public class SaveRespondentClient extends RespondChainHandler {

    @Override
    protected void doHandler(ChainEntity chainEntity) {
        System.out.println("保存答题者任务完成...");
    }
}

创建保存答卷任务子类：SaveQuestionnaireClient

/**
 * @Author Administrator
 * @Date 2021-02-17 15:30:45
 * @Version 1.0
 * @Description 保存答卷任务
 */
@Component
public class SaveQuestionnaireClient extends RespondChainHandler {

    @Override
    protected void doHandler(ChainEntity chainEntity) {
        System.out.println("保存答卷任务完成...");
    }
}

创建保存答案任务子类：SaveAnswerClient

/**
 * @Author Administrator
 * @Date 2021-02-17 15:31:00
 * @Version 1.0
 * @Description 保存答案任务
 */
@Component
public class SaveAnswerClient extends RespondChainHandler {

    @Override
    protected void doHandler(ChainEntity chainEntity) {
        System.out.println("保存答案任务完成...");
    }
}

这三个子类处理自己职责范围内的事情。

然后我们创建外部调用类，处理保存答题业务，外部调用类用Controller模拟。我们默认使用的是SpringBoot框架，所以可以不用new对象，使用IOC容器即可。如果不使用SpringBoot当然是可以的，不过要记得将类实例化。

/**
 * @Author Administrator
 * @Date 2021-02-17 15:37:08
 * @Version 1.0
 * @Description 责任链模式测试controller
 */
@RestController
@RequestMapping("/chain")
public class ChainController {
    //从IOC容器中取出处理类映射成Map，Map的key是处理类的类名，value是已实例化的子类
    @Resource
    private Map<String, RespondChainHandler> respondChainHandlerMap;

    @GetMapping(value = "save")
    public String save(){
        ChainEntity chainEntity =new ChainEntity();
        RespondChain respondChain = new RespondChain();
        respondChain.addFilter(respondChainHandlerMap.get("saveRespondentClient"), 1);
        respondChain.addFilter(respondChainHandlerMap.get("saveQuestionnaireClient"), 2);
        respondChain.addFilter(respondChainHandlerMap.get("saveAnswerClient"), 3);
        //开始执行
        respondChain.proceed(chainEntity);

        return "执行完成";
    }
}

我们启动，测试结果为：

  调用成功，任务按照我们的预期依次顺序执行。