Netty学习篇④-心跳机制及断线重连

心跳检测

前言

客户端和服务端的连接属于socket连接，也属于长连接，往往会存在客户端在连接了服务端之后就没有任何操作了，但还是占用了一个连接；当越来越多类似的客户端出现就会浪费很多连接，netty中可以通过心跳检测来找出一定程度（自定义规则判断哪些连接是无效链接）的无效链接并断开连接，保存真正活跃的连接。

什么叫心跳检测

我理解的心跳检测应该是客户端/服务端定时发送一个数据包给服务端/客户端，检测对方是否有响应；
如果是存活的连接，在一定的时间内应该会收到响应回来的数据包；
如果在一定时间内还是收不到接收方的响应的话，就可以当做是挂机，可以断开此连接；
如果检测到了掉线之后还可以进行重连；

心跳检测的实现

• TCP自带心跳检测，协议层采用Keeplive机制默认2小时频率触发一次检测，但是它存在缺陷:检测不出网线拔出、防火墙、使用起来不灵活、依赖操作系统等
• Netty可以通过IdleStateHandler来实现心跳检测，使用起来也非常方便清晰

IdleStateHandler原理

idleStateHandler在通道注册之后会开启一个定时任务，定时去检测通道中后续是否还有进行数据传输，如果在规定的时间内没有进行数据传输则会触发对应的超时事件，使用者可以根据对应的事件自定义规则来判别当前连接是否是活跃，是否需要关闭连接等来进行操作。
一般idleStateHandler触发的事件IdleStateEvent会在心跳handler中的userEventTriggered方法中捕获到对应的超时事件。

IdleStateHandler的继承关系：通过ChannelDuplexHandler类继承ChannelInboundHandler和实现ChannelOutboundHandler来实现对入站和出站的重写和监控

源码分析

• IdleStateHandler初始化：为0代表不监控

  /**
  * @observeOutput 观察输出
  * @readerIdleTime 读超时时间 自定义时间内检测Channel通道有没有读取到数据，为0代表不监控
  * @writerIdleTime 写超时时间 自定义时间内检测Channel通道有没有write数据，为0代表不监控
  * @allIdleTime 总超时时间 自定义时间内检测Channel通道有没有读/写数据，为0代表不监控
  * @unit 时间单位
  */
  public IdleStateHandler(boolean observeOutput,
              long readerIdleTime, long writerIdleTime, long allIdleTime,
              TimeUnit unit) {
          if (unit == null) {
              throw new NullPointerException("unit");
          }
  
          this.observeOutput = observeOutput;
  
      	// 初始化读取空闲时间，最小值为0
          if (readerIdleTime <= 0) {
              readerIdleTimeNanos = 0;
          } else {
              // 定义读取超时时间为自定义设置时间
              readerIdleTimeNanos = Math.max(unit.toNanos(readerIdleTime), MIN_TIMEOUT_NANOS);
          }
          if (writerIdleTime <= 0) {
              writerIdleTimeNanos = 0;
          } else {
              // 设置写超时时间
              writerIdleTimeNanos = Math.max(unit.toNanos(writerIdleTime), MIN_TIMEOUT_NANOS);
          }
          if (allIdleTime <= 0) {
              allIdleTimeNanos = 0;
          } else {
              // 设置总超时时间
              allIdleTimeNanos = Math.max(unit.toNanos(allIdleTime), MIN_TIMEOUT_NANOS);
          }
      }
  

• IdleStateHandler和channel通道的关联：通过类图可以得知，idleStateHandler可以重写入站和出站的方法，不过只是通过channelRead和write方法来记录阅读的时间等不做其他操作

  @Override
  public void channelActive(ChannelHandlerContext ctx) throws Exception {
      // 初始化检测器，开启定时任务
      initialize(ctx);
      super.channelActive(ctx);
  }
  
  @Override
  public void channelInactive(ChannelHandlerContext ctx) throws Exception {
      // 在通道非活跃状态的时候销毁定时任务
      destroy();
      super.channelInactive(ctx);
  }
  
  @Override
  public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
      // 如果设置的读超时时间大于0则设置是否读操作为true
      if (readerIdleTimeNanos > 0 || allIdleTimeNanos > 0) {
          reading = true;
          firstReaderIdleEvent = firstAllIdleEvent = true;
      }
      // 记录时间和标识标志之后就直接fire当前read到下一个ChannelHandler处理类中
      ctx.fireChannelRead(msg);
  }
  
  @Override
  public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
      // 当读取完毕时，设置是否正在读取为false，设置最后读取时间为系统当前时间
      if ((readerIdleTimeNanos > 0 || allIdleTimeNanos > 0) && reading) {
          lastReadTime = ticksInNanos();
          reading = false;
      }
      // 同样直接fire掉，跳入到下一个handler中
      ctx.fireChannelReadComplete();
  }
  
  // idleStateHandler重写的write方法
  @Override
  public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
      // Allow writing with void promise if handler is only configured for read timeout events.
      if (writerIdleTimeNanos > 0 || allIdleTimeNanos > 0) {
          ctx.write(msg, promise.unvoid()).addListener(writeListener);
      } else {
          ctx.write(msg, promise);
      }
  }
  
  // ChannelOutboundHandler提供的write接口方法
  /**
      * Called once a write operation is made. The write operation will write the messages through the
       * {@link ChannelPipeline}. Those are then ready to be flushed to the actual {@link Channel} once
       * {@link Channel#flush()} is called
       * 执行一次写操作；写操作通过ChannelPipeline来传输信息；最后通过channel的flush()方法来刷新
       *
       * @param ctx               the {@link ChannelHandlerContext} for which the write operation is made 实际写操作者
       * @param msg               the message to write 写的消息
       * @param promise           the {@link ChannelPromise} to notify once the operation completes 在操作完成时立即通知（类似future异步通知）
       * @throws Exception        thrown if an error occurs
       */
      void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception;
  

• 定时器初始化/销毁：将使用者自定义的超时时间设置为延迟定时任务

  初始化：
  
  private void initialize(ChannelHandlerContext ctx) {
          // Avoid the case where destroy() is called before scheduling timeouts.
          // See: https://github.com/netty/netty/issues/143
      	// state; // 0 - none, 1 - 初始化, 2 - 销毁
          switch (state) {
          case 1:
          case 2:
              return;
          }
  
          state = 1;
          initOutputChanged(ctx);
  		// 最后读取时间
          lastReadTime = lastWriteTime = ticksInNanos();
      	// 如果设置的空闲时间大于0则开启定时任务进行监控
          if (readerIdleTimeNanos > 0) {
              readerIdleTimeout = schedule(ctx, new ReaderIdleTimeoutTask(ctx),
                      readerIdleTimeNanos, TimeUnit.NANOSECONDS);
          }
          // 写超时时间
          if (writerIdleTimeNanos > 0) {
              writerIdleTimeout = schedule(ctx, new WriterIdleTimeoutTask(ctx),
                      writerIdleTimeNanos, TimeUnit.NANOSECONDS);
          }
          // 总超时时间
          if (allIdleTimeNanos > 0) {
              allIdleTimeout = schedule(ctx, new AllIdleTimeoutTask(ctx),
                      allIdleTimeNanos, TimeUnit.NANOSECONDS);
          }
      }
  
  

  销毁：
  
  /**
  * @readerIdleTimeout ==> ScheduledFuture类
  * @writerIdleTimeout ==> ScheduledFuture类
  */
  private void destroy() {
      	// 设置销毁状态
          state = 2;
  		// 销毁线程
      	// ScheduledFuture
          if (readerIdleTimeout != null) {
              readerIdleTimeout.cancel(false);
              readerIdleTimeout = null;
          }
          if (writerIdleTimeout != null) {
              writerIdleTimeout.cancel(false);
              writerIdleTimeout = null;
          }
          if (allIdleTimeout != null) {
              allIdleTimeout.cancel(false);
              allIdleTimeout = null;
          }
      }
  

• 开启定时任务

  ScheduledFuture<?> schedule(ChannelHandlerContext ctx, Runnable task, long delay, TimeUnit unit) {
          return ctx.executor().schedule(task, delay, unit);
      }
  

• 读/写定时任务：定时任务启动的时候，通过设置的超时时间和上一次触发channelRead的时间进行相减比较来判断是否超时了

  // 仅分析读取超时时间定时任务，写超时差不多就是触发的时间不一样，比对的变量换成了设置的写超时时间
  private final class ReaderIdleTimeoutTask extends AbstractIdleTask {
  
          ReaderIdleTimeoutTask(ChannelHandlerContext ctx) {
              super(ctx);
          }
  
          @Override
          protected void run(ChannelHandlerContext ctx) {
              // readerIdleTimeNanos：初始化IdleStateHandler设置的读取超时时间
              long nextDelay = readerIdleTimeNanos;
              // 如果没有任何读取操作
              if (!reading) {
                  // 判断是否有超时
                  // nextDelay = nextDelay-（ticksInNanos() - lastReadTime）
                  // 即设置的超时时间减去距离上一次读取的时间
                  nextDelay -= ticksInNanos() - lastReadTime;
              }
  			// 如果小于等于0 则触发读取超时事件,设置新的延迟时间
              if (nextDelay <= 0) {
                  // Reader is idle - set a new timeout and notify the callback.
                  readerIdleTimeout = schedule(ctx, this, readerIdleTimeNanos, TimeUnit.NANOSECONDS);
  				// 标记为第一次
                  boolean first = firstReaderIdleEvent;
                  // 设置成非第一次
                  firstReaderIdleEvent = false;
  
                  try {
                      IdleStateEvent event = newIdleStateEvent(IdleState.READER_IDLE, first);
                      channelIdle(ctx, event);
                  } catch (Throwable t) {
                      ctx.fireExceptionCaught(t);
                  }
              } else {
                  // Read occurred before the timeout - set a new timeout with shorter delay.
                  // 超时的时候发生的读取事件，则重新延迟执行
                  readerIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);
              }
          }
      }
  

项目实战(主要代码，项目以服务端作为心跳监控，也可以在客户端进行心跳监控)

• 项目结构

  ├─src
  │  ├─main
  │  │  ├─java
  │  │  │  └─com
  │  │  │      └─hetangyuese
  │  │  │          └─netty
  │  │  │              ├─client
  │  │  │              │      MyChannelFutureListener.java
  │  │  │              │      MyClient05.java
  │  │  │              │      MyClientChannelHandler.java
  │  │  │              │      MyClientChannelInitializer.java
  │  │  │              │
  │  │  │              └─server
  │  │  │                  │  MyServer05.java
  │  │  │                  │  MyServerChannelInitializer.java
  │  │  │                  │  MyServerHandler.java
  │  │  │                  │
  │  │  │                  └─decoder
  

• 在ChannelPipeline中注册IdleStateHandler

  public class MyServerChannelInitializer extends ChannelInitializer<SocketChannel> {
  
      @Override
      protected void initChannel(SocketChannel ch) throws Exception {
          ch.pipeline().
                  addLast(new StringEncoder(Charset.forName("GBK")))
                  .addLast(new StringDecoder(Charset.forName("GBK")))
                  .addLast(new LoggingHandler(LogLevel.INFO))
              	// 设置读取超时时间为5秒，写超时和总超时为0即不做监控
                  .addLast(new IdleStateHandler(5, 0, 0))
                  .addLast(new MyServerHandler());
      }
  }
  

• 服务端处理handler(其中userEventTriggered为接收心跳任务触发的事件，这次做了计数三次触发读空闲超时则断开连接)

  public class MyServerHandler extends ChannelInboundHandlerAdapter {
  
      private AtomicInteger count = new AtomicInteger(1);
  
      /**
       *  心跳检测机制会进入
       * @param ctx
       * @param evt
       * @throws Exception
       */
      @Override
      public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
          System.out.println("心跳检测触发了事件, object: , time: " + evt + new Date().toLocaleString());
          super.userEventTriggered(ctx, evt);
          if (evt instanceof IdleStateEvent) {
              IdleStateEvent e = (IdleStateEvent) evt;
              // 客户端连接应该是请求 write
              if (e.state() == IdleState.READER_IDLE) {
                  System.out.println("服务端监测到了读取超时");
                  count.incrementAndGet();
                  if (count.get() > 3) {
                      System.out.println("客户端还在？？ 已经3次检测没有访问了，我要断开了哦！！！");
                      ctx.channel().close();
                  }
              } else if (e.state() == IdleState.WRITER_IDLE) {
                  // 如果一直有交互则会发送writer_idle
                  System.out.println("服务端收到了写入超时");
              } else {
                  System.out.println("服务端收到了All_idle");
              }
          } else {
              super.userEventTriggered(ctx,evt);
          }
      }
  
      @Override
      public void channelActive(ChannelHandlerContext ctx) throws Exception {
          System.out.println("myServerHandler is active, time: " + new Date().toLocaleString());
          ctx.writeAndFlush("成功连接服务端, 当前时间：" + new Date().toLocaleString());
      }
  
      @Override
      public void channelInactive(ChannelHandlerContext ctx) throws Exception {
          System.out.println("服务端与客户端断开了连接, time: " + new Date().toLocaleString());
      }
  
      @Override
      public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
          System.out.println("myServerHandler 收到了客户端的信息 msg:" + msg + ", time: " + new Date().toLocaleString());
          ctx.writeAndFlush("您好，客户端，我是服务端");
      }
  
      @Override
      public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
          cause.printStackTrace();
          ctx.close();
      }
  }
  

• 运行结果

  myServer is start time: 2019-11-8 14:47:16
  myServerHandler is active, time: 2019-11-8 14:47:18
  十一月 08, 2019 2:47:18 下午 io.netty.handler.logging.LoggingHandler channelRegistered
  信息: [id: 0x8d924d06, L:/127.0.0.1:9001 - R:/127.0.0.1:62195] REGISTERED
  十一月 08, 2019 2:47:18 下午 io.netty.handler.logging.LoggingHandler channelActive
  信息: [id: 0x8d924d06, L:/127.0.0.1:9001 - R:/127.0.0.1:62195] ACTIVE
  十一月 08, 2019 2:47:18 下午 io.netty.handler.logging.LoggingHandler write
  信息: [id: 0x8d924d06, L:/127.0.0.1:9001 - R:/127.0.0.1:62195] WRITE: 成功连接服务端, 当前时间：2019-11-8 14:47:18
  十一月 08, 2019 2:47:18 下午 io.netty.handler.logging.LoggingHandler flush
  信息: [id: 0x8d924d06, L:/127.0.0.1:9001 - R:/127.0.0.1:62195] FLUSH
  心跳检测触发了事件, object: , time: io.netty.handler.timeout.IdleStateEvent@a3a0212019-11-8 14:47:23
  服务端监测到了读取超时
  心跳检测触发了事件, object: , time: io.netty.handler.timeout.IdleStateEvent@18692702019-11-8 14:47:28
  服务端监测到了读取超时
  心跳检测触发了事件, object: , time: io.netty.handler.timeout.IdleStateEvent@18692702019-11-8 14:47:33
  服务端监测到了读取超时
  客户端还在？？ 已经3次检测没有访问了，我要断开了哦！！！
  十一月 08, 2019 2:47:33 下午 io.netty.handler.logging.LoggingHandler close
  信息: [id: 0x8d924d06, L:/127.0.0.1:9001 - R:/127.0.0.1:62195] CLOSE
  十一月 08, 2019 2:47:33 下午 io.netty.handler.logging.LoggingHandler channelInactive
  信息: [id: 0x8d924d06, L:/127.0.0.1:9001 ! R:/127.0.0.1:62195] INACTIVE
  服务端与客户端断开了连接, time: 2019-11-8 14:47:33
  十一月 08, 2019 2:47:33 下午 io.netty.handler.logging.LoggingHandler channelUnregistered
  信息: [id: 0x8d924d06, L:/127.0.0.1:9001 ! R:/127.0.0.1:62195] UNREGISTERED
  

以上就是心跳监控的所有流程了，合理的利用Netty的心跳机制可以有效的剔除一些无用的连接释放些资源

---

Netty断线重连: 在长连接中有时候出现断开的时候可以重新连接出现断线重连的情况：

• 首次连接但是连接不上，通过ChannelFutureListener增加监控进行重连
• 由于网络原因等、自动断开等 通过在channelInactive中进行重连即可

ChannelFutureListener进行重连

public class MyChannelFutureListener implements ChannelFutureListener {

    @Override
    public void operationComplete(ChannelFuture future) throws Exception {
        if (future.isSuccess()) {
            System.out.println("当前已连接");
            return;
        }
        System.out.println("启动连接客户端失败，开始重连");
        final EventLoop loop = future.channel().eventLoop();
        loop.schedule(new Runnable() {
            @Override
            public void run() {
                try {
                   MyClient05.reConnection();
                   System.out.println("客户端重连成功");
                } catch (Exception e){
                    e.printStackTrace();
                }
            }
        }, 1L, TimeUnit.SECONDS);
    }
}

**client启动 **不知道为啥想要测试listener的效果时，connect的sync()不能带，是由于同步阻塞的原因？

public void start() {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            bootstrap = getBootstrap();

            bootstrap.group(group)
                    .option(ChannelOption.AUTO_READ, true)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .channel(NioSocketChannel.class)
                    .handler(new MyClientChannelInitializer());

            // ChannelFuture future = bootstrap.connect(new InetSocketAddress(ip, port)).sync();
             ChannelFuture future = bootstrap.connect(new InetSocketAddress(ip, port));
            // 增加监听
            future.addListener(new MyChannelFutureListener());
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();
        }
    }

直接启动客户端，可以看到listener输出：启动连接客户端失败，开始重连

channelInactive进行重连(我是直接new了一个线程去重连)

@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    System.out.println("客户端断开了连接, time: " + new Date().toLocaleString());
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                new MyClient05("127.0.0.1", 9001).start();
                System.out.println("客户端重新连接了服务端 time：" + new Date().toLocaleString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }).start();
}

测试方法：

1.可以直接通过上面的心跳机制断开连接后，客户端的channelInactive检测到断开会自动执行重连

测试结果：

服务端：
------
心跳检测触发了事件, object: , time: io.netty.handler.timeout.IdleStateEvent@ab81552019-11-8 16:43:12
服务端监测到了读取超时
心跳检测触发了事件, object: , time: io.netty.handler.timeout.IdleStateEvent@15192622019-11-8 16:43:17
服务端监测到了读取超时
心跳检测触发了事件, object: , time: io.netty.handler.timeout.IdleStateEvent@15192622019-11-8 16:43:22
服务端监测到了读取超时
客户端还在？？ 已经3次检测没有访问了，我要断开了哦！！！
十一月 08, 2019 4:43:22 下午 io.netty.handler.logging.LoggingHandler close
信息: [id: 0x6bfc0d90, L:/192.168.0.118:9001 - R:/192.168.0.118:51031] CLOSE
十一月 08, 2019 4:43:22 下午 io.netty.handler.logging.LoggingHandler channelInactive
信息: [id: 0x6bfc0d90, L:/192.168.0.118:9001 ! R:/192.168.0.118:51031] INACTIVE
十一月 08, 2019 4:43:22 下午 io.netty.handler.logging.LoggingHandler channelUnregistered
信息: [id: 0x6bfc0d90, L:/192.168.0.118:9001 ! R:/192.168.0.118:51031] UNREGISTERED
服务端与客户端断开了连接, time: 2019-11-8 16:43:22
十一月 08, 2019 4:43:22 下午 io.netty.handler.logging.LoggingHandler channelRegistered
信息: [id: 0xbcb2ec62, L:/127.0.0.1:9001 - R:/127.0.0.1:51061] REGISTERED
十一月 08, 2019 4:43:22 下午 io.netty.handler.logging.LoggingHandler channelActive
信息: [id: 0xbcb2ec62, L:/127.0.0.1:9001 - R:/127.0.0.1:51061] ACTIVE
myServerHandler is active, time: 2019-11-8 16:43:22
十一月 08, 2019 4:43:22 下午 io.netty.handler.logging.LoggingHandler write
信息: [id: 0xbcb2ec62, L:/127.0.0.1:9001 - R:/127.0.0.1:51061] WRITE: 成功连接服务端, 当前时间：2019-11-8 16:43:22
十一月 08, 2019 4:43:22 下午 io.netty.handler.logging.LoggingHandler flush
信息: [id: 0xbcb2ec62, L:/127.0.0.1:9001 - R:/127.0.0.1:51061] FLUSH
十一月 08, 2019 4:43:26 下午 io.netty.handler.logging.LoggingHandler channelReadComplete
------------------------------------------------------------------------------------- 

客户端：
-------
当前已连接
客户端与服务端建立了连接 time: 2019-11-8 16:43:07
客户端接收到了服务的响应的数据 msg: 成功连接服务端, 当前时间：2019-11-8 16:43:07, time: 2019-11-8 16:43:07
客户端断开了连接, time: 2019-11-8 16:43:22
当前已连接
客户端与服务端建立了连接 time: 2019-11-8 16:43:22
客户端接收到了服务的响应的数据 msg: 成功连接服务端, 当前时间：2019-11-8 16:43:22, time: 2019-11-8 16:43:22