【设计模式】责任链模式

责任链模式（Chain of Responsibility Pattern）

责任链模式是一种行为设计模式，它允许你将请求沿着处理者链进行传递，直到其中一个处理者能够处理该请求为止。这种模式使得多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

一、责任链模式的定义

责任链模式的核心思想是将请求的处理者连成一条链，并沿着这条链传递请求，直到链中的某个处理者能够处理该请求为止。每个处理者都包含对下一个处理者的引用，如果当前处理者不能处理请求，它会将请求传递给下一个处理者。

二、责任链模式的结构

责任链模式主要包含以下几个角色：

• 抽象处理者（Handler）：定义了一个处理请求的接口，通常包含一个指向下一个处理者的引用。

• 具体处理者（ConcreteHandler）：实现抽象处理者接口的具体类，处理请求或将其传递给下一个处理者。

• 客户端（Client）：发起请求的对象，通常不知道请求会被传递到哪个具体的处理者。

三、责任链模式的实现

以下是一个简单的实现示例：

1.抽象处理者

public abstract class Handler {
    protected Handler nextHandler;

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

    public abstract void handleRequest(Request request);
}

2.具体处理者

public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getType() == RequestType.TYPE_A) {
            System.out.println("ConcreteHandlerA handles request: " + request.getDescription());
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getType() == RequestType.TYPE_B) {
            System.out.println("ConcreteHandlerB handles request: " + request.getDescription());
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

public class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getType() == RequestType.TYPE_C) {
            System.out.println("ConcreteHandlerC handles request: " + request.getDescription());
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

3.请求类

public class Request {
    private RequestType type;
    private String description;

    public Request(RequestType type, String description) {
        this.type = type;
        this.description = description;
    }

    public RequestType getType() {
        return type;
    }

    public String getDescription() {
        return description;
    }
}

public enum RequestType {
    TYPE_A,
    TYPE_B,
    TYPE_C
}

4.客户端代码

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

        handlerA.setNextHandler(handlerB);
        handlerB.setNextHandler(handlerC);

        // 创建请求
        Request requestA = new Request(RequestType.TYPE_A, "Request A");
        Request requestB = new Request(RequestType.TYPE_B, "Request B");
        Request requestC = new Request(RequestType.TYPE_C, "Request C");
        Request requestD = new Request(RequestType.TYPE_A, "Request D");

        // 处理请求
        handlerA.handleRequest(requestA);
        handlerA.handleRequest(requestB);
        handlerA.handleRequest(requestC);
        handlerA.handleRequest(requestD);
    }
}

四、运行效果

运行上述代码后，输出如下：

ConcreteHandlerA handles request: Request A
ConcreteHandlerB handles request: Request B
ConcreteHandlerC handles request: Request C
ConcreteHandlerA handles request: Request D

五、责任链模式的优点

• 降低耦合度：

• 请求的发送者和接收者之间没有直接的耦合关系，增加了系统的灵活性。

• 增强扩展性：

• 可以动态地添加或修改处理者的顺序，而无需修改客户端代码。

• 简化对象结构：

• 避免了复杂的条件语句，使代码更加清晰和易于维护。

六、责任链模式的缺点

• 性能问题：

• 如果链过长，可能会导致请求处理的延迟增加。

• 调试困难：

• 由于请求的处理路径可能不明确，调试时可能需要跟踪整个链。

• 无默认处理：

• 如果链中没有处理者能够处理请求，请求可能会被忽略，需要额外的机制来处理这种情况。

七、责任链模式的应用场景

• 多级审批流程：

• 在多级审批系统中，每个审批级别可以作为一个处理者，请求沿着审批链传递，直到某个级别批准或拒绝。

• 日志处理：

• 在日志系统中，不同级别的日志可以由不同的处理者处理，请求沿着日志链传递，直到某个处理者处理日志。

• 事件处理：

• 在事件驱动的系统中，事件可以沿着处理者链传递，直到某个处理者处理事件。

八、总结

责任链模式是一种非常实用的设计模式，通过将请求的处理者连成一条链，实现了请求的灵活传递和处理。通过合理使用责任链模式，可以降低系统的耦合度，增强系统的扩展性，同时避免使用复杂的条件语句。

// 责任链模式
    static class Solution_20250529213945_6080a9ac877d41a3a0812221e07a4754 {
        static public abstract class Handler {
            protected Handler nextHandler;

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

            public abstract void handleRequest(Request request);
        }

        static public class ConcreteHandlerA extends Handler {
            @Override
            public void handleRequest(Request request) {
                if (request.getType() == RequestType.TYPE_A) {
                    System.out.println("ConcreteHandlerA handles request: " + request.getDescription());
                } else if (nextHandler != null) {
                    nextHandler.handleRequest(request);
                }
            }
        }

        static public class ConcreteHandlerB extends Handler {
            @Override
            public void handleRequest(Request request) {
                if (request.getType() == RequestType.TYPE_B) {
                    System.out.println("ConcreteHandlerB handles request: " + request.getDescription());
                } else if (nextHandler != null) {
                    nextHandler.handleRequest(request);
                }
            }
        }

        static public class ConcreteHandlerC extends Handler {
            @Override
            public void handleRequest(Request request) {
                if (request.getType() == RequestType.TYPE_C) {
                    System.out.println("ConcreteHandlerC handles request: " + request.getDescription());
                } else if (nextHandler != null) {
                    nextHandler.handleRequest(request);
                }
            }
        }

        static public class Request {
            private RequestType type;
            private String description;

            public Request(RequestType type, String description) {
                this.type = type;
                this.description = description;
            }

            public RequestType getType() {
                return type;
            }

            public String getDescription() {
                return description;
            }
        }

        static public enum RequestType {
            TYPE_A,
            TYPE_B,
            TYPE_C
        }

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

            handlerA.setNextHandler(handlerB);
            handlerB.setNextHandler(handlerC);

            // 创建请求
            Request requestA = new Request(RequestType.TYPE_A, "Request A");
            Request requestB = new Request(RequestType.TYPE_B, "Request B");
            Request requestC = new Request(RequestType.TYPE_C, "Request C");
            Request requestD = new Request(RequestType.TYPE_A, "Request D");

            // 处理请求
            handlerA.handleRequest(requestA);
            handlerA.handleRequest(requestB);
            handlerA.handleRequest(requestC);
            handlerA.handleRequest(requestD);
        }
    }