# 设计模式之责任链模式

站点：答源（https://www.dandroid.cn/）
原文：https://www.dandroid.cn/archives/12442
Canonical：https://www.dandroid.cn/archives/12442
作者：dandroid004
发布日期：2023-07-22
最后更新：2023-07-22 05:58
分类：教程
内容类型：post
说明：本页是原文的纯文本镜像，供大模型与检索器完整读取；不含导航、广告、付费框。引用请以上方「原文」链接为准。

## 正文

责任链模式

 责任链模式（Chain of Responsibility Pattern）

 责任链模式将链中每一个节点都看作一个对象，每个节点处理的请求均不同，且内部自动维护下一个节点对象。

 当一个请求从链式的首端发出时，会沿着责任链预设的路径依次传递到每一个节点对象，直至被链中的某个对象处理为止

优点：职责链模式使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系
1.2 两个角色

（1）抽象处理者（Handler）：定义处理请求的方法，并维护一个下一处理节点Handler对象的引用
（2）具体处理者（ConcreteHandler）：对请求进行处理，如果不感兴趣，则进行转发
2. 示例

用户的请求传递，直到可以解决这个请求为止

image.png

public abstract class AbstractHandler {

 protected AbstractHandler successor;
 /**
 * 设置继任者
 */
 public void setSuccessor(AbstractHandler successor) {
 this.successor = successor;
 }

 protected abstract void doHandle(String request);
}

public class ConcreteHandlerA extends AbstractHandler {
 @Override
 protected void doHandle(String request) {
 if (request.startsWith("handlerA")) {
 System.out.println("ConcreteHandlerA execute: " + request);
 } else {
 // 请求向下传递
 successor.doHandle(request);
 }
 }
}

public class ConcreteHandlerB extends AbstractHandler {
 @Override
 public void doHandle(String request) {
 if (request.startsWith("handlerB")) {
 System.out.println("ConcreteHandlerB execute: " + request);
 } else {
 successor.doHandle(request);
 }
 }
}

public class ConcreteHandlerC extends AbstractHandler {
 @Override
 protected void doHandle(String request) {
 if (request.startsWith("handlerC")) {
 System.out.println("ConcreteHandlerC execute: " + request);
 } else {
 successor.doHandle(request);
 }
 }
}

测试：
@Test
public void test() {
 AbstractHandler handlerA = new ConcreteHandlerA();
 AbstractHandler handlerB = new ConcreteHandlerB();
 AbstractHandler handlerC = new ConcreteHandlerC();
 handlerA.setSuccessor(handlerB);
 handlerB.setSuccessor(handlerC);

 List list = Arrays.asList("handlerA000", "handlerB111", "handlerC222");
 for (String str : list) {
 handlerA.doHandle(str);
 }
}
``
## 3. 其他
```java
public abstract class AbstractHandle {

 public static void main(String[] args) {
 AbstractHandle handle = Builder.create()
 .addHandler(new ValidateHandle())
 .addHandler(new LoginHandle())
 .addHandler(new AuthHandle())
 .build();
 handle.doHandle("111");
 }

 protected AbstractHandle chain;

 public void next(AbstractHandle handle) {
 this.chain = handle;
 }

 /**
 * 抽象方法
 * @param request
 */
 public abstract void doHandle(String request);

 public static class Builder {
 private AbstractHandle head;
 private AbstractHandle tail;

 public Builder addHandler(AbstractHandle handle) {
 if (this.head == null) {
 this.head = this.tail = handle;
 return this;
 }
 this.tail.next(handle);
 this.tail = handle;
 return this;
 }

 public AbstractHandle build() {
 return this.head;
 }

 public static Builder create() {
 return new Builder();
 }
 }
}

class ValidateHandle extends AbstractHandle {
 @Override
 public void doHandle(String request) {
 System.out.println("ValidateHandle start");
 if (chain != null) {
 chain.doHandle(request);
 }
 }
}

class LoginHandle extends AbstractHandle {
 @Override
 public void doHandle(String request) {
 System.out.println("LoginHandle start");
 if (chain != null) {
 chain.doHandle(request);
 }
 }
}

class AuthHandle extends AbstractHandle {
 @Override
 public void doHandle(String request) {
 System.out.println("AuthHandle start");
 // 若还有下一级，请求继续传递
 if (chain != null) {
 chain.doHandle(request);
 }
 }
}

---
由 答源 DAN 底座 1.4.0 生成 · 2026-11-08T08:44:30+00:00