java实现心跳监控

先说一下实现心跳监控肯定不止一种方法，在做之前领导给的要求是用netty实现，看了一天多，用netty也算完成了一个小demo，但是对接的时候才发现服务端用的是socket io。所以我又改成了socket io 的实现方式。
肯定也还有别的实现，但是因为我没涉及所以暂时不多讲，从netty说起吧。

netty

第一步：导包

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>5.0.0.Alpha2</version
        </dependency>

关于这个netty的包，网上很多人都说了netty的向下兼容问题。不过因为我没实际遇到，所以不能给太好的建议，只能说如果遇到问题了可以往这个方向考虑考虑。
代码实现。其实这个涉及到很深奥的东西，比如什么编码解码之类的！但是因为我要做的比较简单，所以也没太仔细看这方面的东西。我这里只要实现简单的心跳监控就ok了！
主要是实现SimpleChannelInboundHandler<String>这个类。需要注意的是不同版本的netty，这个类的方法名略有不同，比如messageReceive，有的版本就叫做clientRead0。这个只能随机应变了呗。

package com.dsyl.done.netty;
 
import java.io.IOException;
import java.util.Date;
import java.util.concurrent.TimeUnit;
 
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.EventLoop;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.util.ReferenceCountUtil;
 
public class HeartBeatClientHandler extends SimpleChannelInboundHandler<String> {
 
      private ClientStarter clientStarter;
 
      public HeartBeatClientHandler(ClientStarter clientStarter) {
        this.clientStarter = clientStarter;
      }
 
      /**
       * 客户端监听写事件。也就是设置时间内没有与服务端交互则发送ping 给服务端
       */
      @Override
      public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if(evt instanceof IdleStateEvent) {
          IdleState state = ((IdleStateEvent)evt).state();
          if(state == IdleState.ALL_IDLE) {
            ctx.writeAndFlush("PING");
            System.out.println("send PING");
          }
        }
        super.userEventTriggered(ctx, evt);
      }
      /**
       * channelInactive 被触发一定是和服务器断开了。分两种情况。一种是服务端close，一种是客户端close。
       */
      @Override
      public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        super.channelInactive(ctx);
        System.err.println("客户端与服务端断开连接,断开的时间为："+(new Date()).toString());
        // 定时线程 断线重连
        final EventLoop eventLoop = ctx.channel().eventLoop();
        //设置断开连接后重连时间，此设置是断开连接一分钟（60秒）后重连
        eventLoop.schedule(() -> clientStarter.connect(), 60, TimeUnit.SECONDS);
      }
 
      /**
       * 在服务器端不使用心跳检测的情况下，如果客户端突然拔掉网线断网（注意这里不是客户度程序关闭，而仅是异常断网）
       */
      @Override
      public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        if(cause instanceof IOException) {
          System.out.println("server "+ctx.channel().remoteAddress()+"关闭连接");
        }
      }
 
    /**
     * 消息监控，监听服务端传来的消息(和netty版本有关，有的版本这个方法叫做clientRead0)
     */
      @Override
    protected void messageReceived(ChannelHandlerContext ctx, String msg) throws Exception {
        if (msg.equals("PONG")) {
              System.out.println("receive form server PONG");
            }
            ReferenceCountUtil.release(msg);
         
    }
    }

package com.dsyl.done.netty;
 
import java.net.InetSocketAddress;
 
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;
 
public class ClientStarter {
 
    private Bootstrap bootstrap;
    private int times = 0;
 
    public ClientStarter(Bootstrap bootstrap) {
        this.bootstrap = bootstrap;
        ClientStarter clientStarter = this;
        bootstrap.group(new NioEventLoopGroup())
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new StringEncoder());
                        ch.pipeline().addLast(new StringDecoder());
                        //发送消息频率。单位秒。此设置是60秒发送一次消息
                        ch.pipeline().addLast(new IdleStateHandler(60, 60, 60));
                        ch.pipeline().addLast(new HeartBeatClientHandler(clientStarter));
                    }
                });
    }
 
    public void connect() {
        ChannelFuture channelFuture = bootstrap.connect(new InetSocketAddress("ip", 端口));
        channelFuture.addListener(future ->{
                if (future.isSuccess()) {
                    System.out.println("connect to server success");
                } else {
                    System.out.println("connect to server failed,try times:" + ++times);
                    connect();
                }
        });
    }
}

就此配置完成。测试的时候new个ClientStarter对象并调用start方法就可以了。

ClientStarter starter = new ClientStarter(new Bootstrap());
starter.connect();

然后测试的时候，在本地建个服务端就测试ok，但是真的和服务端联调出现了一个问题：

这个是因为 连接成功后服务端就把客户端踹下线了。然后重复这个过程。这个是服务端设置的问题。

socket io

这个算是一种在netty上面的封装吧，反正用起来比netty还要简单方便，主要是我们服务端用的这个，我也就改成了这种形式。
第一步，导包

<!-- netty socketio -->
        <dependency>
            <groupId>com.corundumstudio.socketio</groupId>
            <artifactId>netty-socketio</artifactId>
            <version>1.7.13</version>
        </dependency>

        <dependency>
            <groupId>io.socket</groupId>
            <artifactId>socket.io-client</artifactId>
            <version>1.0.0</version>
        </dependency>

这里说一下，下面这个是客户端需要导入的依赖，上面这个。。。服务端要导入的吧？反正我看了下我们服务端的项目代码，这两个依赖都导入了。
我直接上我本地代码吧，挺简单的：

    public void connectServer() {
        String url = "http://" + serverListenIp;
        try {
            IO.Options options = new IO.Options();
            options.transports = new String[] { "websocket" };
            options.reconnectionAttempts = 1000000000;
            options.reconnectionDelay = 60000;// 失败重连的时间间隔
            options.timeout = 10000;// 连接超时时间(ms)
            // par1 是任意参数
            final Socket socket = IO.socket(url + "?userType=0", options);
            socket.on(Socket.EVENT_CONNECT, objects -> {
                System.out.println("client: 连接成功");
                System.out.println("拉取缓存的数据信息！");
                //做你想做的操作
            });
            socket.on(Socket.EVENT_CONNECTING, objects -> System.out.println("client: " + "连接中"));
            socket.on(Socket.EVENT_CONNECT_TIMEOUT, objects -> System.out.println("client: " + "连接超时"));
            socket.on(Socket.EVENT_CONNECT_ERROR, objects -> System.out.println("client: " + "连接失败"));
            socket.connect();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

这里Socket.EVENT_CONNECT，Socket.EVENT_CONNECTING等都是给定常量。不懂意思的可以看一看定义