基于Netty4.xx的客户端指数退避重试

已于 2023-05-22 21:36:14 修改
阅读量190 收藏 1
点赞数
文章标签： websocket java
于 2023-05-21 11:39:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014635374/article/details/130790189
版权

指数退避重连: 每隔1秒，2秒，4秒， 8秒....以2的幂次来建立连接，到达一定次数之后放弃连接...

下面代码默认重试10次

直接上Netty客户端代码：

package org.jy.sso.websocket.stomp.push.netty.chat.system.client;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringEncoder;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.time.DateFormatUtils;
import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * Netty基于异步事件驱动的高性能通信框架:
 * 客户端重连处理逻辑
 */
@Slf4j
public class NettyClient {
    // 最大重试次数
    private static final int MAX_RETRY_NUM = 10;
    // 重试初始值
    private static final int INI_RETRY_NUM = 0;
    // 步长
    private static final int STEP_RETRY_NUM_LENGTH = 1;

    // 连接的端口

    private static final int NETTY_SERVER_PORT = 8000;
    // 主机IP
    private static final String NETTY_SERVER_HOST_IP = "127.0.0.1";

    public static void main(String[] args) {
        Bootstrap bootstrap = new Bootstrap();
        NioEventLoopGroup group = new NioEventLoopGroup();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel channel) {
                        // 注册字符串编码器
                        channel.pipeline().addLast(new StringEncoder());
                    }
                });
        connect(bootstrap, NETTY_SERVER_HOST_IP, NETTY_SERVER_PORT, MAX_RETRY_NUM);

    }

    /**
     * 
     *
     * @param bootstrap 客户端启动器
     * @param host      主机
     * @param port      端口
     * @param retryNum  指数退避重新连接的次数
     * @author yh19166
     * @deprecated 连接和重连机制，实现了指数退避重连
     */
    private static void connect(Bootstrap bootstrap, String host, int port, int retryNum) {
        bootstrap.connect(host, port).addListener(future -> {
            // 通过future.isSuccess() 判断是否连接成功
            if (future.isSuccess()) {
                System.out.println(DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss") + " -->> 连接成功....");
            } else if (retryNum == INI_RETRY_NUM) {
                System.out.println(DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss") + " -->> 重连次数已用完,放弃连接....");
            } else {
                // 第几次重连
                int order = (MAX_RETRY_NUM - retryNum) + STEP_RETRY_NUM_LENGTH;
                // 客户考虑重新连接的逻辑,分梯度连接......
                System.out.println("第 " + order + " 连接失败......");
                // 本次重连的间隔: 通过左移操作快速计算出重连时间间隔
                int delay = STEP_RETRY_NUM_LENGTH << order;
                System.out.println(DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss") + " -->> 连接失败,第" + order + "次重新连接....");
                // 实现定时任务逻辑
                bootstrap.config().group().schedule(() -> connect(bootstrap, host, port, retryNum - STEP_RETRY_NUM_LENGTH), delay, TimeUnit.SECONDS);
            }
        });
    }

    /**
     * @param bootstrap 客户端启动类
     * @param host      主机
     * @param port      端口
     * @param retryNum  指数退避重新连接的次数
     * @author yh19166
     * @deprecated 连接和重连机制，实现了指数退避重连
     */
    private static void retryConnect(Bootstrap bootstrap, String host, int port, int retryNum) {
        bootstrap.connect(host, port).addListener(future -> {
            if (future.isSuccess()) {
                log.info("连接服务器成功!");
            } else if (retryNum == INI_RETRY_NUM) {
                log.error("重连次数已用完，放弃连接！");
            } else {
                // 第几次重连
                int order = (MAX_RETRY_NUM - retryNum) + STEP_RETRY_NUM_LENGTH;
                // 本次重连的间隔
                int delay = STEP_RETRY_NUM_LENGTH << order;
                log.error(DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss") + ": 连接失败，第" + order + "次重新连接....");

                bootstrap.config().group().schedule(() -> connect(bootstrap, host, port, retryNum - STEP_RETRY_NUM_LENGTH), delay, TimeUnit.SECONDS);
            }
        });
    }

}

 基于Netty服务器端测试代码：

package org.jy.sso.websocket.stomp.push.netty.chat.system.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;

/**
 * 居于异步事件驱动高性能网络通信框架
 */
public class NettyServer {
    public static void main(String[] args) {
        // 服务器端启动类
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        // boss主线程（父线程）
        NioEventLoopGroup bossLoopGroup = new NioEventLoopGroup();
        // 工作线程(子线程)
        NioEventLoopGroup workerLoopGroup = new NioEventLoopGroup();
        serverBootstrap // 父子线程建立组连接
                .group(bossLoopGroup, workerLoopGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel ch) throws Exception {
                        // 初始化一个Channel(通道),pipeline(管道线)
                        // 字符串解码器
                        ch.pipeline().addLast(new StringDecoder());
                        ch.pipeline().addLast(new SimpleChannelInboundHandler<String>() {
                            @Override
                            protected void channelRead0(ChannelHandlerContext channelHandlerContext, String msg) throws Exception {
                                System.out.println("这是服务器端Netty接收到的消息: " + msg);
                            }
                        });

                    }
                }).bind(8000);
    }
}

测试结果:

11:17:38.131 [main] DEBUG io.netty.util.internal.logging.InternalLoggerFactory - Using SLF4J as the default logging framework
11:17:38.151 [main] DEBUG io.netty.channel.MultithreadEventLoopGroup - -Dio.netty.eventLoopThreads: 40
11:17:38.192 [main] DEBUG io.netty.util.internal.PlatformDependent0 - java.nio.Buffer.address: available
11:17:38.193 [main] DEBUG io.netty.util.internal.PlatformDependent0 - sun.misc.Unsafe.theUnsafe: available
11:17:38.194 [main] DEBUG io.netty.util.internal.PlatformDependent0 - sun.misc.Unsafe.copyMemory: available
11:17:38.195 [main] DEBUG io.netty.util.internal.PlatformDependent0 - direct buffer constructor: available
11:17:38.196 [main] DEBUG io.netty.util.internal.PlatformDependent0 - java.nio.Bits.unaligned: available, true
11:17:38.196 [main] DEBUG io.netty.util.internal.PlatformDependent0 - java.nio.DirectByteBuffer.<init>(long, int): available
11:17:38.197 [main] DEBUG io.netty.util.internal.Cleaner0 - java.nio.ByteBuffer.cleaner(): available
11:17:38.198 [main] DEBUG io.netty.util.internal.PlatformDependent - Platform: Windows
11:17:38.211 [main] DEBUG io.netty.util.internal.PlatformDependent - Java version: 8
11:17:38.211 [main] DEBUG io.netty.util.internal.PlatformDependent - -Dio.netty.noUnsafe: false
11:17:38.211 [main] DEBUG io.netty.util.internal.PlatformDependent - sun.misc.Unsafe: available
11:17:38.212 [main] DEBUG io.netty.util.internal.PlatformDependent - -Dio.netty.noJavassist: false
11:17:38.213 [main] DEBUG io.netty.util.internal.PlatformDependent - Javassist: unavailable
11:17:38.213 [main] DEBUG io.netty.util.internal.PlatformDependent - You don't have Javassist in your class path or you don't have enough permission to load dynamically generated classes.  Please check the configuration for better performance.
11:17:38.214 [main] DEBUG io.netty.util.internal.PlatformDependent - -Dio.netty.tmpdir: C:\Users\ADMINI~1\AppData\Local\Temp (java.io.tmpdir)
11:17:38.214 [main] DEBUG io.netty.util.internal.PlatformDependent - -Dio.netty.bitMode: 64 (sun.arch.data.model)
11:17:38.215 [main] DEBUG io.netty.util.internal.PlatformDependent - -Dio.netty.noPreferDirect: false
11:17:38.215 [main] DEBUG io.netty.util.internal.PlatformDependent - io.netty.maxDirectMemory: 15252586496 bytes
11:17:38.244 [main] DEBUG io.netty.channel.nio.NioEventLoop - -Dio.netty.noKeySetOptimization: false
11:17:38.244 [main] DEBUG io.netty.channel.nio.NioEventLoop - -Dio.netty.selectorAutoRebuildThreshold: 512
11:17:38.248 [main] DEBUG io.netty.util.internal.PlatformDependent - org.jctools-core.MpscChunkedArrayQueue: available
11:17:38.483 [main] DEBUG io.netty.channel.DefaultChannelId - -Dio.netty.processId: 16148 (auto-detected)
11:17:38.485 [main] DEBUG io.netty.util.NetUtil - -Djava.net.preferIPv4Stack: false
11:17:38.486 [main] DEBUG io.netty.util.NetUtil - -Djava.net.preferIPv6Addresses: false
11:17:39.809 [main] DEBUG io.netty.util.NetUtil - Loopback interface: lo (Software Loopback Interface 1, 127.0.0.1)
11:17:39.810 [main] DEBUG io.netty.util.NetUtil - \proc\sys\net\core\somaxconn: 200 (non-existent)
11:17:41.147 [main] DEBUG io.netty.channel.DefaultChannelId - -Dio.netty.machineId: 00:50:56:ff:fe:c0:00:01 (auto-detected)
11:17:41.149 [main] DEBUG io.netty.util.internal.ThreadLocalRandom - -Dio.netty.initialSeedUniquifier: 0xca7695bdb7e785ff
11:17:41.169 [main] DEBUG io.netty.util.ResourceLeakDetector - -Dio.netty.leakDetection.level: simple
11:17:41.169 [main] DEBUG io.netty.util.ResourceLeakDetector - -Dio.netty.leakDetection.maxRecords: 4
11:17:41.206 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.numHeapArenas: 40
11:17:41.206 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.numDirectArenas: 40
11:17:41.206 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.pageSize: 8192
11:17:41.206 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.maxOrder: 11
11:17:41.206 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.chunkSize: 16777216
11:17:41.206 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.tinyCacheSize: 512
11:17:41.206 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.smallCacheSize: 256
11:17:41.206 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.normalCacheSize: 64
11:17:41.206 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.maxCachedBufferCapacity: 32768
11:17:41.206 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.cacheTrimInterval: 8192
11:17:41.221 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.allocator.type: pooled
11:17:41.221 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.threadLocalDirectBufferSize: 65536
11:17:41.221 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.maxThreadLocalCharBufferSize: 16384
第 1 连接失败......
2023-05-21 11:17:42 -->> 连接失败,第1次重新连接....
第 2 连接失败......
2023-05-21 11:17:45 -->> 连接失败,第2次重新连接....
第 3 连接失败......
2023-05-21 11:17:50 -->> 连接失败,第3次重新连接....
第 4 连接失败......
2023-05-21 11:17:59 -->> 连接失败,第4次重新连接....
第 5 连接失败......
2023-05-21 11:18:16 -->> 连接失败,第5次重新连接....
第 6 连接失败......
2023-05-21 11:18:49 -->> 连接失败,第6次重新连接....
第 7 连接失败......
2023-05-21 11:19:54 -->> 连接失败,第7次重新连接....
2023-05-21 11:22:02 -->> 连接成功....

蜗牛杨哥
关注
Netty4长连接（服务端+客户端）
06-02
Netty4长连接、断开重连、心跳检测、Msgpack编码解码 http://blog.csdn.net/giousa/article/details/72846303#t2
netty网络重连记录
weixin_43194854的博客
03-07 167
netty网络重连场景事件总结 场景 运行过程中可能出现网络故障，而需要进行网络重连，故进行网络重连程序的编写。 事件 //模拟将ip地址改错，使其无法进行网络连接成功 发现网络重连时间较长，基本上在10s左右 //模拟将网络断开，使其失去网络，无法进行网络连接 发现该状况下，重连事件很短，平均在1s以内 总结 不同的网络故障，重连导致的时间不同，同时耗时时间也会有所差距 ...
Netty客户端断线重连实现及问题思考
2301_78399805的博客
04-16 966
在连接断线的场景中，这里即为java.io.IOException，所以执行了close方法，当debug到AbstractChannel.AbstractUnsafe#close(ChannelPromise, Throwable, ClosedChannelException, notify)方法中会发现最后又调用了AbstractUnsafe#fireChannelInactiveAndDeregister方法，继续debug最后则会执行自定义的fireChannelInactive方法。
Java基础之《netty（21）—WebSocket长连接开发》
csj50的专栏
01-06 2135
一、实例要求1、http协议是无状态的，浏览器和服务器间的请求响应一次，下一次会重新创建连接 2、要求：实现基于webSocket的长连接的全双工的交互 3、改变http协议多次请求的约束，实现长连接了，服务器可以发送消息给浏览器 4、客户端浏览器和服务器端会相互感知，比如服务器关闭了，浏览器会感知，同样浏览器关闭了，服务器会感知二、服务端1、WebSocketServer.java 2、MyTextWebSocketFrameHandler.java 三、客户端1、hello.html 四、测
Java基础之《netty（18）—群聊系统》
csj50的专栏
01-03 867
4、客户端：通过channel可以无阻塞发送消息给其他所有用户，同时可以接受其他用户发送的消息（由服务器转发得到）1、编写一个netty群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）3、服务器端：可以检测用户上线，离线，并实现消息转发功能。5、目的：进一步理解netty非阻塞网络编程机制。
安卓基于netty4.x心跳，断线重连，状态监听，数据发送
07-03
安卓基于netty4.x心跳，断线重连，状态监听，数据发送
基于Netty实现的MQTT客户端_netty-mqtt-client.zip
最新发布
09-02
基于Netty实现的MQTT客户端_netty-mqtt-client
基于netty实现的mqtt客户端，可用于Java、Android环境.zip
03-24
《基于Netty实现的MQTT客户端在Java与Android环境中的应用》 MQTT（Message Queuing Telemetry Transport）是一种轻量级的发布/订阅式消息协议，广泛应用于物联网（IoT）领域，尤其是资源受限的设备之间。在本文中...
Netty3.x 源码解析
07-01
以Netty中的一个简单EchoServer为例，这个服务器能够接收客户端发送的消息并将其回显给客户端。在该示例中，使用ServerBootstrap来配置服务端，并通过设置ChannelPipeline来处理业务逻辑。这里使用到的...
light-netty-client:Light-netty-client是一个基于netty 4.x快速开发异步客户端的轻量级框架
06-20
Light-netty-client 是一个轻量级的框架，用于快速开发基于 netty 4.x 的异步客户端。 发送获取请求的示例代码： String getUrl = "http://www.baidu.com:80"; NettyHttpRequest request = new NettyHttpRequest...
一起学Netty（十四）之 Netty生产级的心跳和重连机制
热门推荐
BazingaLyncc
05-27 6万+
sigh，这这篇博客的时候老脸还是红了一下，应该算是剽窃吧，看到别人写的代码有点无地之容，好在文章的标题是“一起学”，而不是开涛大神的“跟我学”系列的文章 最近工作比较忙，但闲暇之余还是看了阿里的冯家春（fengjiachun）的github上的开源代码Jupiter，写的RPC框架让我感叹人外有人，废话不多说，下面的代码全部截取自Jupiter，写了一个比较完整的例子，供大家一起学习分
netty客户端断线重连实现及问题思考
Brucelwl的博客
01-18 1万+
netty客户端线程给多大比较合理
求助org.apache.catalina.core.StandardService - Stopping service [Tomcat]怎么解决大神帮帮忙
qq_42450237的博客
07-25 2万+
springboot项目启动，昨天还好好的，突然就启动不了了。什么配置也没改，对springboot'也不熟悉，有没有大神解决下？谢谢！   .   ____          _            __ _ _  /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \  \\/  __...
Java调用本地接口：java.lang.UnsatisfiedLinkError
冷月宫主的专栏
03-19 2340
.java包路径，类的包路径要和生成头文件类的包路径一致。
JCTools简介-增强的并发工具
liinux-Talk is cheap,show me the code.
06-14 7773
JCTools 早在96年就有论文提出了无锁队列的概念，再到后来 Disruptor，高性能已得到生产的验证。此处介绍的 Jctools 中的高性能队列，其性能丝毫不输于 Disruptor。 JCTools (Java Concurrency Tools) 提供了一系列非阻塞并发数据结构（标准 Java 中缺失的），当存在线程争抢的时候，非阻塞并发数据结构比阻塞并发数据结构能提供更好的性能。 JCTools 是一个开源工具包，在 Apache License 2.0 下发布，并在 Netty、Rxj
Netty的断线重连
明光的博客
05-31 1万+
因为工作中经常使用到TCP，所以会频繁使用到诸如Mina或Netty之类的通信框架，为了方便项目的逻辑调用，经常会在框架的基础上再一次进行封装，这样做其实有画蛇添足的嫌疑，但也是无奈之举。 /** * 提供重连功能，需传入bootstrap，并实现handlers */ @ChannelHandler.Sharable public abstract class FunctionsChanne...
Netty4客户端使用遇到的坑笔记
楠之枫雪的博客
05-29 4066
1.注意ChannelPipeline中handler的调用顺序。完整的发送与接收过程，是先发送再接收，所以是先执行out再执行in。具体参考https://blog.csdn.net/u014614038/article/details/80487942 2.发送数据转码，通过MessageToByteEncoder，比如我使用的是SMessage格式数据： public class S...
《Netty实战》第一部分
gwt0425的博客
10-16 984
前言从开始打算学Netty，然后很自然的找到了《Netty实战》这本书，但是，对一个从来没写过的Netty程序的人而言，理解书中的概念确实很难呀。更何况，还几乎没有Nio网络编程的基础，所以一度书看不下去，但觉得写Netty程序不算什么很难的事情。后来，由于一些需要，自己开始写Netty服务端和客户端，时常出现服务端发不出去消息，或者客户端收不到消息。并且用的Kotlin,异常都没有受检，就更加找不
基于Netty最简单的WebSocket通讯
cmqwan的博客
08-14 1万+
基于Netty最简单的WebSocket通讯 基于Netty最简单的WebSocket通讯 总览 服务端 EasyWsServer EasyWsServerHandler 客户端 EasyWsClient EasyWsClientHandler 测试类 EasyWsTest 测试 总览 总共是五个文件： client EasyWsClient 客户端 EasyWsClientHandler 客户端消息处理类 server EasyWsServer 服务端 EasyWsServerHandler 服务端
netty获取玩家chanel_Netty4.X 获取客户端IP
05-26
在 Netty 4.x 中获取客户端 IP 可以通过 ChannelHandlerContext.getChannel().remoteAddress() 方法获取客户端的 InetSocketAddress 对象，然后通过该对象的 getHostString() 方法获取客户端的 IP 地址。示例代码如下： ``` @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { // 获取客户端 IP 地址 InetSocketAddress remoteAddress = (InetSocketAddress) ctx.channel().remoteAddress(); String clientIP = remoteAddress.getHostString(); // 处理业务逻辑 // ... super.channelRead(ctx, msg); } ``` 需要注意的是，由于客户端可能使用代理服务器等方式连接到服务器，因此获取客户端 IP 地址时可能需要考虑 X-Forwarded-For 等 HTTP 头信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值