职责链设计模式

职责链设计模式（Chain of Responsibility Design Pattern）是一种行为设计模式，使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。这些对象被链接成一条链，沿着这条链传递请求，直到有一个对象处理它为止。

关键角色

处理者（Handler）：定义一个处理请求的接口，并实现设置下一个处理者的方法。
具体处理者（Concrete Handler）：继承处理者接口，实现具体的处理请求的逻辑。如果不能处理请求，就传递给下一个处理者。
客户端（Client）：创建具体处理者的实例，并设置它们的链接关系，然后将请求发送给链上的第一个处理者。

实现步骤

定义处理者接口：
包含处理请求的方法和设置下一个处理者的方法。
实现具体处理者类：
继承处理者接口，实现具体的处理逻辑。
创建处理者链：
在客户端代码中，实例化具体处理者，并设置它们之间的链接关系。

示例代码

以下是一个简单的示例，实现职责链模式。

package com.example.study.pattern;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
class ApplicationTests {

    @Test
    void contextLoads() {

        // 创建具体处理者对象
        PurchaseHandler manager = new Manager();
        PurchaseHandler director = new Director();
        PurchaseHandler ceo = new CEO();

        // 设置处理者链
        manager.setNextHandler(director);
        director.setNextHandler(ceo);

        // 发送购买请求
        PurchaseRequest request1 = new PurchaseRequest(500);
        PurchaseRequest request2 = new PurchaseRequest(3000);
        PurchaseRequest request3 = new PurchaseRequest(10000);

        manager.processRequest(request1);
        manager.processRequest(request2);
        manager.processRequest(request3);

    }

    // 创建一个处理者接口
    interface PurchaseHandler {
        void processRequest(PurchaseRequest request);
        void setNextHandler(PurchaseHandler nextHandler);
    }

    // 创建具体处理者类
    class Manager implements PurchaseHandler {
        private PurchaseHandler nextHandler;

        @Override
        public void processRequest(PurchaseRequest request) {
            if (request.getAmount() <= 1000) {
                System.out.println("Manager approved the purchase request for " + request.getAmount());
            } else if (nextHandler != null) {
                nextHandler.processRequest(request);
            }
        }

        @Override
        public void setNextHandler(PurchaseHandler nextHandler) {
            this.nextHandler = nextHandler;
        }
    }

    class Director implements PurchaseHandler {
        private PurchaseHandler nextHandler;

        @Override
        public void processRequest(PurchaseRequest request) {
            if (request.getAmount() <= 5000) {
                System.out.println("Director approved the purchase request for " + request.getAmount());
            } else if (nextHandler != null) {
                nextHandler.processRequest(request);
            }
        }

        @Override
        public void setNextHandler(PurchaseHandler nextHandler) {
            this.nextHandler = nextHandler;
        }
    }

    class CEO implements PurchaseHandler {
        @Override
        public void processRequest(PurchaseRequest request) {
            System.out.println("CEO approved the purchase request for " + request.getAmount());
        }

        @Override
        public void setNextHandler(PurchaseHandler nextHandler) {
            // CEO是处理者链的最后一个处理者，无需设置下一个处理者
        }
    }

    // 创建购买请求类
    class PurchaseRequest {
        private double amount;

        public PurchaseRequest(double amount) {
            this.amount = amount;
        }

        public double getAmount() {
            return amount;
        }
    }
}