【JAVA 网络编程系列】Netty -- Netty 接受新数据
【1】主循环中处理 Read 事件
public final class NioEventLoop extends SingleThreadEventLoop {
private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
...
try {
// 检索此键的就绪操作集
int readyOps = k.readyOps();
...
// 处理 Read / Accept 事件
if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
unsafe.read();
}
} catch (CancelledKeyException ignored) {
// 处理异常
unsafe.close(unsafe.voidPromise());
}
}
}【2】Read 事件的处理流程
【2.1】处理接受新数据请求时的 unsafe 继承结构
针对 NioSocketChannel 其 unsafe 对应的是 NioSocketChannelUnsafe 类；
【2.2】数据读取流程
public abstract class AbstractNioByteChannel extends AbstractNioChannel {
protected class NioByteUnsafe extends AbstractNioUnsafe {
@Override
public final void read() {
// 获取 ServerSocketChannel 中的 ChannelConfig 实例
final ChannelConfig config = config();
// 获取 ServerSocketChannel 中的 ChannelPipeline 实例
final ChannelPipeline pipeline = pipeline();
// 初始化内存分配器
// ByteBuf 的分配器
final ByteBufAllocator allocator = config.getAllocator();
final RecvByteBufAllocator.Handle allocHandle = recvBufAllocHandle();
// 重置已累积的所有计数器，并建议下一个读取循环应读取多少消息/字节
allocHandle.reset(config);
ByteBuf byteBuf = null;
boolean close = false;
try {
do {
// 通过allocator创建一个ByteBuf
// 默认地，通过各种参数判断当前操作系统是否允许池化、Unsafe、堆外这三个指标
// 当然，这些参数也可以通过启动参数来控制
byteBuf = allocHandle.allocate(allocator);
// 读取数据到ByteBuf中
// lastBytesRead
// Set the bytes that have been read for the last read operation
// 设置上次读取操作已读取的字节
// doReadBytes 方法为
// protected abstract int doReadBytes(ByteBuf buf) throws Exception; 由子类覆写
allocHandle.lastBytesRead(doReadBytes(byteBuf));
// lastBytesRead
// Get the amount of bytes for the previous read operation.
// 获取上一次读取操作的字节数
if (allocHandle.lastBytesRead() <= 0) {
// 未读取到数据释放ByteBuf
// nothing was read. release the buffer.
byteBuf.release();
byteBuf = null;
// 标记 close 标志
close = allocHandle.lastBytesRead() < 0;
if (close) {
readPending = false;
}
break;
}
// incMessagesRead
// Increment the number of messages that have been read for the current read loop
// 增加当前读取循环已读取的消息数
allocHandle.incMessagesRead(1);
readPending = false;
// 触发 ChannelHandler 的 channelRead() 方法
pipeline.fireChannelRead(byteBuf);
byteBuf = null;
// continueReading
// Determine if the current read loop should should continue
// 确定当前读取循环是否应继续
} while (allocHandle.continueReading());
// The read has completed
// 标记读取已完成
allocHandle.readComplete();
// 触发 ChannelHandler 的 channelReadComplete() 方法
pipeline.fireChannelReadComplete();
// 数据接受完毕
if (close) {
// 关闭 Channel
closeOnRead(pipeline);
}
} catch (Throwable t) {
// 处理异常
handleReadException(pipeline, byteBuf, t, close, allocHandle);
} finally {
// 当没有未读信息并且Channel不是AutoRead的
if (!readPending && !config.isAutoRead()) {
// 移除与读相关的兴趣事件集
removeReadOp();
}
}
}
}
}public class NioSocketChannel extends AbstractNioByteChannel
implements io.netty.channel.socket.SocketChannel {
@Override
protected int doReadBytes(ByteBuf byteBuf) throws Exception {
// 分配接受处理相关的Handle
final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
// 设置可读取的长度
allocHandle.attemptedBytesRead(byteBuf.writableBytes());
// 调用ByteBuf的writeBytes()方法
// 第一个参数是Java原生的SocketChannel，第二个参数是可读取的长度
return byteBuf.writeBytes(javaChannel(), allocHandle.attemptedBytesRead());
}
}public abstract class AbstractByteBuf extends ByteBuf {
@Override
public int writeBytes(ScatteringByteChannel in, int length) throws IOException {
// 保证容量足够，里面有扩容的逻辑
ensureWritable(length);
// 调用setBytes()方法
// 第一个参数是写入的位置，第二参数是SocketChannel，第三个参数可写入的长度
int writtenBytes = setBytes(writerIndex, in, length);
if (writtenBytes > 0) {
writerIndex += writtenBytes;
}
return writtenBytes;
}
}【2.3】数据在 Pipeline 中的传递过程
Pipeline 中传递数据流程图示
public class DefaultChannelPipeline implements ChannelPipeline {
protected void onUnhandledInboundMessage(Object msg) {
try {
// 记录日志
logger.debug(
"Discarded inbound message {} that reached at the tail of the pipeline. " +
"Please check your pipeline configuration.", msg);
} finally {
// 释放ByteBuf的引用
ReferenceCountUtil.release(msg);
}
}
@Override
public final ChannelPipeline fireChannelRead(Object msg) {
// 从HeadContext开始调用
AbstractChannelHandlerContext.invokeChannelRead(head, msg);
return this;
}
final class HeadContext extends AbstractChannelHandlerContext
implements ChannelOutboundHandler, ChannelInboundHandler {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// 调用ChannelHandlerContext的fireChannelRead()方法
// 触发下一个Context中Handler的调用
ctx.fireChannelRead(msg);
}
}
final class TailContext extends AbstractChannelHandlerContext implements ChannelInboundHandler {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// 数据传递到TailContext则打印日志并释放ByteBuf
// 目的
// 1.实现 ChannelPipeline 的完整性，有头有尾
// 2.回收资源
onUnhandledInboundMessage(msg);
}
}
}abstract class AbstractChannelHandlerContext extends DefaultAttributeMap
implements ChannelHandlerContext, ResourceLeakHint {
static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
// 创建信息数据
final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
// 获取Channel的执行器
EventExecutor executor = next.executor();
// 判断当前线程是不是在EventLoop中
if (executor.inEventLoop()) {
next.invokeChannelRead(m);
} else {
executor.execute(new Runnable() {
@Override
public void run() {
next.invokeChannelRead(m);
}
});
}
}
private void invokeChannelRead(Object msg) {
// invokeHandler() 确定是否已经调用过
// ChannelHandler#handlerAdded(ChannelHandlerContext)
if (invokeHandler()) {
try {
// 调用里面的ChannelHandler的channelRead()方法
((ChannelInboundHandler) handler()).channelRead(this, msg);
} catch (Throwable t) {
// 异常处理
notifyHandlerException(t);
}
} else {
// 从Pipeline中确定一个inbound的HandlerContext
// 并从该HandlerContext发开触发ChannelHandler的channelRead()方法
fireChannelRead(msg);
}
}
@Override
public ChannelHandlerContext fireChannelRead(final Object msg) {
// 寻找下一个可用的ChannelHandlerContext
// 从Pipeline中确定一个inbound的HandlerContext
// 并从该HandlerContext发开触发ChannelHandler的channelRead()方法
invokeChannelRead(findContextInbound(), msg);
return this;
}
private AbstractChannelHandlerContext findContextInbound() {
AbstractChannelHandlerContext ctx = this;
do {
ctx = ctx.next;
} while (!ctx.inbound);
return ctx;
}
}@Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
// 此处读取数据后，写回客户端
// 没有调用ctx.fireChannelRead(msg);
// 此时数据不会继续向下一个ChannelHandlerContext传递
ctx.write(msg);
}
}参考致谢
本博客为博主学习笔记，同时参考了网上众博主的博文以及相关专业书籍，在此表示感谢，本文若存在不足之处，请批评指正。
【1】慕课专栏，网络编程之Netty一站式精讲
【2】极客时间，Netty源码剖析与实战
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
