Netty之心跳重连

最新推荐文章于 2024-07-22 09:58:12 发布
最新推荐文章于 2024-07-22 09:58:12 发布
阅读量360 收藏
点赞数
分类专栏： 网络编程 文章标签： java netty 心跳重连
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangtianjiao/article/details/105855786
版权

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

为什么需要心跳
因为网络的不可靠性，有可能在TCP保持长连接的过程中，由于某些突发情况，例如网线被拔出，突然掉电等，会造成服务器和客户端的连接中断。在这些突发情况下，如果恰好服务器和客户端之间没有交互的话，那么它们是不能在短时间内发现对方已经掉线的.。为了解决这个问题，我们就需要引入心跳机制。心跳机制的工作原理是：在服务器和客户端之间一定时间内没有数据交互时，即处于idle状态时，客户端或服务器会发送一个特殊的数据包给对方，当接收方收到这个数据报文后，也立即发送一个特殊的数据报文，回应发送方，此时就完成了一次PING-PONG的交互。自然地，当某一端收到心跳消息后，就知道了对方仍然在线，这就确保TCP连接的有效性。

Netty中，实现心跳机制的关键是IdleStateHandler，它可以对一个channel的读/写设置定时器，当channel在一定事件间隔内没有数据交互时(即处于idle状态)，就会触发指定的事件。
有关IdleStateHandler原理分析：https://www.cnblogs.com/duan2/p/8919458.html

实例演示
客户端和服务器通过TCP长连接进行通信，TCP报文格式如下：

+--------+-----+---------------+ 
| Length |Type |   Content     |
|   17   |  1  |"HELLO, WORLD" |
+--------+-----+---------------+
  1. 客户端每隔一个随机的时间后, 向服务器发送消息, 服务器收到消息后, 立即将收到的消息原封不动地回复给客户端。
  2. 若客户端在指定的时间间隔内没有读/写操作，则客户端会自动向服务器发送一个PING心跳，服务器收到PING心跳消息时，需要回复一个PONG消息。

CustomHeartbeatHandler捕获IdleStateHandler触发的IdleStateEvent事件，在userEventTriggered中接收不同类型的事件做出相应的处理，并且负责心跳的发送和接收。

public abstract class CustomHeartbeatHandler extends SimpleChannelInboundHandler<ByteBuf> {

    public static final byte PING_MSG = 1;
    public static final byte PONG_MSG = 2;
    public static final byte DATA_MSG = 3;
    protected String name;
    private int heartbeatCount = 0;

    public CustomHeartbeatHandler(String name) {
        this.name = name;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;
        if (byteBuf.getByte(4) == PING_MSG) {
            sendPongMsg(ctx);
        } else if (byteBuf.getByte(4) == PONG_MSG) {

            System.out.println(name
                    + " get pong msg from " + ctx.channel().remoteAddress());
        } else {
            handleData(ctx, byteBuf);
        }
    }

    protected void sendPingMsg(ChannelHandlerContext context) {
        ByteBuf buf = context.alloc().buffer(Constant.PACK_BASE_LENGTH);
        buf.writeInt(Constant.PACK_BASE_LENGTH); // 长度域长4 + 消息类型1
        buf.writeByte(PING_MSG);
        context.writeAndFlush(buf);
        heartbeatCount++;

        System.out.println(name
                + " sent ping msg to " + context.channel().remoteAddress()
                + " count: " + heartbeatCount
                + " current time: " + DateUtil.dateFormat());
    }

    private void sendPongMsg(ChannelHandlerContext context) {
        ByteBuf buf = context.alloc().buffer(Constant.PACK_BASE_LENGTH);
        buf.writeInt(Constant.PACK_BASE_LENGTH); // 长度域长4 + 消息类型1
        buf.writeByte(PONG_MSG);
        context.channel().writeAndFlush(buf);
        heartbeatCount++;
        System.out.println(name
                + " sent pong msg to " + context.channel().remoteAddress()
                + " count: " + heartbeatCount
                + " current time: " + DateUtil.dateFormat());
    }

    protected abstract void handleData(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf);

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent e = (IdleStateEvent) evt;
            switch (e.state()) {
                case READER_IDLE:
                    handleReaderIdle(ctx);
                    break;
                case WRITER_IDLE:
                    handleWriterIdle(ctx);
                    break;
                case ALL_IDLE:
                    handleAllIdle(ctx);
                    break;
                default:
                    break;
            }
        }
    }

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

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.err.println("--- " + ctx.channel().remoteAddress() + " is inactive ---");
    }

    protected void handleReaderIdle(ChannelHandlerContext ctx) {
        System.err.println("--- READER_IDLE ---");
    }

    protected void handleWriterIdle(ChannelHandlerContext ctx) {
        System.err.println("--- WRITER_IDLE ---");
    }

    protected void handleAllIdle(ChannelHandlerContext ctx) {
        System.err.println("--- ALL_IDLE ---");
    }

    @Override
    protected void messageReceived(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {

    }
}

客户端handler
接收服务端相应数据，读写空闲发送ping包，tcp断线重连。

public class ClientHandler extends CustomHeartbeatHandler {

    private NettyClient client;

    public ClientHandler(NettyClient client) {
        super("client");
        this.client = client;
    }

    @Override
    protected void handleData(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) {
        byte[] data = new byte[byteBuf.readableBytes() - Constant.PACK_BASE_LENGTH];
        byteBuf.skipBytes(Constant.PACK_BASE_LENGTH);
        byteBuf.readBytes(data);

        System.out.println(name
                + " receive message: " + new String(data));
    }

    @Override
    protected void handleAllIdle(ChannelHandlerContext ctx) {
        super.handleAllIdle(ctx);
        sendPingMsg(ctx);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        super.channelInactive(ctx);
        client.doConnect(); // 断开tcp连接后重连
    }
}

客户端启动类

public class NettyClient {

    private NioEventLoopGroup workGroup = new NioEventLoopGroup(4);
    private Channel channel;
    private Bootstrap bootstrap;

    public void start() {
        try {
            bootstrap = new Bootstrap();
            bootstrap.group(workGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline p = socketChannel.pipeline();
                            p.addLast(new IdleStateHandler(0, 0, 5));
                            p.addLast(new LengthFieldBasedFrameDecoder(1024, 0, 4, -4, 0));
                            p.addLast(new ClientHandler(NettyClient.this));
                        }
                    });
            this.doConnect();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    protected void doConnect() {
        if (channel != null && channel.isActive()) {
            return;
        }
        ChannelFuture future = bootstrap.connect("127.0.0.1", 9527);
        future.addListener(new ChannelFutureListener() {
            public void operationComplete(ChannelFuture futureListener) throws Exception {
                if (futureListener.isSuccess()) {
                    channel = futureListener.channel();
                    System.out.println("Connect to server successfully!");
                } else {
                    System.out.println("Failed to connect to server, try connect after 10s");
                    futureListener.channel().eventLoop().schedule(new Runnable() {
                        @Override
                        public void run() {
                            doConnect();
                        }
                    }, 10, TimeUnit.SECONDS);
                }
            }
        });
    }

    public void sendData() throws Exception {
        Random random = new Random(System.currentTimeMillis());
        for (int i = 0; i < 10000; i++) {
            if (channel != null && channel.isActive()) {
                String content = "client req " + i;
                ByteBuf buf = channel.alloc().buffer(Constant.PACK_BASE_LENGTH + content.getBytes().length);
                buf.writeInt(Constant.PACK_BASE_LENGTH + content.getBytes().length);
                buf.writeByte(CustomHeartbeatHandler.DATA_MSG);
                buf.writeBytes(content.getBytes());
                channel.writeAndFlush(buf);
                System.out.println("client send message: " + content
                        + " current time: " + DateUtil.dateFormat());
            }
            Thread.sleep(random.nextInt(20000));
        }
    }

    public static void main(String[] args) throws Exception {
        NettyClient client = new NettyClient();
        client.start();
        client.sendData();
    }
}

服务端handler
接收客户端消息，读空闲时断开tcp连接

public class ServerHandler extends CustomHeartbeatHandler {

    public ServerHandler() {
        super("server");
    }

    @Override
    protected void handleData(ChannelHandlerContext channelHandlerContext, ByteBuf buf) {
        byte[] data = new byte[buf.readableBytes() - Constant.PACK_BASE_LENGTH];
        ByteBuf respBuf = Unpooled.copiedBuffer(buf);
        buf.skipBytes(Constant.PACK_BASE_LENGTH);
        buf.readBytes(data);
        System.out.println(name
                + " receive message: " + new String(data)
                + " current time: " + DateUtil.dateFormat());
        channelHandlerContext.write(respBuf);
    }

    @Override
    protected void handleReaderIdle(ChannelHandlerContext ctx) {
        super.handleReaderIdle(ctx);
        System.err.println("--- client " + ctx.channel().remoteAddress().toString() + " reader timeout, close it ---");
        ctx.close();
    }
}

服务端启动类

public class NettyServer {
    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workGroup = new NioEventLoopGroup(4);
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap
                    .group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline p = socketChannel.pipeline();
                            p.addLast(new IdleStateHandler(10, 0, 0));
                            p.addLast(new LengthFieldBasedFrameDecoder(1024, 0, 4, -4, 0));
                            p.addLast(new ServerHandler());
                        }
                    });

            Channel ch = bootstrap.bind(9527).sync().channel();
            ch.closeFuture().sync();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}

 

黑洞刺客
关注
专栏目录
netty+websocket实现心跳和断线重连
03-06
实现netty作为服务端，websocket连接成功，将channel保存到map集合，通过js发送心跳，服务端接收心跳信息并响应给客户端，当服务端断开时 客户端进行重连操作
【Netty】利用Netty实现心跳检测和重连机制
weixin_34161083的博客
05-24 373
一、前言 心跳机制是定时发送一个自定义的结构体(心跳包)，让对方知道自己还活着，以确保连接的有效性的机制。 我们用到的很多框架都用到了心跳检测，比如服务注册到 Eureka Server 之后会维护一个心跳连接，告诉 Eureka Server 自己还活着。本文就是利用 Netty 来实现心跳检测，以及客户端重连。 二、设计思路 分为客户端和服务端 ...
springboot 整合 netty框架， 实现 心跳检测，自动重连
最新发布
weixin_42487883的博客
07-22 451
依赖引入：确保引入了 Spring Boot 和 Netty 的必要依赖。Netty 服务器配置：使用配置服务器端，包括心跳检测处理。Netty 客户端配置：使用Bootstrap配置客户端，实现自动重连和心跳检测。心跳处理器：在服务器端和客户端分别实现心跳检测处理器，处理心跳包和连接超时。Spring Boot 集成：在 Spring Boot 应用启动时启动 Netty 服务器和客户端。
Netty心跳和重连
ZERO
05-23 2675
转载自：http://blog.csdn.net/z69183787/article/details/52625095 Netty应用心跳和重连的整个过程：      1）客户端连接服务端；      2）在客户端的的ChannelPipeline中加入一个比较特殊的IdleStateHandler，设置一下客户端的写空闲时间，例如5s；      3）当客户端的所有ChannelHa
netty实现客户端服务端心跳重连
抓住流浪剑客的小YI巴
08-15 3589
前言：           公司的加密机调度系统一直使用的是http请求调度的方式去调度，但是会出现网络故障导致某个客户端或者服务端断线的情况，导致很多请求信息以及回执信息丢失的情况，接着我们抛弃了http的方式，改为Tcp的方式去建立客户端和服务器之间的连接，并且要去实现断线重连的功能，经过讨论后决定使用java中成熟的nio框架 – netty去解决这一系列的问题。 1.       ne...
netty的心跳检测与断线重连
日落东山的基地
05-02 530
服务端代码 NettyServer package com.example.netty.netty2; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelOption; import io.netty.channe...
netty断线重连机制及心跳机制.rar
09-10
在本文中，我们将深入探讨 Netty 的断线重连机制和心跳机制，这两个特性对于维持稳定可靠的网络通信至关重要。 首先，让我们了解**断线重连机制**。在分布式系统中，网络连接可能会因为各种原因中断，如网络抖动、...
Netty 超时_心跳机制_断线重连 demo
08-07
配置maven添加io.netty 在com.zhao的包下的文件，可以自行修改使用
netty 断线重连+心跳
10-25
netty使用自带工具类实现断线重连和心跳包
springboot整合 netty做心跳检测
04-22
springboot整合 netty做心跳检测 springboot整合 netty做心跳检测 springboot整合 netty做心跳检测 springboot整合 netty做心跳检测 springboot整合 netty做心跳检测 springboot整合 netty做心跳检测 springboot整合...
Netty 心跳机制及断线重连
CodingAnHour
08-02 2989
netty 的服务端一般情况下不需要断线重连，应为服务端服务宕机就只能重新启动服务；空闲检测就是每隔一段时间检测子通道是否有数据读写，如果有，则子通道是正常的；如果没有，则子通道被判定为假死，关掉子通道。心跳检测是在TCP长连接中，客户端和服务端定时向对方发送数据包通知对方自己还在线，保证连接的有效性的一种机制。添加IdleStateHandler心跳检测处理器，并添加自定义处理Handler类。断线重连是指由于发生网络故障而导致服务中断的情况，客户端就需要从重新连接服务端；方法作为超时事件的逻辑处理；..
netty4长连接重连机制,心跳包
04-12
使用netty4,客户端断线重连,使用message收发数据,重写方法
netty客户端断线重连实现及问题思考
热门推荐
Brucelwl的博客
01-18 1万+
netty客户端线程给多大比较合理
Netty心跳机制和客户端重连的实现
三3三的博客
07-27 2693
一文让你搞懂Netty心跳检测和重连
Netty——心跳机制与断线重连
共勉
03-02 3139
在长连接模式下，为了保证系统的稳定行和可用性，心跳包和重连机制是必不可少的，让我们看看在Netty中怎么简单的实现吧
Netty 4.0 实现心跳检测和断线重连
zsg592713711的博客
02-17 1473
一 实现心跳检测 原理：当服务端每隔一段时间就会向客户端发送心跳包，客户端收到心跳包后同样也会回一个心跳包给服务端 一般情况下，客户端与服务端在指定时间内没有任何读写请求，就会认为连接是idle（空闲的）的。此时，客户端需要向服务端发送心跳消息，来维持服务端与客户端的链接。那么怎么判断客户端在指定时间里没有任何读写请求呢？netty中为我们提供一个特别好用的IdleStateHandler来干...
netty心跳机制和重连
shuixiou1的博客
03-21 754
netty心跳机制和重连 一、理论和概述 1、何为心跳 顾名思义, 所谓心跳, 即在 TCP 长连接中, 客户端和服务器之间定期发送的一种特殊的数据包, 通知对方自己还在线, 以确保 TCP 连接的有效性。 为什么引入心跳机制和其原理? 因为网络的不可靠性, 有可能在 TCP 保持长连接的过程中, 由于某些突发情况, 例如网线被拔出, 突然掉电等, 会造成服务器和客户端的连接中断. 在这些突发情况下, 如果恰好服务器和客户端之间没有交互的话, 那么它们是不能在短时间内发现对方已经掉线的. 为了解.
在Netty中如何实现心跳检测？如何处理客户端和服务端的断连重连？
Aaron的博客
03-06 1194
在这个Handler中，你可以根据事件的类型（读超时、写超时或读写超时）来执行相应的操作，比如发送一个心跳包或者关闭连接。综上所述，处理客户端和服务端的断连重连需要综合考虑多种因素，包括心跳检测、重连逻辑、连接池管理、异常处理和服务端容错等。在客户端和服务端的通信中，处理断连重连是一个重要的机制，以确保网络连接的稳定性和可靠性。重连次数限制：可以设置重连尝试的最大次数，如果达到最大次数仍然无法连接，则可以认为服务端不可用，并采取其他措施（如通知用户）。在实际应用中，你需要根据你的需求和环境来完善这些逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值