行为型模式-责任链模式

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

核心思想

请求的发送者不需要指定具体的接收者。
请求沿着链条传递，每个处理者根据自身的逻辑决定是否处理请求。
如果某个处理者无法处理，则传递给下一个处理者。

结构

责任链模式通常包含以下角色：

• Handler（处理者接口/抽象类）：

• 定义处理请求的方法 handleRequest。
  持有对下一个处理者的引用。

• ConcreteHandler（具体处理者）：
  实现具体的请求处理逻辑。
  判断是否处理请求，如果不处理则将请求传递给下一个处理者。

• Client（客户端）：
  创建链条，并发送请求。

优缺点

• 优点
  降低耦合度： 请求的发送者和处理者解耦。
  灵活性： 可以通过调整链条顺序、动态添加/移除处理者来改变责任的分配。
  扩展性好： 增加新的处理者不会影响现有代码。
• 缺点
  链条过长： 如果链条过长，处理可能会影响性能。
  调试困难： 链条中的问题可能难以排查。

实现示例

// 抽象处理者
abstract class Handler {
    protected Handler next; // 下一个处理者

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

    // 处理请求的方法
    public abstract void handleRequest(int request);
}

// 具体处理者A
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("HandlerA 处理请求：" + request);
        } else if (next != null) {
            next.handleRequest(request); // 转发请求
        }
    }
}

// 具体处理者B
class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("HandlerB 处理请求：" + request);
        } else if (next != null) {
            next.handleRequest(request); // 转发请求
        }
    }
}

// 具体处理者C
class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 20) {
            System.out.println("HandlerC 处理请求：" + request);
        } else if (next != null) {
            next.handleRequest(request); // 转发请求
        }
    }
}

// 客户端
public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        // 创建处理者
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();

        // 构建链条 A -> B -> C
        handlerA.setNext(handlerB);
        handlerB.setNext(handlerC);

        // 测试请求
        int[] requests = {5, 14, 22, 8};
        for (int request : requests) {
            handlerA.handleRequest(request);
        }
    }
}

适用场景

• 多个对象可以处理同一请求： 请求的处理者动态决定。
• 需要动态指定处理顺序： 处理者之间可以灵活地增删改。
• 避免强耦合： 客户端和具体处理者解耦。

这种模式非常适合用于审批流程、日志处理、职责划分等场景。

原文地址：https://blog.csdn.net/qq_44407005/article/details/144138157

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！