Netty Channel源码分析

原文地址： https://wangwei.one/posts/net...

前面，我们大致了解了Netty中的几个核心组件。今天我们就来先来介绍Netty的网络通信组件，用于执行网络I/O操作 —— Channel。

Netty版本：4.1.30

概述

数据在网络中总是以字节的形式进行流通。我们在进行网络编程时选用何种传输方式编码（OIO、NIO等）决定了这些字节的传输方式。

在没有Netty之前，为了提升系统的并发能力，从OIO切换到NIO时，需要对代码进行大量的重构，因为相应的Java NIO 与 IO API大不相同。而Netty在这些Java原生API的基础上做了一层封装，对用户提供了高度抽象而又统一的API，从而让传输方式的切换不在变得困难，只需要直接使用即可，而不需要对整个代码进行重构。

Netty Channel UML

netty channel族如下：

整个族群中，AbstractChannel 是最为关键的一个抽象类，从它继承出了AbstractNioChannel、AbstractOioChannel、AbstractEpollChannel、LocalChannel、EmbeddedChannel等类，每个类代表了不同的协议以及相应的IO模型。除了 TCP 协议以外，Netty 还支持很多其他的连接协议，并且每种协议还有 NIO(异步 IO) 和 OIO(Old-IO，即传统的阻塞 IO) 版本的区别. 不同协议不同的阻塞类型的连接都有不同的 Channel 类型与之对应。下面是一些常用的 Channel 类型：

NioSocketChannel：代表异步的客户端 TCP Socket 连接
NioServerSocketChannel：异步的服务器端 TCP Socket 连接
NioDatagramChannel：异步的 UDP 连接
NioSctpChannel：异步的客户端 Sctp 连接
NioSctpServerChannel：异步的 Sctp 服务器端连接
OioSocketChannel：同步的客户端 TCP Socket 连接
OioServerSocketChannel：同步的服务器端 TCP Socket 连接
OioDatagramChannel：同步的 UDP 连接
OioSctpChannel：同步的 Sctp 服务器端连接
OioSctpServerChannel：同步的客户端 TCP Socket 连接

Channel API

我们先来看下最顶层接口 channel 主要的API，常用的如下：

接口名	描述
eventLoop()	Channel需要注册到EventLoop的多路复用器上，用于处理I/O事件，通过eventLoop()方法可以获取到Channel注册的EventLoop。EventLoop本质上就是处理网络读写事件的Reactor线程。在Netty中，它不仅仅用来处理网络事件，也可以用来执行定时任务和用户自定义NioTask等任务。
pipeline()	返回channel分配的ChannelPipeline
isActive()	判断channel是否激活。激活的意义取决于底层的传输类型。例如，一个Socket传输一旦连接到了远程节点便是活动的，而一个Datagram传输一旦被打开便是活动的
localAddress()	返回本地的socket地址
remoteAddress()	返回远程的socket地址
flush()	将之前已写的数据冲刷到底层Channel上去
write(Object msg)	请求将当前的msg通过ChannelPipeline写入到目标Channel中。注意，write操作只是将消息存入到消息发送环形数组中，并没有真正被发送，只有调用flush操作才会被写入到Channel中，发送给对方。
writeAndFlush()	等同于调用write()并接着调用flush()
metadate()	熟悉TCP协议的读者可能知道，当创建Socket的时候需要指定TCP参数，例如接收和发送的TCP缓冲区大小，TCP的超时时间。是否重用地址等。在Netty中，每个Channel对应一个物理链接，每个连接都有自己的TCP参数配置。所以，Channel会聚合一个ChannelMetadata用来对TCP参数提供元数据描述信息，通过metadata()方法就可以获取当前Channel的TCP参数配置。
read()	从当前的Channel中读取数据到第一个inbound缓冲区中，如果数据被成功读取，触发ChannelHandler.channelRead(ChannelHandlerContext,Object)事件。读取操作API调用完成后，紧接着会触发ChannelHander.channelReadComplete（ChannelHandlerContext）事件，这样业务的ChannelHandler可以决定是否需要继续读取数据。如果已经有操作请求被挂起，则后续的读操作会被忽略。
close(ChannelPromise promise)	主动关闭当前连接，通过ChannelPromise设置操作结果并进行结果通知，无论操作是否成功，都可以通过ChannelPromise获取操作结果。该操作会级联触发ChannelPipeline中所有ChannelHandler的ChannelHandler.close(ChannelHandlerContext，ChannelPromise)事件。
parent()	对于服务端Channel而言，它的父Channel为空；对于客户端Channel，它的父Channel就是创建它的ServerSocketChannel。
id()	返回ChannelId对象，ChannelId是Channel的唯一标识。

Channel创建

对Netty Channel API以及相关的类有了一个初步了解之后，接下来我们来详细了解一下在Netty的启动过程中Channel是如何创建的。服务端Channel的创建过程，主要分为四个步骤：1）Channel创建；2）Channel初始化；3）Channel注册；4）Channel绑定。

我们以下面的代码为例进行解析：

// 创建两个线程组,专门用于网络事件的处理，Reactor线程组
// 用来接收客户端的连接，
EventLoopGroup bossGroup = new NioEventLoopGroup();
// 用来进行SocketChannel的网络读写
EventLoopGroup workGroup = new NioEventLoopGroup();

// 创建辅助启动类ServerBootstrap，并设置相关配置：
ServerBootstrap b = new ServerBootstrap();
// 设置处理Accept事件和读写操作的事件循环组
b.group(bossGroup, workGroup)
         // 配置Channel类型
        .channel(NioServerSocketChannel.class)
         // 配置监听地址
        .localAddress(new InetSocketAddress(port))
         // 设置服务器通道的选项，设置TCP属性
        .option(ChannelOption.SO_KEEPALIVE, Boolean.TRUE)
         // 设置建立连接后的客户端通道的选项
        .childOption(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
         // channel属性，便于保存用户自定义数据
        .attr(AttributeKey.newInstance("UserId"), "60293")
        .handler(new LoggingHandler(LogLevel.INFO))
        // 设置子处理器，主要是用户的自定义处理器，用于处理IO网络事件
        .childHandler(new ChannelInitializer() {
            @Override
            public void initChannel(SocketChannel ch) throws Exception {
                ch.pipeline().addLast(serverHandler);
            }
        });

// 调用bind()方法绑定端口，sync()会阻塞等待处理请求。这是因为bind()方法是一个异步过程，会立即返回一个ChannelFuture对象，调用sync()会等待执行完成
ChannelFuture f = b.bind().sync();
// 获得Channel的closeFuture阻塞等待关闭，服务器Channel关闭时closeFuture会完成
f.channel().closeFuture().sync();

调用channel()接口设置 AbstractBootstrap 的成员变量 channelFactory，该变量顾名思义就是用于创建channel的工厂类。源码如下：


...

public B channel(Class channelClass) {
    if (channelClass == null) {
        throw new NullPointerException("channelClass");
    }
    // 创建 channelFactory
    return channelFactory(new ReflectiveChannelFactory(channelClass));
}

...

public B channelFactory(ChannelFactory channelFactory) {
    if (channelFactory == null) {
        throw new NullPointerException("channelFactory");
    }
    
    if (this.channelFactory != null) {
        throw new IllegalStateException("channelFactory set already");
    }
    this.channelFactory = channelFactory;
    return (B) this;
}

...

channelFactory 设置为 ReflectiveChannelFactory ，在我们这个例子中 clazz 为 NioServerSocketChannel ，我们可以看到其中有个 newChannel() 接口，通过反射的方式来调用，这个接口的调用处我们后面会介绍到。源码如下：

// Channel工厂类
public class ReflectiveChannelFactory implements ChannelFactory {

    private final Class clazz;

    public ReflectiveChannelFactory(Class clazz) {
        if (clazz == null) {
            throw new NullPointerException("clazz");
        }
        this.clazz = clazz;
    }
    
    @Override
    public T newChannel() {
        try {
            // 通过反射来进行常见Channel实例
            return clazz.newInstance();
        } catch (Throwable t) {
            throw new ChannelException("Unable to create Channel from class " + clazz, t);
        }
    }

    @Override
    public String toString() {
        return StringUtil.simpleClassName(clazz) + ".class";
    }
}

接下来我们来看下 NioServerSocketChannel 的构造函数，主要就是：

生成ServerSocketChannel对象。NioServerSocketChannel创建时，首先使用SelectorProvider的openServerSocketChannel打开服务器套接字通道。SelectorProvider是Java的NIO提供的抽象类，是选择器和可选择通道的服务提供者。具体的实现类有SelectorProviderImpl，EPollSelectorProvide，PollSelectorProvider。选择器的主要工作是根据操作系统类型和版本选择合适的Provider：如果LInux内核版本>=2.6则，具体的SelectorProvider为EPollSelectorProvider，否则为默认的PollSelectorProvider。
设置 ServerSocketChannelConfig 成员变量。

private static ServerSocketChannel newSocket(SelectorProvider provider) {
    try {
        // 调用JDK底层API生成 ServerSocketChannel 对象实例
        return provider.openServerSocketChannel();
    } catch (IOException e) {
        throw new ChannelException("Failed to open a server socket.", e);
    }
}

private final ServerSocketChannelConfig config;

public NioServerSocketChannel() {
    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}

public NioServerSocketChannel(SelectorProvider provider) {
    this(newSocket(provider));
}

public NioServerSocketChannel(ServerSocketChannel channel) {
    // 调用 AbstractNioChannel 构造器，创建 NioServerSocketChannel，设置SelectionKey为ACCEPT
    super(null, channel, SelectionKey.OP_ACCEPT);
    // 创建ChannleConfig对象,主要是TCP参数配置类
    config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

AbstractNioChannel 的构造器如下：

protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    // 调用 AbstractChannel 构造器
    super(parent);
    this.ch = ch;
    // 从上一步过来，这里设置为 SelectionKey.OP_ACCEPT
    this.readInterestOp = readInterestOp;
    try {
        // 设置为非阻塞状态
        ch.configureBlocking(false);
    } catch (IOException e) {
        try {
            ch.close();
        } catch (IOException e2) {
            if (logger.isWarnEnabled()) {
                logger.warn("Failed to close a partially initialized socket.", e2);
            }
        }
        throw new ChannelException("Failed to enter non-blocking mode.", e);
    }
}

在 AbstractChannel 构造器中，会设Channel关联的三个核心对象：ChannelId、ChannelPipeline、Unsafe。

初始化ChannelId，ChannelId是一个全局唯一的值；
创建 NioMessageUnsafe 实例，该类为Channel提供了用于完成网络通讯相关的底层操作，如connect(),read(),register(),bind(),close()等；
为Channel创建DefaultChannelPipeline，初始事件传播管道。关于Pipeline的分析，请看后文的分析。

protected AbstractChannel(Channel parent) {
    this.parent = parent;
    // 设置ChannelId
    id = newId();
    // 设置Unsafe
    unsafe = newUnsafe();
    // 设置Pipeline
    pipeline = newChannelPipeline();
}

从 NioServerSocketChannelConfig 的构造函数追溯下去，在 DefaultChannelConfig 会设置channel成员变量。

public DefaultChannelConfig(Channel channel) {
    this(channel, new AdaptiveRecvByteBufAllocator());
}

protected DefaultChannelConfig(Channel channel, RecvByteBufAllocator allocator) {
    setRecvByteBufAllocator(allocator, channel.metadata());
    // 绑定channel
    this.channel = channel;
}

以上就是channel创建的过程，总结一下:

通过 ReflectiveChannelFactory 工厂类，以反射的方式对channel进行创建；
channel创建的过程中，会创建四个重要的对象：ChannelId、ChannelConfig、ChannelPipeline、Unsafe。

Channel初始化

主要分为以下两步：

将启动器（Bootstrap）设置的选项和属性设置到NettyChannel上面
向Pipeline添加初始化Handler，供注册后使用

我们从 AbstractBootstrap 的 bind() 接口进去，调用链：bind() —> doBind(localAddress) —> initAndRegister() —> init(Channel channel)，我们看下 ServerBootstrap 中 init() 接口的实现：

final ChannelFuture initAndRegister() {
    Channel channel = null;
    try {
        // 调用Channel工程类的newChannel()接口，创建channel，就是前面我们讲的部分内容
        channel = channelFactory.newChannel();
        // 初始化channel
        init(channel);
    } catch (Throwable t) {
        ....
}

初始化Channel，我们来重点看下 init(channel) 接口：

void init(Channel channel) throws Exception {
    // 获取启动器 启动时配置的option参数，主要是TCP的一些属性
    final Map, Object> options = options0();
    // 将获得到 options 配置到 ChannelConfig 中去
    synchronized (options) {
        setChannelOptions(channel, options, logger);
    }

    // 获取 ServerBootstrap 启动时配置的 attr 参数
    final Map, Object> attrs = attrs0();
    // 配置 Channel attr，主要是设置用户自定义的一些参数
    synchronized (attrs) {
        for (Entry, Object> e: attrs.entrySet()) {
            @SuppressWarnings("unchecked")
            AttributeKey

Netty Channel源码分析

概述

Netty Channel UML

Channel API

Channel创建

Channel初始化

Channel注册

Channel绑定

总结

参考资料

你可能感兴趣的:(Netty Channel源码分析)