责任链模式 每个流程或事物处理 像一个链表结构处理。场景由 多层部门审批，问题分级处理等。下面体现的是 不同难度的问题由不同人进行解决。
设计模式，一定要敲代码理解

传递问题实体

/**
 * @author ggbond
 * @date 2024年04月10日 07:48
 */
public class Question {
    private  int level;

    private  String detail;

    public Question(int level, String detail) {
        this.level = level;
        this.detail = "这是难度系数为"+String.valueOf(level)+":"+detail;
    }

    public int getLevel() {
        return level;
    }

    public String getDetail() {
        return detail;
    }
}

责任链处理抽象

/**
 * @author ggbond
 * @date 2024年04月10日 07:53
 */
public abstract class Handler {
    final static int LEVEL1 = 1; // 题目难度为1
    final static int LEVEL2 = 2; // 题目难度为2
    final static int LEVEL3 = 3; // 题目难度为3
    // 能处理的级别
    private int level = 0;
    // 责任传递，下一个责任人是谁
    private Handler nextHandler;
    protected   String name;

    public Handler(int level) {
        this.level = level;
    }

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

    protected abstract void response(Question question);

    final void handle(Question question) {
        // 难度小递增处理
        if (question.getLevel() <= this.level) {
            this.response(question);
        } else {
            if (this.nextHandler != null) { // 有后续环节，请求传递
                this.nextHandler.handle(question); // 责任传递
            } else { // 无后续环节了，无法处理
                System.out.print("题目难度为" + question.getLevel() +" ");
                System.out.println("，这题目太难，没有人能可以处理。");
            }
        }
    }
}

责任链处理实体

public class Child extends  Handler{
    public Child(String name) {
        super(Handler.LEVEL1);
        this.name=name;
    }


    @Override
    protected void response(Question question) {
        System.out.print("我是"+name+" ");
        System.out.println("问题难度为1："+question.getDetail()+"已经被解决");
    }
}

public class Undergraduate extends  Handler{
    public Undergraduate(String name) {
        super(Handler.LEVEL2);
        this.name=name;
    }


    @Override
    protected void response(Question question) {
        System.out.print("我是"+name+" ");
        System.out.println("问题难度为2："+question.getDetail()+"已经被解决");
    }
}

public class Graduates extends  Handler{
    public Graduates(String name) {
        super(Handler.LEVEL3);
        this.name=name;
    }


    @Override
    protected void response(Question question) {
        System.out.print("我是"+name+" ");
        System.out.println("问题难度为3："+question.getDetail()+"已经被解决");
    }
}

测试与结果

/**
 * @author ggbond
 * @date 2024年04月10日 08:13
 */
public class Main {
    public static void main(String[] args) {
        Question q1=new Question(1,"1+1=");
        Question q2=new Question(2,"数据结构与算法");
        Question q3=new Question(3,"高等算法");
        Question q4=new Question(4,"LLM");
        ArrayList<Question> list=new ArrayList<>();
        list.add(q1);list.add(q2);list.add(q3); list.add(q4);

        Handler h1= new Child("儿童");
        Handler h2= new Undergraduate("大学生");
        Handler h3= new Graduates("研究生");

        h1.setNextHandler(h2);
        h2.setNextHandler(h3);

        for ( Question item: list) {
             h1.handle(item);
        }
    }
}

我是儿童 问题难度为1：这是难度系数为1:1+1=已经被解决
我是大学生 问题难度为2：这是难度系数为2:数据结构与算法已经被解决
我是研究生 问题难度为3：这是难度系数为3:高等算法已经被解决
题目难度为4 ，这题目太难，没有人能可以处理。

总结

调用外部无需关心责任链是如何处理的，如果要加处理对象也非常便携，体现单一职责与开闭原则。

代码下载

代码下载