netty心跳检测一什么是心跳检测机制二 netty 心跳工作原理三 netty 客户端实现心跳机制netty教程

106 阅读 0 评论 70 点赞

我是靠谱客的博主欣慰老虎，这篇文章主要介绍netty心跳检测一什么是心跳检测机制二 netty 心跳工作原理三 netty 客户端实现心跳机制netty教程，现在分享给大家，希望可以做个参考。

一什么是心跳检测机制

心跳是指，在TCP长连接中客户端和服务端定期的互相发送数据包，这样可以确保服务的正确运行，保证服务在线和TCP长连接的可靠性；通常的心跳实现机制是客户端定期的向服务端发送数据包，服务端接收到数据后进行应答，这样就保证了TCP的长连接；当然也有做法是服务端做心跳，如果客户端没有应答，就关闭对应的连接，节省资源，但是这种情况毕竟罕见！

二 netty 心跳工作原理

netty 中进行实现心跳机制是，当客户端写空闲时就可以向服务端发送数据包，服务端收到心跳包后进行回复；关键点就是如何判定客户端是处于写空闲状态；netty中提供了 IdleStateHandler 的处理器；可以监听通道的读写状态；

readerIdleTime表示读超时
writerIdleTime 表示写超时
allIdleTime 表示读写超时
unit 表示时间单位

复制代码

1
2
3
4
public IdleStateHandler(long readerIdleTime, long writerIdleTime, long allIdleTime, TimeUnit unit) {
        this(false, readerIdleTime, writerIdleTime, allIdleTime, unit);
    }

三 netty 客户端实现心跳机制

在客户端连接时启动加入监听事件
pipeline.addLast("ping", new IdleStateHandler(30, 20, 90, TimeUnit.SECONDS));

表示读 30 秒空闲，写 20 秒空闲；读写 90 秒空闲

复制代码

public void connect(int port, String host) throws InterruptedException {

// 创建线程组
        NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup();
        // netty启动辅助类
        Bootstrap bootstrap = new Bootstrap();
        //
        bootstrap.group(nioEventLoopGroup)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.TCP_NODELAY, true)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        // 处理IO事件
                        ChannelPipeline pipeline = socketChannel.pipeline();
                        // 心跳检测
                        pipeline.addLast("ping", new IdleStateHandler(30, 20, 90, TimeUnit.SECONDS));
                        pipeline.addLast(new StringEncoder());
                        pipeline.addLast(new StringDecoder());
                        //
                        pipeline.addLast(new NettyClientHandler());

}
                });
        // 异步操作
        ChannelFuture connect = bootstrap.connect(host, port).sync();
        // 关闭客户端
        connect.channel().closeFuture().sync();
        // 退出线程组
        nioEventLoopGroup.shutdownGracefully();
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 public void connect(int port, String host) throws InterruptedException {

        // 创建线程组
        NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup();
        // netty启动辅助类
        Bootstrap bootstrap = new Bootstrap();
        //
        bootstrap.group(nioEventLoopGroup)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.TCP_NODELAY, true)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        // 处理IO事件
                        ChannelPipeline pipeline = socketChannel.pipeline();
                        // 心跳检测
                        pipeline.addLast("ping", new IdleStateHandler(30, 20, 90, TimeUnit.SECONDS));
                        pipeline.addLast(new StringEncoder());
                        pipeline.addLast(new StringDecoder());
                        //
                        pipeline.addLast(new NettyClientHandler());

                    }
                });
        // 异步操作
        ChannelFuture connect = bootstrap.connect(host, port).sync();
        // 关闭客户端
        connect.channel().closeFuture().sync();
        // 退出线程组
        nioEventLoopGroup.shutdownGracefully();
    }

然后在处理器中实现 userEventTriggered 方法对当前的通道状态进行判定，然后根据不同的状态发送心跳包；在客户端我们只需要是写空闲的时候发送心跳包即可；

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@Slf4j
public class NettyClientHandler extends ChannelInboundHandlerAdapter {




    public NettyClientHandler() {
        super();
    }

    // ......

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent e = (IdleStateEvent) evt;
            switch (e.state()) {
                case READER_IDLE:
                    System.out.println("读空闲");
                    break;
                case WRITER_IDLE:
                    // 写空闲，发送心跳
                    System.out.println("写空闲，发送心跳包");
                    ctx.writeAndFlush("1");
                    break;
                case ALL_IDLE:
                    System.out.println("读写空闲");
                    break;
                default:
                    break;
            }
        }
        super.userEventTriggered(ctx, evt);
    }
}