1，抽象处理者接口

定义抽象处理者（Handler）类：该类定义了处理请求的接口和一个指向下一个处理者的引用。通常会包含一个处理请求的方法。

package top.wangyq.design.responsibility;

/**
 * 责任链模式：抽象处理者接口
 * @author wangyongqiang
 */
public abstract class Handler {
    /**请求处理者父类对象，实现任意流程的编排的核心，即父类都是相同的，而子类的顺序并不会实际影响到什么*/
    protected Handler successor;

    /**定时常量对象*/
    protected static String requestA = "A";
    protected static String requestB = "B";
    protected static String requestC = "C";

    /**
     * 对抽象接口变量进行赋值
     * @param successor 抽象接口变量
     */
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    /**
     * 指定请求的详细实现方法，并针对在调用失败的时候，其下一任处理者。
     * @param request 请求表示
     */
    public abstract void handleRequest(String request);
}

2，定义具体处理者（ConcreteHandler）类

继承抽象处理者类，并实现其处理请求的方法。在具体处理者类中，可以根据业务需求判断是否能够处理请求，如果可以处理，则进行处理；如果不能处理，则将请求传递给下一个处理者。

(1)，ConcreteHandlerA

package top.wangyq.design.responsibility;

/**
 * 责任链模式：具体处理者类A
 * @author wangyongqiang
 */
public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        System.out.println("handleRequestA -> A方法被调用");

        // 在每一个实现方法中自己业务逻辑处理实现
        if (Handler.requestA.equals(request)) {
            System.out.println("ConcreteHandlerA 处理请求");
        } else if (successor != null) {
            // 以及父类中业务属性传递的变量也做了调用，并将当前的入参直接传递给下一个请求处理者
            successor.handleRequest(request);
        }
    }
}

(2)，ConcreteHandlerB

package top.wangyq.design.responsibility;

/**
 * 责任链模式：具体处理者类B
 * @author wangyongqiang
 */
public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        System.out.println("handleRequestB -> B方法被调用");

        if (Handler.requestB.equals(request)) {
            System.out.println("ConcreteHandlerB 处理请求");
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

(3)，ConcreteHandlerC

package top.wangyq.design.responsibility;

/**
 * 责任链模式：具体处理者类B
 * @author wangyongqiang
 */
public class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(String request) {
        System.out.println("handleRequestC -> C方法被调用");

        if (Handler.requestC.equals(request)) {
            System.out.println("ConcreteHandlerC 处理请求");
        } else if (successor != null) {
            // 判断是否还存在下一级方法的调用
            successor.handleRequest(request);
        }
    }
}

3，创建处理者链、发起请求

1. 创建处理者链：在客户端或其他地方创建具体处理者对象，并通过设置其下一个处理者的引用，形成一个处理者链。
2. 发起请求：将请求传递给处理者链的头部（第一个处理者），处理者链会自动传递请求给下一个处理者，直至找到能够处理请求的处理者。

package top.wangyq.design.responsibility;

/**
 * 责任链模式：客户端代码
 * 在客户端代码中，我们创建了handlerA和handlerB两个具体处理者，
 * 并通过handlerB.setSuccessor(handlerA)将handlerA设置为handlerB的下一个处理者。
 * 这样，当handlerB无法处理请求时，它会将请求传递给handlerA。
 *
 * 同时，对于新增的handlerC，也是同样的逻辑，只不过handlerC是在handlerA无法处理请求的时候，才会根据入参做相应的处理。
 * 在实际应用中，可以根据具体的业务需求灵活地设置处理者链，以满足不同的请求处理逻辑。
 * @author wangyongqiang
 */
public class Client {

    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();
        // 通过对父类Handler变量的修改，实现业务流程的编排
        // 因为Handler类定义了successor属性，并提供了setSuccessor()方法来设置下一个处理者。
        // 所以在B调用失败时，会使用handlerA进行处理；
        handlerB.setSuccessor(handlerA);
        // 而在A调用失败的，又会使用handlerC进行处理。
        handlerA.setSuccessor(handlerC);

        // 传入不同的实际业务入参测试流程编排是否生效
        handlerB.handleRequest("A");
        System.out.println("====================分割线A========================");
        handlerB.handleRequest("B");
        System.out.println("====================分割线B========================");
        handlerB.handleRequest("C");
        System.out.println("====================分割线C========================");
        handlerB.handleRequest("D");
    }
}