1. 首页
  2. 文章中心
  3. 网络编程&netty

【Netty4】Netty心跳检测机制1 IdleStateHandler示例1. 概述2. 超时样例3. 不超时演示4. 参考

172 阅读 0 评论
我是靠谱客的博主 糟糕丝袜，这篇文章主要介绍【Netty4】Netty心跳检测机制1 IdleStateHandler示例1. 概述2. 超时样例3. 不超时演示4. 参考，现在分享给大家，希望可以做个参考。

文章目录

  • 1. 概述
  • 2. 超时样例
    • 2.1 代码
    • 2.2 执行
  • 3. 不超时演示
    • 3.1 修改代码
    • 3.2 执行
  • 4. 参考

系列文章：
《Netty心跳检测机制1 IdleStateHandler示例》
《Netty心跳检测机制2 IdleStateHandler原理分析》

1. 概述

所谓心跳, 即在 TCP 长连接中, 客户端和服务器之间定期发送的一种特殊的数据包, 通知对方自己还在线, 以确保 TCP 连接的有效性。

在 Netty 中, 实现心跳机制的关键是 IdleStateHandler, 看下它的构造器：

复制代码
1
2
3
4
 public IdleStateHandler(int readerIdleTimeSeconds, int writerIdleTimeSeconds, int allIdleTimeSeconds) {
   this((long)readerIdleTimeSeconds, (long)writerIdleTimeSeconds, (long)allIdleTimeSeconds, TimeUnit.SECONDS);
}

2. 超时样例

2.1 代码

HeartBeatServer ：

复制代码
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package com.netty.heartbeat;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

public class HeartBeatServer {

    public static void main(String[] args) throws Exception {
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(boss, worker)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            //IdleStateHandler的readerIdleTime参数指定超过3秒还没收到客户端的连接，
                            //会触发IdleStateEvent事件并且交给下一个handler处理，下一个handler必须
                            //实现userEventTriggered方法处理对应事件
                            pipeline.addLast(new IdleStateHandler(3, 0, 0, TimeUnit.SECONDS));
                            pipeline.addLast(new HeartBeatServerHandler());
                        }
                    });
            System.out.println("netty server start。。");
            ChannelFuture future = bootstrap.bind(9000).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            worker.shutdownGracefully();
            boss.shutdownGracefully();
        }
    }
}

核心是在服务器端注册IdleStateHandler

timeout是3s，超过这个时长，就会记一次超时，当总次数到达一定次数后，用户就可以最终认定超时。

IdleStateHandler会自动触发事件，事件被HeartBeatServerHandler 中的userEventTriggered()方法捕获，此时用户可以根据实际需求做响应的处理。

HeartBeatServerHandler ：

复制代码
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package com.netty.heartbeat;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.timeout.IdleStateEvent;

public class HeartBeatServerHandler extends SimpleChannelInboundHandler<String> {

    int readIdleTimes = 0;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String s) throws Exception {
        System.out.println(" ====== > [server] message received : " + s);
        if ("Heartbeat Packet".equals(s)) {
            ctx.channel().writeAndFlush("ok");
        } else {
            System.out.println(" 其他信息处理 ... ");
        }
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        IdleStateEvent event = (IdleStateEvent) evt;

        String eventType = null;
        switch (event.state()) {
            case READER_IDLE:
                eventType = "读空闲";
                readIdleTimes++; // 读空闲的计数加1
                break;
            case WRITER_IDLE:
                eventType = "写空闲";
                // 不处理
                break;
            case ALL_IDLE:
                eventType = "读写空闲";
                // 不处理
                break;
        }



        System.out.println(ctx.channel().remoteAddress() + "超时事件：" + eventType);
        if (readIdleTimes > 3) {
            System.out.println(" [server]读空闲超过3次，关闭连接，释放更多资源");
            ctx.channel().writeAndFlush("idle close");
            ctx.channel().close();
        }
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.err.println("=== " + ctx.channel().remoteAddress() + " is active ===");
    }
}

HeartBeatClient (包含内部类HeartBeatClientHandler)：

复制代码
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package com.netty.heartbeat;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
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 java.util.Random;

public class HeartBeatClient {
    public static void main(String[] args) throws Exception {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            pipeline.addLast(new HeartBeatClientHandler());
                        }
                    });

            System.out.println("netty client start。。");
            Channel channel = bootstrap.connect("127.0.0.1", 9000).sync().channel();
            String text = "Heartbeat Packet";
            Random random = new Random();
            while (channel.isActive()) {
                int num = random.nextInt(8);
                Thread.sleep(num * 1000);
                channel.writeAndFlush(text);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            eventLoopGroup.shutdownGracefully();
        }
    }

    static class HeartBeatClientHandler extends SimpleChannelInboundHandler<String> {

        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
            System.out.println(" client received :" + msg);
            if (msg != null && msg.equals("idle close")) {
                System.out.println(" 服务端关闭连接，客户端也关闭");
                ctx.channel().closeFuture();
            }
        }
    }
}

客户端向服务端发起连接后，通过while循环间隔某个时长发送消息，此时，我们这里的间隔时长超过了timeout参数，因此会造成超时效果。

并且 random.nextInt(8) 会随机生成间隔时间，如果小于3s，则是一个非超时的请求，超过3s是超时请求。因此执行结果不会完全一致。

2.2 执行

客户端代码 random.nextInt(8) 会随机生成间隔时间，如果小于3s，则是一个非超时的请求，超过3s是超时请求。因此执行结果不会完全一致。

服务端：
在这里插入图片描述
服务端发现客户端与自己的连接，发生了3次超时，进而主动关闭了连接。

上图中服务端收到的Heartbeat Packet次数是随机的，并且存在一定的瑕疵，比如，当读空闲之间出现一次有效消息后，应用重置，而本例没有重置。

客户端：
在这里插入图片描述

客户端发现服务端关闭连接后，自己也主动退出。

3. 不超时演示

3.1 修改代码

我们修改客户端发送消息的间隔时长，timeout是3s，那么我们把间隔改为2s，这样就保证一直有消息发送，就不会触发超时检查了。

修改HeartBeatClient类：

复制代码
1
2
3

Thread.sleep(2 * 1000);

3.2 执行

服务端：一直接收消息，不会认定超时
在这里插入图片描述
客户端，一直在发送消息：
在这里插入图片描述

4. 参考

《Netty学习（五）—IdleStateHandler心跳机制》

最后

以上就是糟糕丝袜最近收集整理的关于【Netty4】Netty心跳检测机制1 IdleStateHandler示例1. 概述2. 超时样例3. 不超时演示4. 参考的全部内容，更多相关【Netty4】Netty心跳检测机制1内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(114)

相关文章

unity使用线程做一个心跳的效果
unity使用线程做一个心跳的效果
unity 双屏，多屏幕显示在项目实践中遇到多屏幕展示需求 ，我们可以通过关于其中一些坑点多屏幕识别 （当前鼠标在哪个屏幕活跃）
unity 双屏，多屏幕显示在项目实践中遇到多屏幕展示需求 ，我们可以通过关于其中一些坑点多屏幕识别 （当前鼠标在哪个屏幕活跃）
客户端框架~心跳机制实现1) 背景2) 实现
客户端框架~心跳机制实现1) 背景2) 实现
浅析 Netty心跳机制
浅析 Netty心跳机制
【Netty4】Netty心跳检测机制1 IdleStateHandler示例1. 概述2. 超时样例3. 不超时演示4. 参考
【Netty4】Netty心跳检测机制1 IdleStateHandler示例1. 概述2. 超时样例3. 不超时演示4. 参考
一起学Netty（十二）之 Netty心跳简单Demo
一起学Netty（十二）之 Netty心跳简单Demo
netty heartbeat机制前提：问题由来解决办法最终实现
netty heartbeat机制前提：问题由来解决办法最终实现
Netty 心跳检测心跳检测
Netty 心跳检测心跳检测

评论列表共有 0 条评论

立即
投稿
返回
顶部