【Netty】fireChannelRead责任链模式的使用

fireChannelRead

fireChannelRead是 Netty中实现 pipeline责任链模式的核心方法之一。它的主要作用是将消息传递给 ChannelPipeline中的下一个 ChannelInboundHandler

核心实现原理

1.ChannelHandlerContext 的链表结构

public class DefaultChannelHandlerContext extends AbstractChannelHandlerContext {
    private final ChannelHandler handler;
    
    // 每个 Context 都持有前后节点的引用
    AbstractChannelHandlerContext prev;
    AbstractChannelHandlerContext next;
}

2.消息传递的实现

public ChannelHandlerContext fireChannelRead(Object msg) {
    // 找到下一个 Inbound 处理器
    AbstractChannelHandlerContext next = findContextInbound(MASK_CHANNEL_READ);
    // 触发下一个处理器的 channelRead 方法
    next.invokeChannelRead(msg);
    return this;
}

private AbstractChannelHandlerContext findContextInbound(int mask) {
    AbstractChannelHandlerContext ctx = this;
    // 在链表中向后查找，直到找到下一个 Inbound 处理器
    do {
        ctx = ctx.next;
    } while ((ctx.executionMask & mask) == 0);
    return ctx;
}

示例工作流程

pipline初始化

[Head] <-> [Handler1] <-> [Handler2] <-> [Handler3] <-> [Tail]

消息传递示例

public class Handler1 extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        System.out.println("Handler1");
        // 传递给下一个处理器
        ctx.fireChannelRead(msg);
    }
}

public class Handler2 extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        System.out.println("Handler2");
        // 传递给下一个处理器
        ctx.fireChannelRead(msg);
    }
}

执行流程

1. Handler1收到消息并处理
2. 调用fireChannelRead寻找下一个inbound处理器
3. 找到Handler2并调用的channelRead方法
4. 以此类推，直到pipeline的尾部

特点

1. 单项传递：消息只会向后传递，不会回溯
2. 跳过不匹配：会自动跳过不是ChannelInboundHandler的处理器
3. 线程安全: 通过EventLoop机制确保处理器是线程安全的

使用示例

public class MyHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        if (canHandle(msg)) {
            // 处理消息
            handleMessage(msg);
        } else {
            // 不能处理的消息传递给下一个处理器
            ctx.fireChannelRead(msg);
        }
    }
    
    private boolean canHandle(Object msg) {
        // 判断是否能处理该消息
        return msg instanceof MyMessage;
    }
    
    private void handleMessage(Object msg) {
        // 处理消息的具体逻辑
    }
}

优点

1. 处理器可以专注与自己能处理的消息类型
2. 消息可以在多个处理器之间有序传递
3. 处理器直接解耦，易于维护和扩展