【职责链】设计模式：构建灵活的请求处理系统

本文将深入探讨职责链模式的工作原理、实现方式，并分析其在现代软件架构中的应用。

引言

在复杂的业务逻辑中，请求的传递和处理往往涉及多个处理对象。传统的处理方式可能会导致组件之间高度耦合，难以维护和扩展。
职责链模式通过将请求沿链传递，直到找到合适的处理者，有效解决了这一问题。

概述

职责链模式是一种行为设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
这种模式将对象组成一条链，并沿着这条链传递请求，直到有对象处理它为止。

核心概念

请求（Request）：需要处理的任务或信息。
处理者（Handler）：链中的节点，负责处理请求或转发请求。

工作原理

1. 客户端创建请求并将其发送到链的头部；
2. 链中的每个处理者决定是否能够处理该请求；
3. 如果能够处理，执行相应操作；否则，将请求转发到链中的下一个处理者；
4. 这个过程一直持续，直到请求被处理或到达链的末端。

代码实现

方式一

Handler是所有处理器类的抽象父类，handle()方法是抽象方法。
每个具体的处理器类HandlerA ，HandlerB的handle()代码结构类似，如果它能处理该请求，就不继续向下传递；如果不能处理，则交由后面的处理器来处理（即调用successor.handle()）。
HandlerChain是处理器链，一个记录了链头、链尾的链表。

public abstract class Handler {
  protected Handler successor = null;

  public void setSuccessor(Handler successor) {
    this.successor = successor;
  }

  public final void handle() {
    boolean handled = doHandle();
    if (successor != null && !handled) {
      successor.handle();
    }
  }

  protected abstract boolean doHandle();
}

public class HandlerA extends Handler {
  @Override
  protected boolean doHandle() {
    boolean handled = false;
    //...
    return handled;
  }
}

public class HandlerB extends Handler {
  @Override
  protected boolean doHandle() {
    boolean handled = false;
    //...
    return handled;
  }
}

public class HandlerChain {
  private Handler head = null;
  private Handler tail = null;

  public void addHandler(Handler handler) {
    handler.setSuccessor(null);

    if (head == null) {
      head = handler;
      tail = handler;
      return;
    }

    tail.setSuccessor(handler);
    tail = handler;
  }

  public void handle() {
    if (head != null) {
      head.handle();
    }
  }
}

// 使用举例
public class Application {
  public static void main(String[] args) {
    HandlerChain chain = new HandlerChain();
    chain.addHandler(new HandlerA());
    chain.addHandler(new HandlerB());
    chain.handle();
  }
}

方式 2

HandlerChain类用数组来保存所有的处理器类，且在handler()函数中调用每个处理器类的handler()函数。

public interface IHandler {
  boolean handle();
}

public class HandlerA implements IHandler {
  @Override
  public boolean handle() {
    boolean handled = false;
    //...
    return handled;
  }
}

public class HandlerB implements IHandler {
  @Override
  public boolean handle() {
    boolean handled = false;
    //...
    return handled;
  }
}

public class HandlerChain {
  private List<IHandler> handlers = new ArrayList<>();

  public void addHandler(IHandler handler) {
    this.handlers.add(handler);
  }

  public void handle() {
    for (IHandler handler : handlers) {
      boolean handled = handler.handle();
      if (handled) {
        break;
      }
    }
  }
}

// 使用举例
public class Application {
  public static void main(String[] args) {
    HandlerChain chain = new HandlerChain();
    chain.addHandler(new HandlerA());
    chain.addHandler(new HandlerB());
    chain.handle();
  }
}

变体

实际上，职责链模式还有一种变体，那就是请求会被所有的处理器都处理一遍，不存在中途停止的情况。

链表实现

public abstract class Handler {
  protected Handler successor = null;

  public void setSuccessor(Handler successor) {
    this.successor = successor;
  }

  public final void handle() {
    doHandle();
    if (successor != null) {
      successor.handle();
    }
  }

  protected abstract void doHandle();
}

public class HandlerA extends Handler {
  @Override
  protected void doHandle() {
    //...
  }
}

public class HandlerB extends Handler {
  @Override
  protected void doHandle() {
    //...
  }
}

public class HandlerChain {
  private Handler head = null;
  private Handler tail = null;

  public void addHandler(Handler handler) {
    handler.setSuccessor(null);

    if (head == null) {
      head = handler;
      tail = handler;
      return;
    }

    tail.setSuccessor(handler);
    tail = handler;
  }

  public void handle() {
    if (head != null) {
      head.handle();
    }
  }
}

// 使用举例
public class Application {
  public static void main(String[] args) {
    HandlerChain chain = new HandlerChain();
    chain.addHandler(new HandlerA());
    chain.addHandler(new HandlerB());
    chain.handle();
  }
}

数组实现

public interface IHandler {
  void handle();
}

public class HandlerA implements IHandler {
  @Override
  public void handle() { 
    //...
  }
}

public class HandlerB implements IHandler {
  @Override
  public boolean handle() {
    //...
  }
}

public class HandlerChain {
  private List<IHandler> handlers = new ArrayList<>();

  public void addHandler(IHandler handler) {
    this.handlers.add(handler);
  }

  public void handle() {
    for (IHandler handler : handlers) {
      handler.handle();
    }
  }
}

// 使用举例
public class Application {
  public static void main(String[] args) {
    HandlerChain chain = new HandlerChain();
    chain.addHandler(new HandlerA());
    chain.addHandler(new HandlerB());
    chain.handle();
  }
}

性能和设计考量

职责链模式提供了请求处理的灵活性和可扩展性，但也需要考虑以下方面：

• 性能问题：如果链过长，请求的传递可能会引入延迟。
• 未知终点：请求可能在链的末端仍未被处理，需要有默认的处理策略。

最佳实践

• 确保每个处理者明确自己的职责范围；
• 避免创建过长的职责链，以免影响性能；
• 提供默认的处理者，以防请求未被处理。

总结

职责链模式是一种强大且灵活的设计模式，它通过解耦请求发送者和接收者，提高了系统的可扩展性和可维护性。理解其工作原理和实现方式，有助于我们在面对复杂的请求处理逻辑时，设计出更加优雅和高效的解决方案。
另外，职责链模式经常用来开发框架的过滤器和拦截器，如Servlet Filter和Spring Interceptor，关于底层代码分析，将在后面文章中单独讲解。