Netty中的责任链模式

适用场景:

• 对于一个请求来说,如果有个对象都有机会处理它,而且不明确到底是哪个对象会处理请求时,我们可以考虑使用责任链模式实现它,让请求从链的头部往后移动,直到链上的一个节点成功处理了它为止

优点:

• 发送者不需要知道自己发送的这个请求到底会被哪个对象处理掉,实现了发送者和接受者的解耦
• 简化了发送者对象的设计
• 可以动态的添加节点和删除节点

缺点:

• 所有的请求都从链的头部开始遍历,对性能有损耗
• 极差的情况,不保证请求一定会被处理

自定义一个责任链

在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;
}

转载于:https://www.cnblogs.com/ZhuChangwu/p/11241304.html