责任链模式(Chain of responsibility)

19-05-27 jdon
              

目的

它属于  行为设计模式目录。通过为多个对象提供处理请求的机会,避免将请求的发送者与其接收者耦合。链接接收对象并沿链传递请求,直到对象处理它。

说明

国王向他的军队发出了命令。最早做出反应的是指挥官,然后是军官,最后是士兵。这里的指挥官,军官和士兵构成了一系列责任。简单来说

它有助于构建一系列对象。请求从一端进入并从一个对象到另一个对象,直到找到合适的处理程序。

维基百科说

在面向对象的设计中,责任链模式是一种由命令对象源和一系列处理对象组成的设计模式。每个处理对象都包含定义它可以处理的命令对象类型的逻辑; 其余的传递给链中的下一个处理对象。责任链模式的优势

  • 它减少了耦合。

  • 它在为对象分配职责时增加了灵活性。

  • 它允许一组类作为一个类; 在一个类中生成的事件可以在组合的帮助下发送到其他处理程序类。

结构

参与者

1.处理程序

  • 定义用于处理请求的接口。
  • (可选)实现后续链接。

2. ConcreteHandler

  • 处理它负责的请求。
  • 可以访问其继任者。
  • 如果ConcreteHandler可以处理该请求,则处理; 否则
  • 它将请求转发给其继任者。

3.客户端

  • 向链上的ConcreteHandler对象启动请求

合作

  • 当客户端发出请求时,请求将沿着链传播,直到ConcreteHandler对象负责处理它。

源代码

 第1步:首先我们有请求类

public class Request {

  private final RequestType requestType;
  private final String requestDescription;
  private boolean handled;

  public Request(final RequestType requestType, final String requestDescription) {
    this.requestType = Objects.requireNonNull(requestType);
    this.requestDescription = Objects.requireNonNull(requestDescription);
  }

  public String getRequestDescription() { return requestDescription; }

  public RequestType getRequestType() { return requestType; }

  public void markHandled() { this.handled = true; }

  public boolean isHandled() { return this.handled; }

  @Override
  public String toString() { return getRequestDescription(); }
}

public enum RequestType {
  DEFEND_CASTLE, TORTURE_PRISONER, COLLECT_TAX
}

第2步:然后是请求处理程序层次结构

public abstract class RequestHandler {
  private static final Logger LOGGER = LoggerFactory.getLogger(RequestHandler.class);
  private RequestHandler next;

  public RequestHandler(RequestHandler next) {
    this.next = next;
  }

  public void handleRequest(Request req) {
    if (next != null) {
      next.handleRequest(req);
    }
  }

  protected void printHandling(Request req) {
    LOGGER.info("{} handling request \"{}\"", this, req);
  }

  @Override
  public abstract String toString();
}

public class OrcCommander extends RequestHandler {
  public OrcCommander(RequestHandler handler) {
    super(handler);
  }

  @Override
  public void handleRequest(Request req) {
    if (req.getRequestType().equals(RequestType.DEFEND_CASTLE)) {
      printHandling(req);
      req.markHandled();
    } else {
      super.handleRequest(req);
    }
  }

  @Override
  public String toString() {
    return "Orc commander";
  }
}

// OrcOfficer and OrcSoldier are defined similarly as OrcCommander

第3步:然后我们有Orc King给出订单并形成链

public class OrcKing {
  RequestHandler chain;

  public OrcKing() {
    buildChain();
  }

  private void buildChain() {
    chain = new OrcCommander(new OrcOfficer(new OrcSoldier(null)));
  }

  public void makeRequest(Request req) {
    chain.handleRequest(req);
  }
}

步骤4:然后使用如下

OrcKing king = new OrcKing();
king.makeRequest(new Request(RequestType.DEFEND_CASTLE, "defend castle")); // Orc commander handling request "defend castle"
king.makeRequest(new Request(RequestType.TORTURE_PRISONER, "torture prisoner")); // Orc officer handling request "torture prisoner"
king.makeRequest(new Request(RequestType.COLLECT_TAX, "collect tax")); // Orc soldier handling request "collect tax"

适用场景

多个对象可以处理请求,并且处理程序不是先前已知的。应自动确定处理程序

您希望向几个对象之一发出请求,而不明确指定接收方

应动态指定可以处理请求的对象集。

              

2