Netty源码分析第四章: pipeline
第6节: 传播异常事件
讲完了inbound事件和outbound事件的传输流程, 这一小节剖析异常事件的传输流程
首先我们看一个最最简单的异常处理的场景:
2
3
4
5
6
7
8
9
2public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
3 throw new Exception("throw Exception");
4}
5@Override
6public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
7 System.out.println(cause.getMessage());
8}
9
我们在handler的channelRead方法中主动抛出异常, 模拟程序中出现异常的场景, 经测试会发现, 程序最终会走到exceptionCaught方法中, 获取异常对象并打印其信息
那么抛出异常之后, 是如何走到exceptionCaught方法的呢?
我们回顾之前小节channelRead事件的传播流程, channelRead方法是在AbstractChannelHandlerContext类的invokeChannelRead方法中被调用
我们跟到invokeChannelRead这个方法:
2
3
4
5
6
7
8
9
10
11
12
13
14
2 if (invokeHandler()) {
3 try {
4 //调用了当前handler的channelRead方法, 其实就是head对象调用自身的channelRead方法
5 ((ChannelInboundHandler) handler()).channelRead(this, msg);
6 } catch (Throwable t) {
7 //发生异常的时候在这里捕获异常
8 notifyHandlerException(t);
9 }
10 } else {
11 fireChannelRead(msg);
12 }
13}
14
这里不难看出, 当调用户自定义的handler的channelRead方法发生异常之后, 会被捕获, 并调用notifyHandlerException方法, 并传入异常对象, 也就是我们示例中抛出的异常
我们跟到fireChannelRead方法中:
2
3
4
5
6
7
2
3 //代码省略
4
5 invokeExceptionCaught(cause);
6}
7
再继续跟到invokeExceptionCaught方法中:
2
3
4
5
6
7
8
9
10
11
12
13
2 if (invokeHandler()) {
3 try {
4 //当前handler调用exceptionCaught()方法
5 handler().exceptionCaught(this, cause);
6 } catch (Throwable error) {
7 //代码省略
8 }
9 } else {
10 fireExceptionCaught(cause);
11 }
12}
13
走到这里一切都明白了, 这里调用了当前handler的exceptionCaught方法, 也就是我们重写的exceptionCaught方法
知道了为什么会走到exceptionCaught方法之后, 我们再进行剖析异常事件的传播流程
我还是通过两种写法来进行剖析:
2
3
4
5
6
7
8
9
10
11
12
2public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
3 System.out.println(cause.getMessage());
4}
5@Override
6public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
7 //写法1
8 ctx.fireChannelRead(cause);
9 //写法2
10 ctx.pipeline().fireExceptionCaught(cause);
11}
12
这两种写法我们并不陌生, 可能我们能直接猜到, 第一种写法是从当前节点进行传播, 第二种写法则从头结点或者尾节点进行转播, 那么和传播inbound事件或outbound事件有什么区别呢?我们先以第二种写法为例, 剖析异常事件传输的整个流程
跟到DefualtChannelPipeline的fireExceptionCaught方法中:
2
3
4
5
2 AbstractChannelHandlerContext.invokeExceptionCaught(head, cause);
3 return this;
4}
5
我们看到invokeExceptionCaught传入了head节点, 我们可以猜测, 异常事件的传播是从head节点开始的
跟进invokeExceptionCaught方法:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2 ObjectUtil.checkNotNull(cause, "cause");
3 EventExecutor executor = next.executor();
4 if (executor.inEventLoop()) {
5 //执行下一个节点的异常方法
6 next.invokeExceptionCaught(cause);
7 } else {
8 try {
9 executor.execute(new Runnable() {
10 @Override
11 public void run() {
12 next.invokeExceptionCaught(cause);
13 }
14 });
15 } catch (Throwable t) {
16 //忽略代码
17 }
18 }
19}
20
因为这里是传入的是head节点, 所以这里的next指向head节点
我们跟到invokeExceptionCaught方法中, 这里其实是headContext的父类AbstractChannelHandlerContext中的方法:
2
3
4
5
6
7
8
9
10
11
12
13
2 if (invokeHandler()) {
3 try {
4 //当前handler调用exceptionCaught()方法
5 handler().exceptionCaught(this, cause);
6 } catch (Throwable error) {
7 //代码省略
8 }
9 } else {
10 fireExceptionCaught(cause);
11 }
12}
13
这里又是我们熟悉的逻辑, 调用当前handler的exceptionCaught方法, 因为当前handler是head, 所以首先会调用headContext的exceptionCaught方法
跟进exceptionCaught方法:
2
3
4
2 ctx.fireExceptionCaught(cause);
3}
4
这里仅仅是继续传播异常事件, 这时候我们发现, 这个写法和我们刚才提到传播异常事件的两种写法的第一种写法一样:
2
3
4
5
6
7
8
2public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
3 //写法1
4 ctx.fireChannelRead(cause);
5 //写法2
6 ctx.pipeline().fireExceptionCaught(cause);
7}
8
根据我们之前的学习, 我们知道第一种写法是从当前节点传播, 而第二种写法是从头传播, 并且要求传播事件一定要使用第一种写法, 否则事件到这里会重新从头传播进而引发不可预知错误, 这个结论在异常传播同样适用, 同学们一定要注意这点
我们继续跟fireExceptionCaught方法, 这里会走到AbstractChannelHandlerContex类的fireExceptionCaught方法:
2
3
4
5
6
2 //传播异常事件的时候, 直接拿了当前节点的下一个节点
3 invokeExceptionCaught(next, cause);
4 return this;
5}
6
这个时候我们发现, 这里并没有去获取下一个的inbound节点还是outbound节点, 而是直接通过next拿到下一个节点, 这就说明在异常事件传播的过程中是不区分inbound事件还是outbound事件的, 都是直接从head节点按照链表结构往下传播,
跟到invokeExceptionCaught方法中:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
2 ObjectUtil.checkNotNull(cause, "cause");
3 EventExecutor executor = next.executor();
4 if (executor.inEventLoop()) {
5 next.invokeExceptionCaught(cause);
6 } else {
7 try {
8 executor.execute(new Runnable() {
9 @Override
10 public void run() {
11 next.invokeExceptionCaught(cause);
12 }
13 });
14 } catch (Throwable t) {
15 //代码省略
16 }
17 }
18}
19
这里又是我们熟悉的逻辑, 我们知道invokeExceptionCaught中执行了next的exceptionCaught, 这里的next, 因为我们是从head节点开始剖析的, 所以这里很有可能就是用户自定义的handler, 如果用户没有重写exceptionCaught方法, 则会交给用户handler的父类处理
我们以ChannelInboundHandlerAdapter为例看它的该方法实现:
2
3
4
5
2 throws Exception {
3 ctx.fireExceptionCaught(cause);
4}
5
我们看到这里继续向下传播了异常事件
走到这里我们会知道, 如果我们没有重写exceptionCaught方法, 异常事件会一直传播到链表的底部, 就是tail节点
我们跟到TailConext的exceptionCaught方法:
2
3
4
2 onUnhandledInboundException(cause);
3}
4
我们看到最终这里释放了异常对象
以上就是有关异常事件的传播
上一节: 传播outbound事件
下一节: 前章节内容回顾
