Java 中责任链模式实现的三种方式

责任链模式

责任链模式的定义：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系， 将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理他为止。这里就不再过多的介绍什么是责任链模式，主要来说说java中如何编写。主要从下面3个框架中的代码中介绍。

• servlet中的filter
• dubbo中的filter
• mybatis中的plugin 这3个框架在实现责任链方式不尽相同。

servlet中的filter

servlet中分别定义了一个 filter和filterchain的接口，核心代码如下：

public final class applicationfilterchain implements filterchain {
  private int pos = 0; //当前执行filter的offset
  private int n; //当前filter的数量
  private applicationfilterconfig[] filters; //filter配置类，通过getfilter()方法获取filter
  private servlet servlet
  @override
  public void dofilter(servletrequest request, servletresponse response) {
    if (pos < n) {
      applicationfilterconfig filterconfig = filters[pos++];
      filter filter = filterconfig.getfilter();
      filter.dofilter(request, response, this);
    } else {
      // filter都处理完毕后，执行servlet
      servlet.service(request, response);
    }
  }
}

代码还算简单，结构也比较清晰，定义一个chain，里面包含了filter列表和servlet，达到在调用真正servlet之前进行各种filter逻辑。

dubbo中的filter

dubbo在创建filter的时候是另外一个方法，通过把filter封装成 invoker的匿名类，通过链表这样的数据结构来完成责任链，核心代码如下：

private static <t> invoker<t> buildinvokerchain(final invoker<t> invoker, string key, string group) {
  invoker<t> last = invoker;
  //只获取满足条件的filter
  list<filter> filters = extensionloader.getextensionloader(filter.class).getactivateextension(invoker.geturl(), key, group);
  if (filters.size() > 0) {
    for (int i = filters.size() - 1; i >= 0; i --) {
      final filter filter = filters.get(i);
      final invoker<t> next = last;
      last = new invoker<t>() {
        ...
        public result invoke(invocation invocation) throws rpcexception {
          return filter.invoke(next, invocation);
        }
        ...
      };
    }
  }
  return last;
}

dubbo的责任链就没有类似filterchain这样的类吧filter和调用invoker结合起来，而是通过创建一个链表，调用的时候我们只知道第一个节点，每个节点包含了下一个调用的节点信息。 这里的虽然invoker封装filter没有显示的指定next，但是通过java匿名类和final的机制达到同样的效果。

mybatis中的plugin

mybatis可以配置各种plugin，无论是官方提供的还是自己定义的，plugin和filter类似，就在执行sql语句的时候做一些操作。mybatis的责任链则是通过动态代理的方式，使用plugin代理实际的executor类。（这里实际还使用了组合模式，因为plugin可以嵌套代理），核心代码如下：

public class plugin implements invocationhandler{
  private object target;
  private interceptor interceptor;
  @override
  public object invoke(object proxy, method method, object[] args) throws throwable {   
    if (满足代理条件) {
      return interceptor.intercept(new invocation(target, method, args));
    }
    return method.invoke(target, args);   
  }
  //对传入的对象进行代理，可能是实际的executor类，也可能是plugin代理类
  public static object wrap(object target, interceptor interceptor) {
    class<?> type = target.getclass();
    class<?>[] interfaces = getallinterfaces(type, signaturemap);
    if (interfaces.length > 0) {
      return proxy.newproxyinstance(
          type.getclassloader(),
          interfaces,
          new plugin(target, interceptor, signaturemap));
    }
    return target;
  }
}

　简单的示意图如下：

总结

这里简单介绍了servlet、dubbo、mybatis对责任链模式的不同实现手段，其中servlet是相对比较清晰，又易于实现的方式，而dubbo和mybatis则适合在原有代码基础上，增加责任链模式代码改动量最小的。

以上所述是小编给大家介绍的java 中责任链模式实现的三种方式，希望对大家有所帮助