什么'；Netty ChannelHandler和#x27；s例外CAUGHT和CHANNEL无效

我正在学习Netty，被ChannelHandler的channelInactive和exceptionCaught弄糊涂了

据我所知，当服务器关闭时，客户机将获得IOEEException，但如果服务器显式关闭通道，客户机将获得WRITE_IDEL事件，并且它可以定义后期处理本身

但是从下面的演示中，我得到了不同的结果。我关闭了服务器，客户端跳转到channelInactive方法，但也不例外

ClientHandler：

package echoclient;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.util.CharsetUtil;

import java.io.IOException;
import java.net.SocketAddress;
import java.util.concurrent.TimeUnit;

/**
 * Created by lulijun on 2018/2/12.
 */
@ChannelHandler.Sharable
public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {



    @Override
    public void channelActive(ChannelHandlerContext ctx) {

        System.out.println("channel active");
    }


    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channel inactive");
    }


    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf in) throws Exception {

        System.out.println("Client received: "+in.toString(CharsetUtil.UTF_8));


    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleState state= ((IdleStateEvent) evt).state();
            if (state == IdleState.WRITER_IDLE) {
                // read timeout, break the channel
                System.out.println("client write timeout");
                SocketAddress remoteAddress = ctx.channel().remoteAddress();

            }
        }
    }



    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {


        System.out.println("channel exception");
        cause.printStackTrace();

        if (cause instanceof IOException) {

            SocketAddress remoteAddress = ctx.channel().remoteAddress();

           // reconnect
            ctx.channel().close();
            ctx.connect(remoteAddress);
        } else {
            ctx.channel().close();
        }

    }


    protected void messageReceived(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        System.out.println("Client received: "+msg.toString(CharsetUtil.UTF_8));
    }
}

package客户端；
导入io.netty.buffer.ByteBuf；
导入io.netty.buffer.Unpooled；
导入io.netty.channel.ChannelHandler；
导入io.netty.channel.ChannelHandlerContext；
导入io.netty.channel.SimpleChannelInboundHandler；
导入io.netty.handler.timeout.idlstate；
导入io.netty.handler.timeout.IDLESTATEVENT；
导入io.netty.util.CharsetUtil；
导入java.io.IOException；
导入java.net.SocketAddress；
导入java.util.concurrent.TimeUnit；
/**
*卢立军于2018年2月12日创作。
*/
@ChannelHandler.可共享
公共类EchoClientHandler扩展了SimpleChannelInboundHandler{
@凌驾
public void channelActive（ChannelHandlerContext ctx）{
System.out.println（“通道激活”）；
}
@凌驾
public void channelInactive（ChannelHandlerContext ctx）引发异常{
System.out.println（“通道不活动”）；
}
受保护的无效channelRead0（ChannelHandlerContext ctx，ByteBuf in）引发异常{
System.out.println（“客户端接收：+in.toString（CharsetUtil.UTF_8））；
}
@凌驾
public void userEventTriggered（ChannelHandlerContext ctx，Object evt）引发异常{
if（IdleStateEvent的evt实例）{
IdleState=（（IDLESTATEVENT）evt.state（）；
if（state==IdleState.WRITER\u IDLE）{
//读取超时，断开通道
System.out.println（“客户端写入超时”）；
SocketAddress remoteAddress=ctx.channel（）.remoteAddress（）；
}
}
}
@凌驾
公共无效例外情况（ChannelHandlerContext ctx，可丢弃原因）{
System.out.println（“通道异常”）；
cause.printStackTrace（）；
如果（导致IOException实例）{
SocketAddress remoteAddress=ctx.channel（）.remoteAddress（）；
//重新连接
ctx.channel（）.close（）；
ctx.connect（远程地址）；
}否则{
ctx.channel（）.close（）；
}
}
受保护的void messageReceived（ChannelHandlerContext ctx，ByteBuf msg）引发异常{
System.out.println（“客户端接收：+msg.toString（CharsetUtil.UTF_8））；
}
}

当通道关闭时，将执行channelInActive方法，因此连接也将关闭

入站处理程序引发的任何异常都将“向上”传播管道并调用此处理程序的exceptionCaught（）方法，前提是下面的处理程序不使用它们