文章目录
- 系列文章目录
- 一、ChannelPipeline、ChannelHandler、ChannelHandlerContext
- 1、三者关系
- 二、ChannelPipeline源码分析
- 1、ChannelPipeline接口设计
- 2、ChannelPipeline处理事件
- 三、ChannelHandler源码分析
- 1、ChannelHandler接口
- 2、ChannelInboundHandler入站接口
- 3、ChannelOutboundHandler出站接口
- 4、ChannelDuplexHandler处理出站和入站事件
- 四、ChannelHandlerContext源码分析
- 1、ChannelHandlerContext接口
- 2、ChannelInboundInvoker和ChannelOutboundInvoker接口
- 五、创建过程源码分析
- 1、SocketChannel创建过程创建pipeline
- 2、pipeline的addLast方法
- 3、小总结
- 六、ChannelPipeline调度Handler源码分析
- 1、inbound——fireChannelRead
- 2、outbound——connect
- 3、总结
系列文章目录
Netty核心源码分析(一),Netty的Server端启动过程源码分析Netty核心源码分析(二),Netty的Server端接收请求过程源码分析
Netty核心源码分析(三)业务请求执行关键——ChannelPipeline、ChannelHandler、ChannelHandlerContext源码分析
Netty核心源码分析(四)心跳检测源码分析
Netty核心源码分析(五)核心组件EventLoop源码分析
一、ChannelPipeline、ChannelHandler、ChannelHandlerContext
1、三者关系
- 每当 ServerSocket 创建一个新的连接,就会创建一个 Socket,对应的就是目标客户端。
2)每一个新创建的 Socket 都将会分配一个全新的 ChannelPipeline (以下简称 pipeline) - 每一个 ChannelPipeline 内部都含有多个 ChannelHandlerContext (以下简称 Context)
4)他们一起组成了双向链表,这些 Context 用于包装我们调用 addLast 方法时添加的 ChannelHandler (以下简称
handler)
上图中: ChannelSocket 和 ChannelPipeline 是一对一的关联关系,而 pipeline 内部的多个 Context 形成了链表,Context 只是对 Handler 的封装。
当一个请求进来的时候,会进入 Socket 对应的 pipeline,并经过 pipeline 所有的 handler,就是设计模式中的过滤器模式。
二、ChannelPipeline源码分析
1、ChannelPipeline接口设计
我们可以看到,ChannelPipeline继承了ChannelInboundInvoker、ChannelOutboundInvoker、Iterable接口,表示可以调用数据出站、入站的方法,同时支持迭代遍历。
ChannelPipeline内部的方法基本都是针对handler链表的增删改查。
2、ChannelPipeline处理事件
ChannelPipeline接口上提供了一张图:
这是一个handler的list,handler用于处理或拦截入站事件和出站事件,pipeline实现了过滤器的高级形式,以便用户控制事件如何处理以及handler在pipeline中如何交互。
上图描述了一个典型的handler在pipeline中处理IO事件的方式,IO事件由inboundHandler或者outBoundHandler处理,并通过调用ChannelHandlerContext.fireChannelRead方法转发给其最近的处理程序。
// 在ChannelInboundHandlerAdapter中的channelRead方法中有着对该方法的默认实现,默认就是调用了ChannelHandlerContext的fireChannelRead方法:
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ctx.fireChannelRead(msg);
}
// io.netty.channel.AbstractChannelHandlerContext#fireChannelRead
@Override
public ChannelHandlerContext fireChannelRead(final Object msg) {
invokeChannelRead(findContextInbound(), msg);
return this;
}
其中,findContextInbound方法,通过循环的方式查找下一个inboundHandler:
// io.netty.channel.AbstractChannelHandlerContext#findContextInbound
private AbstractChannelHandlerContext findContextInbound() {
AbstractChannelHandlerContext ctx = this;
do {
ctx = ctx.next;
} while (!ctx.inbound);
return ctx;
}
invokeChannelRead用于执行查找出的下一个Handler的channelRead方法,相当于一个执行器链。
// io.netty.channel.AbstractChannelHandlerContext#invokeChannelRead(io.netty.channel.AbstractChannelHandlerContext, java.lang.Object)
static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
EventExecutor executor = next.executor();
if (executor.inEventLoop()) {
next.invokeChannelRead(m);
} else {
executor.execute(new Runnable() {
@Override
public void run() {
next.invokeChannelRead(m);
}
});
}
}
// io.netty.channel.AbstractChannelHandlerContext#invokeChannelRead(java.lang.Object)
private void invokeChannelRead(Object msg) {
if (invokeHandler()) {
try {
((ChannelInboundHandler) handler()).channelRead(this, msg);
} catch (Throwable t) {
notifyHandlerException(t);
}
} else {
fireChannelRead(msg);
}
}
outBound处理同理,只不过是从尾往前进行遍历。
而这些Handler,正是保存在Pipeline中的:
通常一个pipeline有多个handler,例如,一个典型的服务器在每个通道的pipeline都会有以下处理程序:编解码器+业务处理程序。
业务程序不能将线程阻塞,会影响IO的速度,进而影响整个Netty程序的性能。如果你的业务程序很快,就可以放在IO线程中,反之,需要异步执行(使用MQ)。或者在添加Handler的时候添加一个线程池,例如:
// 下面这个任务执行的时候,将不会阻塞IO线程,执行的线程来自group线程池
pipeline.addLast(group, "handler", new MyHandler());
三、ChannelHandler源码分析
1、ChannelHandler接口
public interface ChannelHandler {
// 当把ChannelHandler添加到pipeline时调用
void handlerAdded(ChannelHandlerContext ctx) throws Exception;
// 当从pipeline中移除时调用
void handlerRemoved(ChannelHandlerContext ctx) throws Exception;
// 当处理过程在pipeline发生异常时调用
@Deprecated
void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception;
@Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Sharable {
// no value
}
}
Netty中的@Sharable注解用于标识某个ChannelHandler是否可以在多个ChannelPipeline之间共享使用,也即表示该ChannelHandler是否是无状态的。使用@Sharable注解标记的ChannelHandler可以在多个ChannelPipeline之间共享使用,从而降低资源的消耗。在Netty中,每次调用ChannelHandler的构造函数或添加到ChannelPipeline时,都会创建一个新的实例。因此,对于有状态的ChannelHandler,将不能使用@Sharable进行标记。
需要注意的是,在进行ChannelHandler的复用时,考虑到线程安全问题。对于使用@Sharable注解的ChannelHandler类,在多个ChannelPipeline之间共享时需要保证线程安全性。假如ChannelHandler类中包含非线程安全的成员变量,需要在成员变量上进行同步,以防止出现线程安全问题。因此,这也是使用@Sharable注解时需要仔细考虑的一点。
ChannelHandler的作用就是处理IO事件或拦截IO事件,并将其转发给下一个处理程序ChannelHandler。Handler处理事件时分入站和出站的,两个方向的操作都是不同的,因此,Netty定义了两个子接口继承ChannelHandler,分别是ChannelInboundHandler和ChannelOutboundHandler。
2、ChannelInboundHandler入站接口
public interface ChannelInboundHandler extends ChannelHandler {
// channel注册时调用
void channelRegistered(ChannelHandlerContext ctx) throws Exception;
// channel取消注册时调用
void channelUnregistered(ChannelHandlerContext ctx) throws Exception;
// channel处于活动状态时调用
void channelActive(ChannelHandlerContext ctx) throws Exception;
// channel非活动状态时调用
void channelInactive(ChannelHandlerContext ctx) throws Exception;
// 从channel读取数据时被调用
void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception;
// 数据读取完成时被调用
void channelReadComplete(ChannelHandlerContext ctx) throws Exception;
// 用户事件触发
void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception;
// 通道可写状态被触发时调用
void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception;
// 发生异常时调用
@Override
@SuppressWarnings("deprecation")
void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception;
}
我们需要重写其中的一些方法,用于关注某些我们需要的事件,在重写的方法中实现我们自己的逻辑。当Netty事件发生时,Netty会回调对应重写的方法。
3、ChannelOutboundHandler出站接口
public interface ChannelOutboundHandler extends ChannelHandler {
// 当请求将channel绑定到本地端口时调用
void bind(ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise) throws Exception;
// 发生连接时调用
void connect(
ChannelHandlerContext ctx, SocketAddress remoteAddress,
SocketAddress localAddress, ChannelPromise promise) throws Exception;
// 断开连接时调用
void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception;
// 当请求关闭channel时调用
void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception;
// 取消注册时调用
void deregister(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception;
void read(ChannelHandlerContext ctx) throws Exception;
// 在进行写操作时调用。写操作将通过ChannelPipeline写入消息。一旦调用Channel.flush(),它们就准备好被刷新到实际的Channel
void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception;
// 在执行刷新操作时调用。flush操作将尝试flush所有以前写的挂起的消息
void flush(ChannelHandlerContext ctx) throws Exception;
}
出站操作都是一些连接或者写出数据的方法。
4、ChannelDuplexHandler处理出站和入站事件
ChannelDuplexHandler继承了ChannelInboundHandlerAdapter类,实现了ChannelOutboundHandler接口,可以处理入站和出站所有的事件。
我们尽量避免使用ChannelDuplexHandler处理事件,入站出站事件最好由独立的类处理,否则容易混淆。
四、ChannelHandlerContext源码分析
1、ChannelHandlerContext接口
public interface ChannelHandlerContext extends AttributeMap, ChannelInboundInvoker, ChannelOutboundInvoker
ChannelHandlerContext接口继承了AttributeMap, ChannelInboundInvoker, ChannelOutboundInvoker接口。
ChannelHandlerContext不仅仅继承了ChannelInboundInvoker和ChannelOutboundInvoker接口的方法,同时也定义了一些自己的方法,这些方法能够获取context上下文环境中对应的比如channel、executor、handler、pipeline、内存分配器、关联的handler是否被删除。
Context就是包装了handler相关的一切类,以便Context可以在pipeline方便地操作handler。
2、ChannelInboundInvoker和ChannelOutboundInvoker接口
这两个invoker就是针对入站或出站方法来的,就是在入站或出站handler的外层再包装一层,达到在方法前后拦截并做一些特定操作的目的。
五、创建过程源码分析
1、SocketChannel创建过程创建pipeline
在上一篇文章我们分析到,doReadMessages方法会创建NioSocketChannel:
Netty核心源码分析(二),Netty的Server端接收请求过程源码分析
// io.netty.channel.socket.nio.NioServerSocketChannel#doReadMessages
@Override
protected int doReadMessages(List<Object> buf) throws Exception {
// 实际上调用NIO的的accept方法,获取SocketChannel
SocketChannel ch = SocketUtils.accept(javaChannel());
try {
if (ch != null) {
// 将NIO的SocketChannel包装成NioSocketChannel
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;
}
在new NioSocketChannel()的过程中,一直往父类找,会找到AbstractChannel的构造方法:
protected AbstractChannel(Channel parent) {
this.parent = parent;
id = newId();
unsafe = newUnsafe();
pipeline = newChannelPipeline();
}
protected DefaultChannelPipeline newChannelPipeline() {
return new DefaultChannelPipeline(this);
}
此时会创建一个DefaultChannelPipeline,在DefaultChannelPipeline的构造方法中会做Pipeline初始化。
protected DefaultChannelPipeline(Channel channel) {
// 将channel赋值给channel字段
this.channel = ObjectUtil.checkNotNull(channel, "channel");
// 创建future和promise,用于异步回调使用
succeededFuture = new SucceededChannelFuture(channel, null);
voidPromise = new VoidChannelPromise(channel, true);
// 创建inbound的TailContext
tail = new TailContext(this);
// 创建outbound的HeadContext(实际上实现了inbound和outbound两者)
head = new HeadContext(this);
// 形成双向链表
head.next = tail;
tail.prev = head;
}
2、pipeline的addLast方法
在服务端通过pipeline的addLiast方法添加Handler时的源码:
// io.netty.channel.DefaultChannelPipeline#addLast(io.netty.channel.ChannelHandler...)
@Override
public final ChannelPipeline addLast(ChannelHandler... handlers) {
return addLast(null, handlers);
}
// io.netty.channel.DefaultChannelPipeline#addLast(io.netty.util.concurrent.EventExecutorGroup, io.netty.channel.ChannelHandler...)
@Override
public final ChannelPipeline addLast(EventExecutorGroup executor, ChannelHandler... handlers) {
if (handlers == null) {
throw new NullPointerException("handlers");
}
for (ChannelHandler h: handlers) {
if (h == null) {
break;
}
addLast(executor, null, h);
}
return this;
}
// io.netty.channel.DefaultChannelPipeline#addLast(io.netty.util.concurrent.EventExecutorGroup, java.lang.String, io.netty.channel.ChannelHandler)
@Override
public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
final AbstractChannelHandlerContext newCtx;
synchronized (this) { // 多线程安全问题
// 检查这个handler实例是否是共享的,如果不是,并且已经被别的pipeline使用了,则抛出异常
checkMultiplicity(handler);
// 创建一个Context,我们可以看出,每添加一个Handler都会关联一个Context
newCtx = newContext(group, filterName(name, handler), handler);
// 将Context追加到链表中
addLast0(newCtx);
// If the registered is false it means that the channel was not registered on an eventloop yet.
// In this case we add the context to the pipeline and add a task that will call
// ChannelHandler.handlerAdded(...) once the channel is registered.
/*
如果这个通道还没有注册到selector上,就将这个Context添加到这个pipeline的待办任务中。
当注册好了以后,就会调用callHandlerAdded0方法(默认是什么都不做,用户可以实现这个方法)
*/
if (!registered) {
newCtx.setAddPending();
callHandlerCallbackLater(newCtx, true);
return this;
}
EventExecutor executor = newCtx.executor();
if (!executor.inEventLoop()) {
newCtx.setAddPending();
executor.execute(new Runnable() {
@Override
public void run() {
callHandlerAdded0(newCtx);
}
});
return this;
}
}
callHandlerAdded0(newCtx);
return this;
}
// io.netty.channel.DefaultChannelPipeline#addLast0
// 实际上是插在了尾的前一个,而不是尾,因为尾部的Handler用于框架做最后的处理用
private void addLast0(AbstractChannelHandlerContext newCtx) {
AbstractChannelHandlerContext prev = tail.prev;
newCtx.prev = prev;
newCtx.next = tail;
prev.next = newCtx;
tail.prev = newCtx;
}
3、小总结
到这里,针对三个对象创建过程就结束了,每当创建 ChannelSocket 的时候都会创建个绑定的 pipeline,一对一的关系,创建 pipeline 的时候也会创建 tail 节点和 head 节点,形成最初的链表。
tail是入站 inbound 类型的 handler, head 既是 inbound 也是 outbound 类型的 handler。
在调用 pipeline 的 addLast方法的时候,会根据给定的 handler 创建一个 Context,然后,将这个 Context 插入到链表的尾端(tail 前面)到此就 OK 了。
Context包装handler,多个Context在pipeline中形成了双向链表。
入站方法叫inbound,由head节点开始。出站方法叫outbound,由tail节点开始。
六、ChannelPipeline调度Handler源码分析
当一个请求进来的时候,ChannelPipeline会第一个调用pipeline的相关方法,如果是入站事件,这些方法由fire开头,表示开始管道的流动。让后面的handler继续处理。
上面我们分析过了,ChannelPipeline创建的是一个DefaultChannelPipeline。
上面我们也分析了,DefaultChannelPipeline中包含着一系列的事件方法,触发某一个事件之后,会执行其相关的方法。
1、inbound——fireChannelRead
我们以fireChannelRead方法为例,追一下源代码。
当client业务数据发送过来之后,会触发DefaultChannelPipeline的fireChannelRead方法,表示有数据可读。
// io.netty.channel.DefaultChannelPipeline#fireChannelRead
@Override
public final ChannelPipeline fireChannelRead(Object msg) {
// 将head传入
AbstractChannelHandlerContext.invokeChannelRead(head, msg);
return this;
}
// io.netty.channel.AbstractChannelHandlerContext#invokeChannelRead(io.netty.channel.AbstractChannelHandlerContext, java.lang.Object)
static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
EventExecutor executor = next.executor(); // 获取下一个执行器
if (executor.inEventLoop()) {
next.invokeChannelRead(m); // 执行器调度ChannelRead事件
} else {
executor.execute(new Runnable() {
@Override
public void run() {
next.invokeChannelRead(m);
}
});
}
}
此时,handler()方法返回this,也就是当前的ChannelHandler,并且调用该Handler的channelRead方法。
// io.netty.channel.AbstractChannelHandlerContext#invokeChannelRead(java.lang.Object)
private void invokeChannelRead(Object msg) {
if (invokeHandler()) {
try {
((ChannelInboundHandler) handler()).channelRead(this, msg);
} catch (Throwable t) {
notifyHandlerException(t);
}
} else {
fireChannelRead(msg);
}
}
上面我们分析到,pipeline的第一个Handler是系统创建的HeadContext,此时会调用HeadContext的channelRead方法(方法实现在其父类DefaultChannelPipeline中):
// io.netty.channel.DefaultChannelPipeline.HeadContext#channelRead
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ctx.fireChannelRead(msg);
}
// io.netty.channel.AbstractChannelHandlerContext#fireChannelRead
@Override
public ChannelHandlerContext fireChannelRead(final Object msg) {
invokeChannelRead(findContextInbound(), msg);
return this;
}
// io.netty.channel.AbstractChannelHandlerContext#findContextInbound
private AbstractChannelHandlerContext findContextInbound() {
AbstractChannelHandlerContext ctx = this;
do {
ctx = ctx.next;
} while (!ctx.inbound);
return ctx;
}
// io.netty.channel.AbstractChannelHandlerContext#invokeChannelRead(io.netty.channel.AbstractChannelHandlerContext, java.lang.Object)
static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
EventExecutor executor = next.executor();
if (executor.inEventLoop()) {
next.invokeChannelRead(m);
} else {
executor.execute(new Runnable() {
@Override
public void run() {
next.invokeChannelRead(m);
}
});
}
}
我们发现,在AbstractChannelHandlerContext中也有个fireChannelRead方法,该方法调用了findContextInbound方法查找了pipeline的next下一个Handler,然后调用下一个Handler的channelRead方法,如此重复。
也就是说,在Handler的channelRead方法中,调用ChannelHandlerContext的fireChannelRead方法,就会将消息传递给下一个Handler。
2、outbound——connect
我们以connect方法来分析出站源码:
// io.netty.channel.DefaultChannelPipeline#connect(java.net.SocketAddress, java.net.SocketAddress, io.netty.channel.ChannelPromise)
@Override
public final ChannelFuture connect(
SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) {
// 从tail开始调用connect事件
return tail.connect(remoteAddress, localAddress, promise);
}
// io.netty.channel.AbstractChannelHandlerContext#connect(java.net.SocketAddress, java.net.SocketAddress, io.netty.channel.ChannelPromise)
@Override
public ChannelFuture connect(
final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) {
if (remoteAddress == null) {
throw new NullPointerException("remoteAddress");
}
if (isNotValidPromise(promise, false)) {
// cancelled
return promise;
}
final AbstractChannelHandlerContext next = findContextOutbound();
EventExecutor executor = next.executor();
if (executor.inEventLoop()) {
next.invokeConnect(remoteAddress, localAddress, promise);
} else {
safeExecute(executor, new Runnable() {
@Override
public void run() {
next.invokeConnect(remoteAddress, localAddress, promise);
}
}, promise, null);
}
return promise;
}
// io.netty.channel.AbstractChannelHandlerContext#invokeConnect
private void invokeConnect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) {
if (invokeHandler()) {
try {
((ChannelOutboundHandler) handler()).connect(this, remoteAddress, localAddress, promise);
} catch (Throwable t) {
notifyOutboundHandlerException(t, promise);
}
} else {
connect(remoteAddress, localAddress, promise);
}
}
我们发现,也是链式的调用ChannelOutboundHandler的connect方法,与入站如出一辙。
3、总结
Context包装handler,多个Context在pipeline中形成了双向链表,入站方向叫inbound,由head节点开始,出站方法叫outbound,由tail节点开始。
节点中间的传递通过AbstractChannelHandlerContext内部的fire系列方法,找到当前节点的下一个节点不断地进行传播,以链式完成对handler的调度。
到此时,我们Netty从请求建立、请求接收、请求处理的整个过程源码已经全部分析完毕