学习Netty(四)------ChannelPipeline 和 ChannelHandler

Netty作为一款强大的异步事件驱动网络框架，其核心设计包括ChannelPipeline和ChannelHandler。在本文中，我们将深入介绍Pipeline的作用，详解ChannelPipeline的设计和功能，以及深入探讨Handler的生命周期，包括添加、移除和执行的过程。

前言

为了方便大家理解，我每个文章都会画出逻辑图，以方便大家理解,大家可以结合着图来进行学习

---

Pipeline的作用

1.ChannelPipeline的设计及作用

ChannelPipeline是Netty中一项关键的设计，它是一系列处理器（Handler）按顺序组织的管道。每个Channel都有一个独立的ChannelPipeline，它负责处理所有进出该Channel的事件。

ChannelPipeline pipeline = channel.pipeline();

1.1 使用ChannelPipeline的好处：

事件驱动模型： Netty采用异步事件驱动模型，ChannelPipeline使得我们可以轻松地管理和响应各种事件，例如数据读取、连接建立和异常处理。
解耦业务逻辑： 通过将处理器串联成链路，ChannelPipeline实现了业务逻辑的解耦。每个处理器关注特定任务，使得修改和扩展业务逻辑变得简单。

1.2 ChannelPipeline的组成：

处理器链
ChannelPipeline由一系列有序的ChannelHandler组成，形成了处理器链。事件在这条链上依次传播，每个处理器都有机会对事件进行处理、修改或拦截。

ChannelPipeline pipeline = channel.pipeline();
pipeline.addLast("handler1", new Handler1());
pipeline.addLast("handler2", new Handler2());
// ...

处理器的分类
入站处理器（Inbound Handler）： 处理入站事件，例如数据读取、连接建立等。
出站处理器（Outbound Handler）： 处理出站事件，例如数据写入、连接关闭等。
双向处理器（Bidirectional Handler）： 同时处理入站和出站事件。

1.3 事件传播与处理:

事件传播机制
事件在ChannelPipeline中的传播是有顺序的，从Head到Tail。当一个事件被触发时，它会沿着处理器链传播，每个处理器都有机会对事件进行处理。
处理器的执行
每个处理器都有channelRead、write等方法，用于处理入站和出站事件。处理器的执行是串行的，一个处理器的输出可以作为下一个处理器的输入。

public class Handler1 extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        // 处理入站事件
        // ...
        // 将事件传递给下一个处理器
        ctx.fireChannelRead(msg);
    }
}

public class Handler2 extends ChannelOutboundHandlerAdapter {
    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
        // 处理出站事件
        // ...
        // 将事件传递给下一个处理器
        ctx.write(msg, promise);
    }
}

事件的截断
处理器可以决定是否截断事件的传播，阻止事件继续传递给后续的处理器。这是通过不调用ctx.fireChannelRead(msg)或ctx.write(msg, promise)实现的。

public class MyHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        // 处理入站事件
        if (shouldHandle(msg)) {
            // 不传递给下一个处理器，截断事件传播
        } else {
            // 传递给下一个处理器
            ctx.fireChannelRead(msg);
        }
    }
}

1.4 ChannelPipeline的设计原理

Head和Tail的作用:
Head和Tail是ChannelPipeline中的两个特殊处理器，分别位于链的最前和最后。
Head： 负责处理入站事件，是第一个接收入站事件的处理器。
Tail： 负责处理出站事件，是最后一个接收出站事件的处理器。
链的初始化
在Channel被创建时，ChannelPipeline会被自动创建并初始化。这包括将Head和Tail添加到链的最前和最后。
Head和Tail的实现
Head和Tail并不是独立的处理器类，而是DefaultChannelPipeline内部类的实例，用于处理入站和出站事件。

Handler的生命周期

1.ChannelHandler的添加

ChannelHandler是处理数据和事件的基本单元。在ChannelPipeline中，我们通过addLast等方法添加ChannelHandler。

pipeline.addLast("handler1", new MyHandler1());
pipeline.addLast("handler2", new MyHandler2());

2 ChannelHandler的执行过程

ChannelHandler的执行过程涉及到事件的传播、处理器的执行和事件的截断。以下是一个简化的执行流程：
事件传播： 事件从Channel的起始点传播至处理器链的末尾。传播可以是入站事件（从底层传输到应用层）或出站事件（从应用层传输到底层）。
处理器执行： 事件在处理器链上的每个处理器中被执行。每个处理器都有机会对事件进行处理、修改或拦截。
事件截断： 处理器可以截断事件的传播，使得事件不再传递给后续的处理器。这是通过返回void或null来实现的。

3.ChannelHandler的移除

在ChannelPipeline中移除ChannelHandler可以通过remove等方法实现。移除后，该处理器将不再参与事件的传播和处理。

pipeline.remove("handler1");

4 ChannelHandler的生命周期

ChannelHandler的生命周期包括三个重要的方法：handlerAdded、handlerRemoved和exceptionCaught。这些方法允许我们在处理器被添加、移除或发生异常时执行特定的逻辑。

public class MyHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) {
        // 处理器添加时执行的逻辑
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) {
        // 处理器移除时执行的逻辑
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 处理异常时执行的逻辑
    }
}

总结

ChannelPipeline和ChannelHandler是Netty框架中非常重要的组件，它们通过处理器链路和生命周期方法提供了强大的事件处理和业务逻辑解耦的机制。深入了解这些组件的设计和使用，有助于充分发挥Netty框架的优势，构建高性能、可维护的网络应用。

这里我只做了简单介绍，netty是一个庞大的架构，之后的文章我会分开模块对其进行分析
这里作为目录方便大家学习（后续持续更新中）：
学习netty-通俗易懂版本
学习Netty(一)------Netty 架构概览
学习Netty(二)------Netty 启动过程与初始化
学习Netty(三)------Channel 和 EventLoop
学习Netty(四)------ChannelPipeline 和 ChannelHandler
学习Netty(五)------ByteBuf 的设计和使用
学习Netty(六)------编解码器的实现
学习Netty(七)------Selector 和事件模型
学习Netty(八)------性能优化和底层实现细节
学习Netty(九)------代码实现
学习Netty(十)------高级功能和扩展