netty重连

最新推荐文章于 2024-02-04 10:30:00 发布
最新推荐文章于 2024-02-04 10:30:00 发布
阅读量804 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48942229/article/details/128145960
版权

  1. 简单的netty重连

    1. 首先是 有一个 netty 客户端；
`package com.example.nettySimple;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

import java.util.concurrent.TimeUnit;

/**
 * @author Xia_Ye_bing
 * @PRODUCT_NAME IntelliJ IDEA
 * @creatime 2021 10 27 13:20
 */
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client" + ctx); 
    }

    /**
     * 当通道有读取事件时 会触发，
     *
     * @param ctx
     * @param msg
     * @throws Exception
     */

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        final ByteBuf buf = (ByteBuf) msg;
        System.out.println("服务器回复的信息是 " + buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务器地址为：" + ctx.channel().remoteAddress());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelUnregistered();
        System.out.println(" netty 链接失败，3秒后进行重连");
        Thread.sleep(3000);
        NettyClient.start();
    }

    @Override
    public void channelInactive(final ChannelHandlerContext ctx) {
        System.out.println("连接断开:" + ctx.channel().remoteAddress());
    }

}
  1. `创建一个处理器
  package com.example.nettySimple;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

import java.util.concurrent.TimeUnit;

/**
 * @author Xia_Ye_bing
 * @PRODUCT_NAME IntelliJ IDEA
 * @creatime 2021 10 27 13:20
 */
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client" + ctx);
    }

    /**
     * 当通道有读取事件时 会触发，
     *
     * @param ctx
     * @param msg
     * @throws Exception
     */

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        final ByteBuf buf = (ByteBuf) msg;
        System.out.println("服务器回复的信息是 " + buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务器地址为：" + ctx.channel().remoteAddress());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelUnregistered();
        System.out.println(" netty 链接失败，3秒后进行重连");
        Thread.sleep(3000);
        NettyClient.start();
    }

    @Override
    public void channelInactive(final ChannelHandlerContext ctx) {
        System.out.println("连接断开:" + ctx.channel().remoteAddress());
    }

}
  1. 演示效果
  2. netty重连演示-url（需下载）
  3. 新建一个客户端
package com.example.nettySimple;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * @author Xia_Ye_bing
 * @PRODUCT_NAME IntelliJ IDEA
 * @creatime 2021 10 27 7:19
 */
public class nrtty_siple {

    public static void main(String[] args) throws InterruptedException {
        /**
         * 创建两个 线程组 booGroup 和 workerGroup，
         * booGroup 只处理链接请求，
         * workerGroup 真正处理客户端业务处理
         * 两个都是 无线循环，两个线程的默认线程个数是 CPU核数*2，写了值话，按照写的个数创建线程数
         */
        final EventLoopGroup booGroup = new NioEventLoopGroup(1);

        final EventLoopGroup workerGroup = new NioEventLoopGroup();

        /**
         *    创建启动对象
         */
        final ServerBootstrap bootstrap = new ServerBootstrap();

        /**
         * 使用链式编程 来 设置 各个参数
         */

        bootstrap.group(booGroup, workerGroup)//设置里昂个线程组
                .channel(NioServerSocketChannel.class)//使用  NioServerSocketChannel 作为服务器的通道实现
                .option(ChannelOption.SO_BACKLOG, 128)//设置保持通道链接状态
                .childOption(ChannelOption.SO_KEEPALIVE, true)//对应的管道设置处理器
                .childHandler(new ChannelInitializer<SocketChannel>() {//创建一个通道初始化对象（匿名对象）
                    //给 pipeline 设置处理器
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline().addLast(new nettySipleHandler());//将自定义的处理器加入
                    }
                });//给我们的workerGroup 的 EventLoopGroup 设置处理器
        System.out.println("服务器 is ready");
        //绑定一个端口 生成一个channelFuture 对象 同时启动服务器
        final ChannelFuture channelFuture = bootstrap.bind(6668).sync();
        //对关闭通道进行监听
        channelFuture.channel().closeFuture().sync();

    }
}

8 建立 客户端处理器

package com.example.nettySimple;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

/**
 * @author Xia_Ye_bing
 * @PRODUCT_NAME IntelliJ IDEA
 * @creatime 2021 10 27 7:40
 */

/**
 * 我，们自定义一个handler ，需要 继承 netty规定好的 某个 HandlerAdapter （规范）
 * 这时的handler 才是 一个 handler
 */
public class nettySipleHandler extends ChannelInboundHandlerAdapter {
    //读取数据事件 （）可以读取客户端发送的消息

    /**
     * @param ctx ： ChannelHandlerContext ctx 上下文对象，含有 通道 、管道
     *            Object ms 客户端发发送的数据
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server ctx" + msg);
        System.out.println("服务器读取线程   "+Thread.currentThread().getName());
        /**
         * 将msg转为bytebuf ，
         * bytebuf  是 netty 提供，不是 nio中的ByteBuffer
         */
        final ByteBuf buf = (ByteBuf) msg;
        System.out.println("客户端发送的消息是 " + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端地址是：" + ctx.channel().remoteAddress());
    }

    //数据读取完毕
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

        /**
         * writeAndFlush 写并且发送
         * 将数据写入缓存并刷新
         * 需要对发送的数据进行编码
         */
        ctx.writeAndFlush(Unpooled.copiedBuffer(("hellow 客户端"), CharsetUtil.UTF_8));
    }

    //关闭通道、
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.channel().close();
    }
}

10 netty 重连 效果演示（演示时候，先开启 客户端，客户端 会 一直 重连，当 启动 服务端后，服务端 停止重连，当 断开 服务器时 ，服务端再次重连）；

11、链接-断开-重连-效果演示（需下载）

13、文件源码下载

冰淋晨夏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
netty5长连接.自动重连
09-28
netty的长连接.. 连接断开之后 自动重连demo
netty断线重连机制及心跳机制.rar
09-10
netty断线重连机制及心跳,包含客户端和服务端，主要学习怎么重连和发送接收心跳，不满足心跳则关闭管道。
Netty权威指南总结（一）
hanxiaozhang的博客
02-25 1206
Netty权威指南总结
Netty核心原理与基础实战（三）——详解Channel、Handler（备份）
最新发布
geminigoth的博客
02-04 1642
通道是Netty的核心概念之一，代表网路连接，有它负责同对端网络进行网络通信，既可以写入数据到对端，也可以从对端读取数据。AbstractChannel内部有一个pipeline属性，表示处理器的流水线。Netty在对通道进行初始化的时候，将pipiline属性初始化为DefaultChannelPipeline的实例。以上代码表明每个通道都拥有一条ChannelPipeline处理器流水线。AbstractChannel内部有一个parent父通道属性，保持通道的父通道。
《Netty》从零开始学netty源码（三十二）之ChannelPipeline的Unregistered
Lanna_w的博客
04-11 130
【技术】《Netty》从零开始学netty源码（三十二）之ChannelPipeline的Unregistered
netty中基本组件的作用与关系
tinysakura的博客
08-10 1409
Netty中的基本组件及关系 概述 这篇文章主要是用来介绍netty中常用的一些组件，以及这些组件之间的存在关系 Channel —-Socket EventLoop —-控制流，多线程处理，并发； ChannelHandler和ChannelPipeline Bootstrap 和 ServerBootstrap Channel 接口 基本的I/O操作，在基于...
Netty中Channel的生命周期（SimpleChannelInboundHandler）
小龙哒的博客
01-14 9132
文章目录1.channelRegistered2.channelUnregistered3.channelActive4.channelInactive5.channelReadComplete6.userEventTriggered7.channelWritabilityChanged8.exceptionCaught9.handlerAdded10.handlerRemoved11.chann...
Unregistere
12-14 757
void channelUnregistered(ChannelHandlerContext ctx) 通道取消注册到Selector时被调用，通常在通道关闭时触发，首先触发channelInactive 事件，然后再触发 channelUnregistered 事件。 void channelActive(ChannelHandlerContext ctx) 通道处于激活的事件，在 Netty 中，处于激活状态表示底层 Socket 的isOpen() 方法与 isConnected() 方法返回 tru
netty系列之:自动重连
程序那些事
08-12 7447
我们在使用客户端和服务器端连接的过程中，可能会因为各种问题导致客户端和服务器的连接发生中断，遇到这种情况，一般情况下我们需要使用监控程序去监听客户端和服务器端的连接，如果第一时间发现连接断开了，就需要手动去重连。比较麻烦，今天给大家介绍一种netty中自动重连的方式。
简单阐述一下Netty中Channel的生命周期（SimpleChannelInboundHandler）
丁东的博客
05-17 1525
文章目录1.channelRegistered（注册事件）2.channelUnregistered（取消注册事件）3.channelActive（是否是活跃）4.channelInactive（不活跃）5.channelReadComplete（读取完毕事件）6.userEventTriggered（用户事件触发）7.channelWritabilityChanged（可写更改）8.exceptionCaught（捕获到异常）9.handlerAdded（拦截器的添加）10.handlerRemoved（
处理器 Handler 详解
这个人很懒什么都没有~
10-22 1699
（2）也不调用ctx.fireChannelXxx()[ctx.fireChannelRead(msg)方法是另外一种入站向下传递的方法]handlerAdded()→channelRegistered()→channelActive()→入站方法回调。是在完成ch.pipeline().addLast(handler)语句之后，会回调handlerAdded()。入站方法会多次调用，每一次有。ChannelHandler通道处理器的入站/出站处理方法中，Netty都会传递一个Context上下。
netty 断线重连+心跳
10-25
netty使用自带工具类实现断线重连和心跳包
netty 断线重连
10-25
使用netty自带工具类实现心跳功能，并带有重连功能
netty+websocket实现心跳和断线重连
03-06
实现netty作为服务端，websocket连接成功，将channel保存到map集合，通过js发送心跳，服务端接收心跳信息并响应给客户端，当服务端断开时 客户端进行重连操作
Netty5用户手册之六：netty核心之ChannelHandler用法详解
热门推荐
zzjstudent的专栏
10-24 1万+
概述       主要介绍四个主要的核心类：ChannelPipeline、ChannelHandlerContext、ChannelHandler、Inbound VS Outbound(入站和出站)等。netty提供了强大的类来处理输入和输出的数据，通过ChannelHandler可以快速编写出可重用的、高性能的代码程序。下面一一介绍这些核心类的用法： ChannelPipeline类的用
Netty in Action -ChannelHandler和ChannelPipeline
lzf的博客
05-27 354
本章主要内容ChannelChannelHandlerChannePipelineChannelHandlerContext我们在上一章研究的 bytebuf 是一个容器用来“包装”数据。在本章我们将探讨这些容器如何通过应用程序来移动，传入和传出，以及他们的内容是如何处理的。Netty 提供了应用开发的数据处理方面的强大支持。我们已经看到了channelhandler 如何链接在一起 Channe...
Netty-原理篇(ChannelPipeline&ChannelHandler)
S1124654的博客
06-28 674
netty channel channelhandlercontext pipeline
用netty实现客户端断线重连
yygr的博客
04-21 4925
https://blog.csdn.net/haohaoxuexiyai/article/details/116497444 一、NettyClient /** * 实现了重连的客户端 */ public class NettyClient { ​ private String host; private int port; private Bootstrap bootstrap; private EventLoopGroup group; ​ publ...
Netty 各组件的原理分析（九）
nandao158的博客
02-17 744
Channel、EventLoop(Group)和 ChannelFuture Netty 网络抽象的代表： Channel—Socket； EventLoop—控制流、多线程处理、并发； ChannelFuture—异步通知。 Channel 和 EventLoop 关系如图： Channel 接口 基本的 I/O 操作（bind()、connect()、read()和 write()）依赖于底层网络传输所提供的原 语。在基于 Java 的网络编程中，其基本的..
netty websocket重连
09-12
对于Netty WebSocket的重连，你可以采取以下步骤： 1. 创建一个WebSocket重连管理类，用于管理WebSocket的连接状态和重连逻辑。 2. 在WebSocket连接断开时，触发重连逻辑。你可以在`channelInactive`方法中检测连接断开事件。 3. 在重连逻辑中，使用`Bootstrap`重新建立WebSocket连接。你可以在重连方法中创建一个新的`WebSocketClientHandler`并添加到`Bootstrap`中。 4. 设置重连的时间间隔，避免频繁重连。可以使用定时器来触发重连逻辑，并设置一个合理的重连间隔时间。 5. 如果重连成功，更新连接状态并进行后续操作。如果重连失败，可以继续触发下一次重连。 下面是一个简单的示例代码，演示了如何实现Netty WebSocket的重连： ```java public class WebSocketReconnectManager { private final EventLoopGroup eventLoopGroup; private final String host; private final int port; private final URI uri; private Bootstrap bootstrap; private WebSocketClientHandler clientHandler; private ScheduledFuture<?> reconnectFuture; private boolean connected; public WebSocketReconnectManager(EventLoopGroup eventLoopGroup, String host, int port, String path) throws URISyntaxException { this.eventLoopGroup = eventLoopGroup; this.host = host; this.port = port; this.uri = new URI("ws://" + host + ":" + port + path); init(); } private void init() { bootstrap = new Bootstrap(); clientHandler = new WebSocketClientHandler(bootstrap, uri); bootstrap.group(eventLoopGroup) .channel(NioSocketChannel.class) .handler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) { ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast(new HttpClientCodec()); pipeline.addLast(new HttpObjectAggregator(8192)); pipeline.addLast(clientHandler); } }); connect(); } private void connect() { bootstrap.connect(host, port).addListener((ChannelFutureListener) future -> { if (future.isSuccess()) { connected = true; } else { connected = false; scheduleReconnect(); } }); } private void scheduleReconnect() { if (!connected && reconnectFuture == null) { reconnectFuture = eventLoopGroup.schedule(this::connect, 5, TimeUnit.SECONDS); } } public void onConnected() { connected = true; if (reconnectFuture != null) { reconnectFuture.cancel(false); reconnectFuture = null; } } public void onDisconnected() { connected = false; scheduleReconnect(); } } ``` 在你的WebSocket客户端代码中，需要在连接断开时调用`onDisconnected`方法，当重连成功后调用`onConnected`方法。这样就能实现简单的WebSocket重连逻辑。你可以根据自己的需求进行调整和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值