Netty系列文章:
Netty服务端启动流程源码分析
Netty服务端处理客户端连接流程
Netty客户端消息处理流程
NioEventLoop源码分析
Netty RecvByteBufAllocator源码分析
在前面一期我们讲了Netty服务端启动流程,本期就带大家看看服务端是如何处理客户端连接的流程。
我们直接从#NioEventLoop的processSelectedKeys()方法开始,此方法的被调用处在#NioEventLoop的run()方法中,熟悉NioEvetnLoop的朋友应该知道,所有的Io事件和任务队列中的任务,都是在run()方法中被执行到,所以run()是NioEvent Loop的核心方法,不熟悉的朋友也没事,后面会有单独篇章进行讲解,在这里只需要知道run()里面处理了什么即可。
#NioEventLoop的processSelectedKeys()
private void processSelectedKeys() {
//selectedKeys表示当前NioEventLoop 的 selector 就绪事件 集合。
//这时已经有客户端发起连接操作,所以不为null
if (selectedKeys != null) {
processSelectedKeysOptimized();
} else {
processSelectedKeysPlain(selector.selectedKeys());
}
}
private void processSelectedKeysOptimized() {
//遍历每一个就绪事件
for (int i = 0; i < selectedKeys.size; ++i) {
// SelectionKey 表示 就绪事件。
final SelectionKey k = selectedKeys.keys[i];
//处理完事件后,将引用指向null,帮助GC
selectedKeys.keys[i] = null;
// 附件。 这里会拿到 “注册” 阶段 ,咱们向 selector 提供的 Channel 对象。
// channel 可能是 NioServerSocketChannel 也可能是 NioSocketChannel。
//这里可以再去回顾一下#AbstractNioChannel的doRegister()方法
//注册时将NioServerSocketChannel放在附件上
final Object a = k.attachment();
//NioServerSocketChannel
if (a instanceof AbstractNioChannel) {
// 处理IO事件
processSelectedKey(k, (AbstractNioChannel) a);
} else {
@SuppressWarnings("unchecked")
NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;
processSelectedKey(k, task);
}
if (needsToSelectAgain) {
selectedKeys.reset(i + 1);
selectAgain();
i = -1;
}
}
}
private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
// NioServerSocketChannel的UnSafe对象是NioMessageUnsafe类型
//NioMessageUnsafe就是专门用来处理客户端连接的对象
final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
//......
try {
int readyOps = k.readyOps();
if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
int ops = k.interestOps();
ops &= ~SelectionKey.OP_CONNECT;
k.interestOps(ops);
unsafe.finishConnect();
}
if ((readyOps & SelectionKey.OP_WRITE) != 0) {
ch.unsafe().forceFlush();
}
//有读事件或连接事件
if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
//目前我们关注的是连接,所以去看NioMessageUnsafe
unsafe.read();
}
} catch (CancelledKeyException ignored) {
unsafe.close(unsafe.voidPromise());
}
}
#NioMessageUnsafe的read()
private final List<Object> readBuf = new ArrayList<Object>();
@Override
public void read() {
assert eventLoop().inEventLoop();
final ChannelConfig config = config();
final ChannelPipeline pipeline = pipeline();
final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
allocHandle.reset(config);
boolean closed = false;
Throwable exception = null;
try {
try {
do {
//处理消息,传入readBuf
int localRead = doReadMessages(readBuf);
if (localRead == 0) {
break;
}
if (localRead < 0) {
closed = true;
break;
}
allocHandle.incMessagesRead(localRead);
} while (allocHandle.continueReading());
} catch (Throwable t) {
exception = t;
}
int size = readBuf.size();
//遍历readBuf处理消息
for (int i = 0; i < size; i ++) {
readPending = false;
//向服务端通道传播channelRead事件
//readBuf.get(i)就是NioSocketChannel
pipeline.fireChannelRead(readBuf.get(i));
}
readBuf.clear();
allocHandle.readComplete();
//向服务端通道传播channelReadComplete事件
pipeline.fireChannelReadComplete();
if (exception != null) {
closed = closeOnReadError(exception);
pipeline.fireExceptionCaught(exception);
}
if (closed) {
inputShutdown = true;
if (isOpen()) {
close(voidPromise());
}
}
} finally {
if (!readPending && !config.isAutoRead()) {
removeReadOp();
}
}
}
#NioServerSocketChannel的doReadMessages()
@Override
protected int doReadMessages(List<Object> buf) throws Exception {
//原生jdk处理accept事件
SocketChannel ch = SocketUtils.accept(javaChannel());
try {
if (ch != null) {
//将客户端通道存放到readBuf中
//this指当前服务端通道,在NioSocketChannel的构造中可以看到
//指定当前服务端通道为NioSocketChannel的parent
buf.add(new NioSocketChannel(this, ch));
return 1;
}
} catch (Throwable t) {
logger.warn("Failed to create a new channel from an accepted socket.", t);
try {
ch.close();
} catch (Throwable t2) {
logger.warn("Failed to close a socket.", t2);
}
}
return 0;
}
通过查看#NioMessageUnsafe的read()方法可以很清楚的知道,首先处理了接收事件,并将原生的SocketChannel包装为NioSocketChannel存放到readBuf中,然后向服务端通道(NioServerSocketChannel)传播channelRead事件。
这里一定要弄清楚服务端通道(NioServerSocketChannel)和客户端通道(NioSocketChannel)的区别,目前我们是处理客户端连接事件,用的是bossGroup,并且在NioServerSocketChannel中传播了正在连接的NioSocketChannel。
在服务端启动流程那一章里面,NioEventLoop执行的第二个任务大家还有印象吗?
ch.eventLoop().execute(new Runnable() {
@Override
public void run() {
//向管道内添加了一个ServerBootstrapAcceptor处理器,这个处理器是在NioServerSocketChannel中
pipeline.addLast(new ServerBootstrapAcceptor(ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
}
});
这里用示意图来描述(由于ServerBootstrapAcceptor是入站处理器,此处没有画出站箭头)
NioServerSocketChannel内部有一个pipeline,pipeline中有默认的HeadContext和TailContext,后来由NioEventLoop向pipeline中添加了一个处理器。
再回到#NioMessageUnsafe的read()方法,处理完accept事件后向通道传播channelRead事件,这是一个入站类型的事件,所以处理流程是HeadContext->ServerBootstrapAcceptor->TailContext,分别看这三个类的channelRead(),可以知道处理客户端连接事件的逻辑在ServerBootstrapAcceptor中。
#ServerBootstrapAcceptor的channelRead()
@Override
@SuppressWarnings("unchecked")
public void channelRead(ChannelHandlerContext ctx, Object msg) {
//msg就是NioSocketChannel,内部包装了jdk的SocketChannel
final Channel child = (Channel) msg;
//向NioSocketChannel的pipeline中添加业务处理器
//childHandler就是启动模板代码里 .childHandler() 配置的处理器
child.pipeline().addLast(childHandler);
//设置客户端通道属性
setChannelOptions(child, childOptions, logger);
setAttributes(child, childAttrs);
try {
//重点!!!
//childGroup就是workerGroup
//在这里完成了客户端通道注册到workerGroup的NioEvetnLoop中
childGroup.register(child).addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (!future.isSuccess()) {
forceClose(child, future.cause());
}
}
});
} catch (Throwable t) {
forceClose(child, t);
}
}
看到这里,我们可以明白为什么说boss是处理客户端连接,worker是处理客户端消息的原因了。
childGroup.register(child)的流程和第一章的注册流程大致相同,在这里就简单的梳理一下。这个register最终调用到了#AbstractUnsafe的register()方法中,对服务端启动流程比较熟悉的朋友肯定有印象了,这里和客户端通道注册到workerGroup的NioEventLoop中是一样的。
@Override
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
ObjectUtil.checkNotNull(eventLoop, "eventLoop");
if (isRegistered()) {
promise.setFailure(new IllegalStateException("registered to an event loop already"));
return;
}
if (!isCompatible(eventLoop)) {
promise.setFailure(
new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
return;
}
//这时的AbstractChannel是NioSocketChannel
//eventLoop是worker中的
AbstractChannel.this.eventLoop = eventLoop;
if (eventLoop.inEventLoop()) {
//注册
register0(promise);
} else {
try {
eventLoop.execute(new Runnable() {
@Override
public void run() {
register0(promise);
}
});
} catch (Throwable t) {
logger.warn(
"Force-closing a channel whose registration task was not accepted by an event loop: {}",
AbstractChannel.this, t);
closeForcibly();
closeFuture.setClosed();
safeSetFailure(promise, t);
}
}
}
private void register0(ChannelPromise promise) {
try {
if (!promise.setUncancellable() || !ensureOpen(promise)) {
return;
}
boolean firstRegistration = neverRegistered;
//注册,在#AbstractNioChannel内部实现
doRegister();
neverRegistered = false;
registered = true;
//回调处理器的事件方法,这里回调的是 .childHandler()
//配置的ChannelInitializer的initChannel()
pipeline.invokeHandlerAddedIfNeeded();
//注册的future设为success,并回调在此future上的监听器
safeSetSuccess(promise);
//在通道(NioSocketChannel)内传播注册成功事件
pipeline.fireChannelRegistered();
//客户端注册会进入此逻辑
if (isActive()) {
if (firstRegistration) {
//向客户端通道传播channelActive事件
pipeline.fireChannelActive();
} else if (config().isAutoRead()) {
beginRead();
}
}
} catch (Throwable t) {
closeForcibly();
closeFuture.setClosed();
safeSetFailure(promise, t);
}
}
#AbstractNioChannel的doRegister()
@Override
protected void doRegister() throws Exception {
boolean selected = false;
for (;;) {
try {
//将SocketChannel注册到多路复用器上,设置没有感兴趣的事件,附件为当前客户端通道
selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
return;
} catch (CancelledKeyException e) {
if (!selected) {
eventLoop().selectNow();
selected = true;
} else {
throw e;
}
}
}
}
到这里就完成了worker与NioSocketChannel的绑定。然后向NioSocketChannel传播注册成功事件和channelActive事件。
在上一章服务端启动流程里,在NioServerSocketChannel中传播channelActive事件时提交了一个任务,在NioSocketChannel中是直接执行。
在客户端的pipeline里,还是看HeadContext的channelActive()。
@Override
public void channelActive(ChannelHandlerContext ctx) {
ctx.fireChannelActive();
readIfIsAutoRead();
}
private void readIfIsAutoRead() {
if (channel.config().isAutoRead()) {
//可以看到这时又发起了一次read事件
channel.read();
}
}
再回到HeadContext的read()方法中
@Override
public void read(ChannelHandlerContext ctx) {
unsafe.beginRead();
}
beginRead()最终会调用到#AbstractUnsafe里面
@Override
public final void beginRead() {
assertEventLoop();
if (!isActive()) {
return;
}
try {
//核心方法
doBeginRead();
} catch (final Exception e) {
invokeLater(new Runnable() {
@Override
public void run() {
pipeline.fireExceptionCaught(e);
}
});
close(voidPromise());
}
}
doBeginRead()方法也会有一系列的调用流程,最终来到#AbstractNioChannel的doBeginRead()
@Override
protected void doBeginRead() throws Exception {
final SelectionKey selectionKey = this.selectionKey;
if (!selectionKey.isValid()) {
return;
}
readPending = true;
final int interestOps = selectionKey.interestOps();
//还记得最开始注册通道的时候吗,那时候设置的感兴趣的事件为0,条件成立
if ((interestOps & readInterestOp) == 0) {
//设置感兴趣的事件
selectionKey.interestOps(interestOps | readInterestOp);
}
}
由于现在是客户端连接流程,readInterestOp可以在#NioServerSocketChannel的父类构造中找到赋值
public NioSocketChannel(Channel parent, SocketChannel socket) {
super(parent, socket);
config = new NioSocketChannelConfig(this, socket.socket());
}
#AbstractNioByteChannel
protected AbstractNioByteChannel(Channel parent, SelectableChannel ch) {
//设置感兴趣的事件为read
super(parent, ch, SelectionKey.OP_READ);
}
到这里客户端的连接流程就已经分析完毕,在这一章里主要是要弄清服务端通道和客户端通道的区别,在找到boss与worker交互的地方,后面的客户端注册逻辑就和服务端注册逻辑基本一致,下面还是给个流程图来方便大家理解。
以上就是Netty服务端处理客户端连接的整体流程,后续还会继续更新Netty相关的知识。