适用场景:
- 对于一个请求来说,如果有个对象都有机会处理它,而且不明确到底是哪个对象会处理请求时,我们可以考虑使用责任链模式实现它,让请求从链的头部往后移动,直到链上的一个节点成功处理了它为止
优点:
- 发送者不需要知道自己发送的这个请求到底会被哪个对象处理掉,实现了发送者和接受者的解耦
- 简化了发送者对象的设计
- 可以动态的添加节点和删除节点
缺点:
- 所有的请求都从链的头部开始遍历,对性能有损耗
- 极差的情况,不保证请求一定会被处理
自定义一个责任链#
在java中不再存在指针了,如果我们想创建一个链表,只能是在本类中添加本类属性, 因为我们想创建一个链表,所以这是必须的工作
需要提供set方法,让当前的节点可以设置自己的下一个节点
处理请求的逻辑,设计成抽象方法,让不同的节点根据自己的需求去实现
public abstract class Approver { Approver approver; String name; // todo 抽象父类中可以存在构造函数,但是当我们创建子类时,必须要有一个参数的构造函数, // todo 让子类一个参数的构造函数,来给这个函数初始化 public Approver (String name){ this.name=name; } public abstract void ProcessRequest(PurchaseRequest request); // 如果当前的处理器处理不了,就会往下传播 public void setApprover( Approver approver){ this.approver=approver; } }
PurchaseRequest,需要被处理的请求,根据自己的需要各不相同
接着就是链表上的不同功能的节点都要实现上面的抽象类Approver,重写它的抽象方法,添加上他们特定的功能
测试:
// 创建出各个节点 Approver1 approver1 = new Approver1(); Approver2 approver2 = new Approver2(); Approver3 approver3 = new Approver3(); // 设置他们关系 approver1.setApprover(approver2); approver2.setApprover(approver3); // 发起请求 Client client = new Client(); PurchaseRequest purchaseRequest = client.sendRequest(); // 处理请求 tom.ProcessRequest(purchaseRequest);
把请求传递给责任链的第一个节点,她会自动往后传播下去,直到有一个节点成功处理了它
Netty的责任链设计#
netty的pipeline设计,就采用了责任链设计模式, 底层采用双向链表的数据结构, 将链上的各个处理器串联起来
客户端每一个请求的到来,netty都认为,pipeline中的所有的处理器都有机会处理它,因此,对于入栈的请求,全部从头节点开始往后传播,一直传播到尾节点(来到尾节点的msg会被释放掉)
netty的责任链模式中的组件
- 责任处理器接口
- pipeline中的处理器都它的具体实现
- 添加删除责任处理器的接口
- 上下文
- 通过这个上下文,可以获得需要的数据,属性
- 责任终止机制
- pipeline中的每一个节点,都可以终止事件的传播
netty的责任处理器接口#
责任处理器接口, pipeline中的所有的handler的顶级抽象接口,它规定了所有的handler统一要有添加,移除,异常捕获的行为
public interface ChannelHandler { // todo 当handler被添加到真实的上下文中,并且准备处理事件时被调用 // todo handler 被添加进去的回调 void handlerAdded(ChannelHandlerContext ctx) throws Exception; // todo 是 handler 被移出的后的 回调 void handlerRemoved(ChannelHandlerContext ctx) throws Exception; @Deprecated void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception; @Inherited @Documented @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @interface Sharable { // no value } }
netty对责任处理接口,做了更细粒度的划分, 处理器被分成了两种, 一种是站处理器ChannelInboundHandler,另一种是出站处理器ChannelOutboundHandler,这两个接口都继承自ChannelHandler
添加删除责任处理器的接口#
netty中所有的处理器最终都在添加在pipeline上,所以,添加删除责任处理器的接口的行为 netty在channelPipeline中的进行了规定
public interface ChannelPipeline extends ChannelInboundInvoker, ChannelOutboundInvoker, Iterable<Entry<String, ChannelHandler>> { ChannelPipeline addFirst(String name, ChannelHandler handler); ChannelPipeline addFirst(EventExecutorGroup group, String name, ChannelHandler handler); ChannelPipeline addLast(String name, ChannelHandler handler); ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler); ChannelPipeline addBefore(String baseName, String name, ChannelHandler handler); ...
上下文#
pipeline中的handler被封装进了上下文中,如下, 通过上下文,可以轻松拿到当前节点所属的channel, 以及它的线程执行器
// todo AttributeMap -- 让ChannelHandlerContext 可以存储自定义的属性 // todo ChannelInboundInvoker -- 让ChannelHandlerContext 可以进行 InBound事件的传播,读事件,read 或者是 注册事件 active事件 // todo ChannelOutboundInvoker -- 让ChannelHandlerContext 可以传播写事件 public interface ChannelHandlerContext extends AttributeMap, ChannelInboundInvoker, ChannelOutboundInvoker { // todo 获取ChannelHandlerContext所对应的这个Channel对象 Channel channel(); // todo 获取事件执行器 EventExecutor executor(); ...
责任终止机制#
责任终止机制
- 在pipeline中的任意一个节点,只要我们不手动的往下传播下去,这个事件就会终止传播在当前节点
- 对于入站数据,默认会传递到尾节点,进行回收,如果我们不进行下一步传播,事件就会终止在当前节点,别忘记回收msg
- 对于出站数据,用header节点的使用unsafe对象,把数据写会客户端也意味着事件的终止
事件的传播#
底层事件的传播使用的就是针对链表的操作
private AbstractChannelHandlerContext findContextInbound() { AbstractChannelHandlerContext ctx = this; do { ctx = ctx.next; } while (!ctx.inbound); return ctx; }
