基于Netty4.xx客户端与服务器端互读|写数据(一)

于 2023-05-22 23:30:28 发布
阅读量242 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014635374/article/details/130817440
版权

客户端代码:
============================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 org.jy.sso.websocket.stomp.push.netty.chat.system.chapter.handler.FirstClientSendMsgHandler;

import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * Netty基于异步事件驱动的高性能通信框架:
 * 客户端重连处理逻辑
 */
@Slf4j
public class NettyClient {
    // 最大重试次数
    private static final int MAX_RETRY_NUM = 100;
    // 重试初始值
    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());
                        // 在客户端添加一遍逻辑处理器，在客户建立连接成功后，向服务器端写数据
                        channel.pipeline().addLast(new FirstClientSendMsgHandler());
                    }
                });
        connect(bootstrap, NETTY_SERVER_HOST_IP, NETTY_SERVER_PORT, MAX_RETRY_NUM);

    }

    /**
     * https://www.cnblogs.com/fanguangdexiaoyuer/p/6132968.html
     *
     * @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);
            }
        });
    }

}

 客户端写|读服务器端的处理器：
 

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

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.apache.commons.lang.time.DateFormatUtils;
import java.nio.charset.StandardCharsets;
import java.util.Date;

/**
 * 客户端向服务器端发送消息第一个处理器
 */
public class FirstClientSendMsgHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        System.out.println("=========================向服务器端写数据============================");
        System.out.println(DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss") + ": 客户端写出数据");
        // 1.获取数据
        ByteBuf buffer = getByteBuf(ctx);
        // 2.写数据
        ctx.channel().writeAndFlush(buffer);
    }

    private ByteBuf getByteBuf(ChannelHandlerContext ctx) {
        // 1.获取二进制抽象 ByteBuf
        ByteBuf buffer = ctx.alloc().buffer();
        // 2.准备传递给服务器端的数据，并指定字符编码为UTF-8
        byte[] bytes = "你好,这是Netty客户端传递的数据".getBytes(StandardCharsets.UTF_8);
        // 3.填充数据到ByteBuf
        buffer.writeBytes(bytes);
        return buffer ;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        System.out.println("=========================读取到服务器端的数据============================");
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println(DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss") + " : 服务器端读到的客户端传递过来的数据 -> "
                + byteBuf.toString(StandardCharsets.UTF_8)); // 去掉这个编码转换结果为:
    }
}

================================netty服务器端处理逻辑=====================

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

import io.netty.bootstrap.ServerBootstrap;
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;
import org.jy.sso.websocket.stomp.push.netty.chat.system.chapter.handler.FirstServerReceiveDataHandler;

/**
 * 居于异步事件驱动高性能网络通信框架
 * VisualVM使用教程：
 * https://blog.csdn.net/weixin_42652596/article/details/122240268
 * 插件下载
 * https://visualvm.github.io/archive/uc/8u40/updates.html
 * // 插件的位置
 * D:\program_files\jdk_vm_tool
 */
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);
                            }
                        });*/

                        ch.pipeline().addLast(new FirstServerReceiveDataHandler());

                    }
                }).bind(8000);
    }
}

 服务器端读|写处理器：

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

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.apache.commons.lang3.time.DateFormatUtils;

import java.nio.charset.StandardCharsets;
import java.util.Date;

/**
 * 服务器端接收客户端数据的处理器：
 * 服务器端接收客户端数据
 * 响应客户端请求，并向客户端写数据
 */
public class FirstServerReceiveDataHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object requestContent) {

        //接收客户端的数据逻辑
        System.out.println("============================接收客户端的数据=============================");
        ByteBuf byteBuf = (ByteBuf) requestContent;
        System.out.println(DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss") + " : 服务器端读到的客户端传递过来的数据 -> "
                + byteBuf.toString(StandardCharsets.UTF_8)); // 去掉这个编码转换结果为:
        System.out.println("============================向客户端写数据=============================");
        ByteBuf response = getByteBuf(ctx);
        ctx.channel().writeAndFlush(response);


    }

    /**
     * 向客户端写响应数据
     *
     * @param ctx 通道处理器上下文
     * @return {@link io.netty.buffer.ByteBuf}
     */
    private ByteBuf getByteBuf(ChannelHandlerContext ctx) {
        byte[] responseBytes = "你好,欢迎关注杨哥哥的微信公众号,<<财务自由耕耘者>>!".getBytes(StandardCharsets.UTF_8);
        ByteBuf buffer = ctx.alloc().buffer();
        buffer.writeBytes(responseBytes);
        return buffer;
    }
}

客户端测试日志如下:

23:18:23.516 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.normalCacheSize: 64
23:18:23.516 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.maxCachedBufferCapacity: 32768
23:18:23.516 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.cacheTrimInterval: 8192
23:18:23.531 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.allocator.type: pooled
23:18:23.531 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.threadLocalDirectBufferSize: 65536
23:18:23.531 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.maxThreadLocalCharBufferSize: 16384
第 1 连接失败......
2023-05-22 23:18:24 -->> 连接失败,第1次重新连接....
第 2 连接失败......
2023-05-22 23:18:27 -->> 连接失败,第2次重新连接....
第 3 连接失败......
2023-05-22 23:18:32 -->> 连接失败,第3次重新连接....
2023-05-22 23:18:40 -->> 连接成功....
=========================向服务器端写数据============================
2023-05-22 23:18:40: 客户端写出数据
23:18:40.686 [nioEventLoopGroup-2-7] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.maxCapacityPerThread: 32768
23:18:40.686 [nioEventLoopGroup-2-7] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.maxSharedCapacityFactor: 2
23:18:40.686 [nioEventLoopGroup-2-7] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.linkCapacity: 16
23:18:40.686 [nioEventLoopGroup-2-7] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.ratio: 8
23:18:40.702 [nioEventLoopGroup-2-7] DEBUG io.netty.buffer.AbstractByteBuf - -Dio.netty.buffer.bytebuf.checkAccessible: true
23:18:40.705 [nioEventLoopGroup-2-7] DEBUG io.netty.util.ResourceLeakDetectorFactory - Loaded default ResourceLeakDetector: io.netty.util.ResourceLeakDetector@e5f4a2
=========================读取到服务器端的数据============================
2023-05-22 23:18:40 : 服务器端读到的客户端传递过来的数据 -> 你好,欢迎关注杨哥哥的微信公众号,<<财务自由耕耘者>>!

 服务器端测试日志如下:

23:18:35.467 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.normalCacheSize: 64
23:18:35.467 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.maxCachedBufferCapacity: 32768
23:18:35.467 [main] DEBUG io.netty.buffer.PooledByteBufAllocator - -Dio.netty.allocator.cacheTrimInterval: 8192
23:18:35.483 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.allocator.type: pooled
23:18:35.483 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.threadLocalDirectBufferSize: 65536
23:18:35.483 [main] DEBUG io.netty.buffer.ByteBufUtil - -Dio.netty.maxThreadLocalCharBufferSize: 16384
23:18:40.723 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.maxCapacityPerThread: 32768
23:18:40.723 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.maxSharedCapacityFactor: 2
23:18:40.724 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.linkCapacity: 16
23:18:40.724 [nioEventLoopGroup-3-1] DEBUG io.netty.util.Recycler - -Dio.netty.recycler.ratio: 8
23:18:40.739 [nioEventLoopGroup-3-1] DEBUG io.netty.buffer.AbstractByteBuf - -Dio.netty.buffer.bytebuf.checkAccessible: true
23:18:40.752 [nioEventLoopGroup-3-1] DEBUG io.netty.util.ResourceLeakDetectorFactory - Loaded default ResourceLeakDetector: io.netty.util.ResourceLeakDetector@e80c32
============================接收客户端的数据=============================
2023-05-22 23:18:40 : 服务器端读到的客户端传递过来的数据 -> 你好,这是Netty客户端传递的数据
============================向客户端写数据=============================

 

蜗牛杨哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
netty 终极篇 客户端，服务端双方通信，服务端自由发送。网络异常重新连接，tcp协议传输。(附带，写入，读取工具类txt，获取P配置文件工具类)
小孔的博客
10-29 209
netty，io与nio的区别，先上代码在分析： 依赖包: <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.12.Final</version> </dependency> 服务端： import com.gs.util.ReadUtils; imp
04.Netty客户端实现接服务器收响应数据.rar
09-24
04.Netty客户端实现接服务器收响应数据.rar
netty实现客户端服务端心跳重连
抓住流浪剑客的小YI巴
08-15 3564
前言：           公司的加密机调度系统一直使用的是http请求调度的方式去调度，但是会出现网络故障导致某个客户端或者服务端断线的情况，导致很多请求信息以及回执信息丢失的情况，接着我们抛弃了http的方式，改为Tcp的方式去建立客户端和服务器之间的连接，并且要去实现断线重连的功能，经过讨论后决定使用java中成熟的nio框架 – netty去解决这一系列的问题。 1.       ne...
【初识Netty&使用Netty实现简单的客户端与服务端的通信操作&Netty框架中一些重要的类以及方法的解析】
Coder_ljw的博客
11-02 1326
无论你的应用程序使用哪种协议或者处理哪种类型的数据，唯一决定它使用哪种引导类的是它是作为一个客户端还是作为一个服务器。好了，【初识Netty&使用Netty实现简单的客户端与服务端的通信操作&Netty框架中一些重要的类以及方法的解析】就先学习到这里，更多内容不断学习更新中。它代表一个到实体（如一个硬件设备、一个文件、一个网络套接字或者一个能够执行一个或者多个不同的I/O操作的程序组件）的开放连接，如读操作和写操作。Netty 使用不同的事件来通知我们状态的改变或者是操作的状态。连接已被激活或者连接失活；
netty-Server读取客户端写入
weixin_34417200的博客
07-14 311
2019独角兽企业重金招聘Python工程师标准>>> ...
彻底搞懂 Netty 线程模型
org_hjh的博客
10-13 715
点赞再看，养成习惯，微信搜一搜【一角钱技术】关注更多原创技术文章。本文 GitHub org_hejianhui/JavaStudy 已收录，有我的系列文章。 前言 BIO 、NIO 、AIO 总结 Unix网络编程中的五种IO模型 深入理解IO多路复用实现机制 在学习Netty 之前我们最好先掌握 BIO、NIO、AIO 基础知识，前面我们已经花了三篇文章去讲这些知识。我们开始来学习 Netty 的具体知识了，本文就Netty线程模型展开分析。 基本概念 IO 模型 BIO：同步阻塞模型； N..
Netty源码(十二)之服务端向客户端写数据的过程
了不起的盖茨比的博客
08-30 655
前面的几篇博客大致的介绍整个Netty核心的代码，以及启动的流程，服务端的读取流程，以及常用的解码器的源码。至此Netty的源码还剩一个服务端向客户端写数据的流程。今天我们就来介绍一下服务端向客户端写的流程。写的方式有以下两种，具体代码如下： ctx.writeAndFlush(""); ctx.channel().writeAndFlush(""); 这两种方式的区别具体如下图所示： 可以看到我们如果执行ctx.writeAndFlush("");方法后，当前的handler后面所有handler都会
Netty-5-客户端的创建并且接受服务端的数据
文天大人
12-11 487
启动Memcached,我的memcached文件是在/usr/local/memcached/bin下 /usr/local/memcached/bin# memcached -p 11211 -m 64m -d -u root
Netty写操作的一点概括
书唐瑞的博客
11-22 339
相对于读操作而言,Netty在处理写操作上更复杂一些.在之前的文章我们介绍了Netty空闲检测之读空闲,为了介绍Netty空闲检测之写空闲,我们有必要对Netty的写操作做一个整体上的介绍.有助于我们接下来介绍写空闲. 在之前的文章我们也说过,在Netty中有两类线程,一类是IO线程,负责读写操作,一类是业务线程,就是处理业务的线程.我们以RocketMQ为例,看下它的源码中,如何分配这两类线程的. // 源码位置: org.apache.rocketmq.remoting.netty.NettyRemot
netty源码之写数据
u012391423的博客
07-27 351
目录 前言 和快递比较一下 几种场景 发送数据的分类 写数据 flush数据 前言 write 是把数据写到buf里 flush 是将数据发出去 writeAndFlush 写入数据到buf 并立刻发送出去 和快递比较一下 几种场景 1、netty协数据，写不进去了 ， 会停止写 ， 然后注册一个OP_WRITE事件 ， 来通知什么时候可以写进去了再写 2、netty批量写数据时，如果想写的都写完了， 接下来会尝试写更多 ， 调整maxBytesPerG...
summer:一个基于Netty4.x的简单mvc lib进行研究
05-14
Summer是一个基于的简单mvc库，用于学习！！！ 用法 快速开始 public class Application { public static void main ( String [] args ) { Summer . me() .before( " /example/* " , (request, response) - > { ...
基于Java Netty 实现的多人联机游戏（多人对战）的客户端和服务器端.zip
最新发布
07-19
java课程设计大作业，java、算法练手项目，适合初学java、数据结构的同学拿来学习研究，基于java、GUI开发的小游戏，程序都经过测试，可以直接运行，资源含程序运行所需的源码、资源文件等全部数据，有需要的可放心...
mqttserver:基于netty实现mqtt协议 服务器端开发
05-19
mqttserver，基于netty 4.1.1，可解码http、mqtt协议请求。 项目包括： 1.基于netty绑定端口监听，对于mqtt消息和http请求消息分别绑定不同的监听端口； 2.在MQTTServerInitializer中，分别添加mqtt编码解码器和http...
netty4 Android客户端和服务器端
09-30
netty-4.0.31.Final和Android的代码都有。还有一个java客户端的。
Netty学习（八）-- 练习
weixin_43989102的博客
09-06 141
的双向信号传输，即时是阻塞 IO，读和写是可以同时进行的，只要分别采用读线程和写线程即可，读不会阻塞写、写也不会阻塞读。Java Socket 是全双工的，线路上存在。实现一个 echo Server。
Netty | 03 - 客户端与服务端双向通信
GangsterChen & Codes
02-13 473
客户端和服务器双向通信
Netty
Sick_2W的博客
03-14 1141
Netty基础 概念 netty是一个网络编程框架，可以自定义通信协议，自定义编码、解码字节流。 三大特性 并发高：基于nio的网络通信框架，对比bio，性能得到了很大的提高。 传输快：0拷贝，堆内存外开辟一块内存，提高传输速度 封装好：优良的api设计和灵活的代码调用 I/O基础 输入流: InputStream和Reader输出流: OutputStream和Writer 字节流 字符流 计算机最小的二进制单位bit 比特代表0和1字节1 byte = 8bit计算机处理的最小单
学习Netty以便通过串口读写数据
热门推荐
yanchangyufan的专栏
08-15 1万+
最近在接触到Netty，以前都用的比较少。其实最近在项目中，发现很多地方都可以将Netty替代原来的Socket编程，应该在效率上会有改善。我也是先说下自己在项目中遇到的问题，去学习Netty.     由于项目中采用比较老的一个开源的框架，去读写串口数据。RxTxcommon.jar可以通过这个开源的框架去读写串口数据。后来Netty4.1.5以后，也有这种实现方法。效率比以前更快。实现方法都
Netty写刷数据源码解析
我神级欧文的博客
07-07 682
Netty写刷数据源码解析
netty获取玩家chanel_Netty4.X 获取客户端IP
05-26
在 Netty 4.x 中获取客户端 IP 可以通过 ChannelHandlerContext.getChannel().remoteAddress() 方法获取客户端的 InetSocketAddress 对象，然后通过该对象的 getHostString() 方法获取客户端的 IP 地址。示例代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值