7 - 责任链模式-行为模式

参考：设计模式之禅

1. 定义

多个对象连成一个链，沿着链传递请求，直到有对象处理为止。

public abstract class AbstractLogger {
    protected static int DEBUG = 1;
    protected static int INFO = 2;
    protected static int ERROR = 3;
    protected int level = 0;
    protected AbstractLogger logger;

    public AbstractLogger(int level) {
        this.level = level;
    }


    public void handleRequest(int level, String msg) {
        if (this.level <= level) {
            write(msg);
        } else {
            if (this.logger != null) {
                this.logger.handleRequest(level, msg);
            }
        }
    }

    public abstract void write(String msg);

    public void setLogger(AbstractLogger logger) {
        this.logger = logger;
    }
}

public class DebugLogger extends AbstractLogger {
    public DebugLogger() {
        super(AbstractLogger.DEBUG);
    }

    @Override
    public void write(String msg) {
        System.out.println("Level =" + level + ",debug msg = " + msg);
    }
}
public class InfoLogger extends AbstractLogger {
    public InfoLogger() {
        super(AbstractLogger.INFO);
    }

    @Override
    public void write(String msg) {
        System.out.println("Level =" + level + ",info msg = " + msg);
    }
}
public class ErrorLogger extends AbstractLogger {
    public ErrorLogger() {
        super(AbstractLogger.ERROR);
    }

    @Override
    public void write(String msg) {
        System.out.println("Level =" + level + ",error msg = " + msg);
    }
}

public class Client {
    public static void main(String[] args) {
        ErrorLogger errorLogger = new ErrorLogger();
        InfoLogger infoLogger = new InfoLogger();
        DebugLogger debugLogger = new DebugLogger();
        errorLogger.setLogger(infoLogger);
        infoLogger.setLogger(debugLogger);

        errorLogger.handleRequest(1,"critical thinking");

    }
}

2. 应用

2.1 优点

将请求和处理分开，解耦，提高系统灵活性。

2.2 缺点

• 性能问题，因为请求要从头到尾遍历一遍；
• 调试麻烦。

可以设置责任链的节点数量。

3. 模拟web请求

/**
 * 模拟web请求request和response的处理
 * <p>
 * 有若干个Filter，request先经过第一个Filter处理，然后是第二个，直到最后一个；然后response返回则返过来，先经过最后一个Filter,
 * 然后倒数第二个，以此类推。
 * </P>
 *
 * @author tobebetter9527
 * @create 2021/07/25 14:40
 */
public class FilterChainDemo {

  public static void main(String[] args) {
    Request request = new Request();
    Response response = new Response();
    request.req = "你好，<script>, 我们都是996";
    response.res = "返回顺序：";

    FilterChain chain = new FilterChain();
    chain.add(new WordFilter()).add(new HtmlFilter());
    chain.doFilter(request, response);
    System.out.println("===============");
    System.out.println(request.req);
    System.out.println(response.res);
  }
}

interface Filter {

  void doFilter(Request request, Response response, FilterChain chain);
}

class HtmlFilter implements Filter {

  @Override
  public void doFilter(Request request, Response response, FilterChain chain) {
    request.req = request.req.replaceAll("<", "[").replaceAll(">", "]");
    System.out.println("HtmlFilter:" + request.req);
    chain.doFilter(request, response);
    response.res = response.res + "--HtmlFilter";
  }
}

class WordFilter implements Filter {

  @Override
  public void doFilter(Request request, Response response, FilterChain chain) {
    request.req = request.req.replaceAll("996", "955");
    System.out.println("WordFilter:" + request.req);
    chain.doFilter(request, response);
    response.res = response.res + "--WordFilter";
  }
}

class FilterChain {

  private List<Filter> filters = new ArrayList<>();
  private int index;

  public FilterChain add(Filter filter) {
    filters.add(filter);
    return this;
  }

  public void doFilter(Request request, Response response) {
    if (index == filters.size()) {
      return;
    }
    Filter filter = filters.get(index);
    index++;
    filter.doFilter(request, response, this);
  }
}


class Request {

  String req;
}

class Response {

  String res;
}

4. 参考资料

• https://refactoringguru.cn/design-patterns/chain-of-responsibility