netty网络编程（三）之tcp/ip协议与netty编程实战

最新推荐文章于 2024-05-17 16:11:15 发布
最新推荐文章于 2024-05-17 16:11:15 发布
阅读量857 收藏 1
点赞数 1
分类专栏： netty 网络编程 文章标签： tcp/ip netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yemuxiaweiliang/article/details/105462856
版权

netty编解码编程实战

TCP/IP协议

TCP/IP（Transmission Control Protocol/Internet Protocol，传输控制协议/网际协议）是指能够在多个不同网络间实现信息传输的协议簇。TCP/IP协议不仅仅指的是TCP 和IP两个协议，而是指一个由FTP、SMTP、TCP、UDP、IP等协议构成的协议簇， 只是因为在TCP/IP协议中TCP协议和IP协议最具代表性，所以被称为TCP/IP协议。
TCP/IP传输协议是严格来说是一个四层的体系结构，应用层、传输层、网络层和数据链路层都包含其中。
如下图所示
在这里插入图片描述

TCP协议

传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。

主要功能

  • 当应用层向TCP层发送用于网间传输的、用8位字节表示的数据流，TCP则把数据流分割成适当长度的报文段，**最大传输段大小（MSS）通常受该计算机连接的网络的数据链路层的最大传送单元（MTU）**限制。之后TCP把数据包传给IP层，由它来通过网络将包传送给接收端实体的TCP层。
  • TCP为了保证报文传输的可靠，就给每个包一个序号，同时序号也保证了传送到接收端实体的包的按序接收。然后接收端实体对已成功收到的字节发回一个相应的确认（ACK）；如果发送端实体在合理的往返时延（RTT）内未收到确认，那么对应的数据（假设丢失了）将会被重传。

主要特点

（1）基于流的方式；
（2）面向连接；
（3）可靠通信方式；
（4）在网络状况不佳的时候尽量降低系统由于重传带来的带宽开销；
（5）通信连接维护是面向通信的两个端点的，而不考虑中间网段和节点。

工作方式

建立连接

TCP是因特网中的传输层协议，使用三次握手协议建立连接。当主动方发出SYN连接请求后，等待对方回答SYN+ACK，并最终对对方的 SYN 执行 ACK 确认。这种建立连接的方法可以防止产生错误的连接，TCP使用的流量控制协议是可变大小的滑动窗口协议。
在这里插入图片描述
TCP三次握手的过程如下：

  • 客户端发送SYN（SEQ=x）报文给服务器端，进入SYN_SEND状态。
  • 服务器端收到SYN报文，回应一个SYN （SEQ=y）ACK（ACK=x+1）报文，进入SYN_RECV状态。
  • 客户端收到服务器端的SYN报文，回应一个ACK（ACK=y+1）报文，进入Established状态。
    更详细的解释：（更容易理解）
    seq是序列号，这是为了连接以后传送数据用的，ack是对收到的数据包的确认，值是等待接收的数据包的序列号。
    在第一次消息发送中，A随机选取一个序列号作为自己的初始序号发送给B；
    第二次消息B使用ack对A的数据包进行确认，因为已经收到了序列号为x的数据包，准备接收序列号为x+1的包，所以ack=x+1，同时B告诉A自己的初始序列号，就是seq=y；
    第三条消息A告诉B收到了B的确认消息并准备建立连接，A自己此条消息的序列号是x+1，所以seq=x+1，而ack=y+1是表示A正准备接收B序列号为y+1的数据包。
    seq是数据包本身的序列号；ack是期望对方继续发送的那个数据包的序列号。
为什么需要三次握手

客户端发出去的第一个连接请求由于某些原因在网络节点中滞留了导致延迟，直到连接释放的某个时间点才到达服务端，这是一个早已失效的报文，但是此时服务端仍然认为这是客户端的建立连接请求第一次握手，于是服务端回应了客户端，第二次握手。
如果只有两次握手，那么到这里，连接就建立了，但是此时客户端并没有任何数据要发送，而服务端还在傻傻的等候佳音，造成很大的资源浪费。所以需要第三次握手，只有客户端再次回应一下，就可以避免这种情况。

连接终止

建立一个连接需要三次握手，而终止一个连接要经过四次握手，这是由**TCP的半关闭（half-close）**造成的。
在这里插入图片描述
（1） 某个应用进程首先调用close，称该端执行“主动关闭”（active close）。该端的TCP于是发送一个FIN分节，表示数据发送完毕。
（2） 接收到这个FIN的对端执行 “被动关闭”（passive close），这个FIN由TCP确认。
注意：FIN的接收也作为一个文件结束符（end-of-file）传递给接收端应用进程，放在已排队等候该应用进程接收的任何其他数据之后，因为，FIN的接收意味着接收端应用进程在相应连接上再无额外数据可接收。
（3） 一段时间后，接收到这个文件结束符的应用进程将调用close关闭它的套接字。这导致它的TCP也发送一个FIN。
（4） 接收这个最终FIN的原发送端TCP（即执行主动关闭的那一端）确认这个FIN。

为什么连接的时候是三次握手，关闭的时候却是四次握手

因为当Server端收到Client端的SYN连接请求报文后，可以直接发送SYN+ACK报文。其中ACK报文是用来应答的，SYN报文是用来同步的。但是关闭连接时，当Server端收到FIN报文时，很可能并不会立即关闭SOCKET，所以只能先回复一个ACK报文，告诉Client端，“你发的FIN报文我收到了”。只有等到我Server端所有的报文都发送完了，我才能发送FIN报文，因此不能一起发送。故需要四步握手。

半包粘包问题示例与分析

程序示例

服务器端程序

package test14;

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

public class StickyDemoServer {

	public static void main(String[] args) throws Exception {
		int port = 8080;
		if (args != null && args.length > 0) {
			try {
				port = Integer.valueOf(args[0]);
			} catch (NumberFormatException e) {
				// 采用默认值
			}
		}
		new StickyDemoServer().bind(port);
	}

	public void bind(int port) throws Exception {
		// 第一步：
		// 配置服务端的NIO线程组
		// 主线程组, 用于接受客户端的连接，但是不做任何具体业务处理，像老板一样，负责接待客户，不具体服务客户
		EventLoopGroup bossGroup = new NioEventLoopGroup(1);
		// 工作线程组, 老板线程组会把任务丢给他，让手下线程组去做任务，服务客户
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			// 类ServerBootstrap用于配置Server相关参数，并启动Server
			ServerBootstrap b = new ServerBootstrap();

			// 链式调用
			// 配置parentGroup和childGroup
			b.group(bossGroup, workerGroup)
					// 配置Server通道
					.channel(NioServerSocketChannel.class)
					// 配置通道的ChannelPipeline
					.childHandler(new ChildChannelHandler());

			// 绑定端口，并启动server，同时设置启动方式为同步
			ChannelFuture f = b.bind(port).sync();

			System.out.println(
					StickyDemoServer.class.getName() + " 启动成功，在地址[" + f.channel().localAddress() + "]上等待客户请求......");

			// 等待服务端监听端口关闭
			f.channel().closeFuture().sync();
		} finally {
			// 优雅退出，释放线程池资源
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
		}
	}

	private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
		@Override
		protected void initChannel(SocketChannel ch) throws Exception {
			ch.pipeline().addLast(new StickyDemoServerHandler());
		}
	}
}


package test14;

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

public class StickyDemoServerHandler extends ChannelInboundHandlerAdapter {

   @Override
   public void channelRead(ChannelHandlerContext ctx, Object msg) {
       ByteBuf in = (ByteBuf) msg;
       System.out.println(
               "服务器接收到消息：" + in.toString(CharsetUtil.UTF_8));
       ctx.write(in);
   }

   @Override
   public void channelReadComplete(ChannelHandlerContext ctx)
           throws Exception {
       ctx.writeAndFlush(Unpooled.EMPTY_BUFFER)
               .addListener(ChannelFutureListener.CLOSE);
   }

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

客户端程序

package test14;

import io.netty.bootstrap.Bootstrap;
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.NioSocketChannel;

public class StickyDemoClient {

    public static void main(String[] args) throws Exception {
        int port = 8080;
        if (args != null && args.length > 0) {
            try {
                port = Integer.valueOf(args[0]);
            } catch (NumberFormatException e) {
             }
        }
        new StickyDemoClient().connect(port, "127.0.0.1");
    }

    public void connect(int port, String host) throws Exception {
        // 工作线程组 
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioSocketChannel.class)
                    //是否启用Nagle算法，该算法将小的碎片数据连接成更大的报文来最小化所发送的报文的数量
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                        	ch.pipeline().addLast(new StickyDemoClientHandler());

                        }
                    });

            // 发起异步连接操作
            ChannelFuture f = b.connect(host, port).sync();

            // 等待客户端链路关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放线程池资源
            group.shutdownGracefully();
        }
    }
}

package test14;

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

public class StickyDemoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
	
	private static String[] alphabets = {"A", "B", "C", "D", "E", "F", "G", "H", "I",
			                      "J", "K", "L", "M", "N", "O", "P"};
	
	@Override
	public void channelActive(ChannelHandlerContext ctx) {
		for(int i=0; i<10; i++) {
			StringBuilder builder = new StringBuilder();
			builder.append("这是第");
			builder.append(i);
			builder.append("条消息, 内容是：");
            for(int j=0; j<100; j++) {
            	builder.append(alphabets[i]);
            }
			builder.append("......");
			builder.append("#");


			System.out.println(builder.toString().getBytes().length);

			ctx.writeAndFlush(Unpooled.copiedBuffer(builder.toString(),
					CharsetUtil.UTF_8));
		}
	}

	@Override
	public void channelRead0(ChannelHandlerContext ctx, ByteBuf in) {
		System.out.println("客户端接收到消息： " + in.toString(CharsetUtil.UTF_8));
	}

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

运行结构

服务端

test14.StickyDemoServer 启动成功，在地址[/0:0:0:0:0:0:0:0:8080]上等待客户请求......
服务器接收到消息：这是第0条消息, 内容是：AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA......#这是第1条消息, 内容是：BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB......#这是第2条消息, 内容是：CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC......#这是第3条消息, 内容是：DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD......#这是第4条消息, 内容是：EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE......#这是第5条消息, 内容是：FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF......#这是第6条消息, 内容是：GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG......#这是第7条消息, 内容是：HHHHHHHHHHH
服务器接收到消息：HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH......#这是第8条消息, 内容是：IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII......#这是第9条消息, 内容是：JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ......#

客户端

140
140
140
140
140
140
140
140
140
140
客户端接收到消息： 这是第0条消息, 内容是：AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA......#这是第1条消息, 内容是：BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB......#这是第2条消息, 内容是：CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC......#这是第3条消息, 内容是：DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD......#这是第4条消息, 内容是：EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE......#这是第5条消息, 内容是：FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF......#这是第6条消息, 内容是：GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG......#这是第7条消息, 内容是：HHHHHHHHHHH
客户端接收到消息： HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH......#这是第8条消息, 内容是：IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII......#这是第9条消息, 内容是：JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ......#

Process finished with exit code 0

很明显，这不是我们要的结果。出现了粘包问题

netty半包粘包问题解决

基本解决思路

不断从TCP缓冲区中读取数据，每次读取完都需要判断是否是一个完整的数据包

  • 若当前读取的数据不足以拼接成一个完整的业务数据包，那就保留该数据，继续从tcp缓冲区中读取，直到得到一个完整的数据包。
  • 若当前读到的数据加上已经读取的数据足够拼接成一个数据包，那就将已经读取的数据拼接上本次读取的数据，够成一个完整的业务数据包传递到业务逻辑，多余的数据仍然保留，以便和下次读到的数据尝试拼接

判断是否是一个完整的数据包的办法

  • 定长
    只给出关键代码段
package test15;

import io.netty.bootstrap.Bootstrap;
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.NioSocketChannel;
import io.netty.handler.codec.FixedLengthFrameDecoder;

public class StickyDemoClient {

    public static void main(String[] args) throws Exception {
        int port = 8080;
        if (args != null && args.length > 0) {
            try {
                port = Integer.valueOf(args[0]);
            } catch (NumberFormatException e) {
             }
        }
        new StickyDemoClient().connect(port, "127.0.0.1");
    }

    public void connect(int port, String host) throws Exception {
        // 工作线程组 
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioSocketChannel.class)
                    //是否启用Nagle算法，该算法将小的碎片数据连接成更大的报文来最小化所发送的报文的数量
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                        //此处为关键代码
                            ch.pipeline().addLast("framer", new FixedLengthFrameDecoder(140));
                        	ch.pipeline().addLast(new StickyDemoClientHandler());

                        }
                    });

            // 发起异步连接操作
            ChannelFuture f = b.connect(host, port).sync();

            // 等待客户端链路关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放线程池资源
            group.shutdownGracefully();
        }
    }
}

package test15;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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.FixedLengthFrameDecoder;

public class StickyDemoServer {

	public static void main(String[] args) throws Exception {
		int port = 8080;
		if (args != null && args.length > 0) {
			try {
				port = Integer.valueOf(args[0]);
			} catch (NumberFormatException e) {
				// 采用默认值
			}
		}
		new StickyDemoServer().bind(port);
	}

	public void bind(int port) throws Exception {
		// 第一步：
		// 配置服务端的NIO线程组
		// 主线程组, 用于接受客户端的连接，但是不做任何具体业务处理，像老板一样，负责接待客户，不具体服务客户
		EventLoopGroup bossGroup = new NioEventLoopGroup(1);
		// 工作线程组, 老板线程组会把任务丢给他，让手下线程组去做任务，服务客户
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			// 类ServerBootstrap用于配置Server相关参数，并启动Server
			ServerBootstrap b = new ServerBootstrap();

			// 链式调用
			// 配置parentGroup和childGroup
			b.group(bossGroup, workerGroup)
					// 配置Server通道
					.channel(NioServerSocketChannel.class)
					// 配置通道的ChannelPipeline
					.childHandler(new ChildChannelHandler());

			// 绑定端口，并启动server，同时设置启动方式为同步
			ChannelFuture f = b.bind(port).sync();

			System.out.println(
					StickyDemoServer.class.getName() + " 启动成功，在地址[" + f.channel().localAddress() + "]上等待客户请求......");

			// 等待服务端监听端口关闭
			f.channel().closeFuture().sync();
		} finally {
			// 优雅退出，释放线程池资源
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
		}
	}

	private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
		@Override
		protected void initChannel(SocketChannel ch) throws Exception {
		//此处为关键代码
			ch.pipeline().addLast("framer", new FixedLengthFrameDecoder(140));
			ch.pipeline().addLast(new StickyDemoServerHandler());
		}
	}
}

运行结果如下图：
在这里插入图片描述
在这里插入图片描述

  • 分隔符
    服务端
private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
		@Override
		protected void initChannel(SocketChannel ch) throws Exception {
			ch.pipeline().addLast("framer", new DelimiterBasedFrameDecoder(8192,
					Unpooled.wrappedBuffer(new byte[] { '#' })));
			ch.pipeline().addLast(new StickyDemoServerHandler());
		}
	}

package test16;

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

public class StickyDemoServerHandler extends ChannelInboundHandlerAdapter {

   @Override
   public void channelRead(ChannelHandlerContext ctx, Object msg) {
       ByteBuf in = (ByteBuf) msg;
       System.out.println(
               "服务器接收到消息：" + in.toString(CharsetUtil.UTF_8));
       ctx.write(in);
       ctx.write(Unpooled.copiedBuffer("#", CharsetUtil.UTF_8));
   }

   @Override
   public void channelReadComplete(ChannelHandlerContext ctx)
           throws Exception {
       ctx.writeAndFlush(Unpooled.EMPTY_BUFFER)
               .addListener(ChannelFutureListener.CLOSE);
   }

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

客户端

public void connect(int port, String host) throws Exception {
        // 工作线程组 
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioSocketChannel.class)
                    //是否启用Nagle算法，该算法将小的碎片数据连接成更大的报文来最小化所发送的报文的数量
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast("framer", new DelimiterBasedFrameDecoder(8192,
                                    Unpooled.wrappedBuffer(new byte[] { '#' })));
                        	ch.pipeline().addLast(new StickyDemoClientHandler());

                        }
                    });

            // 发起异步连接操作
            ChannelFuture f = b.connect(host, port).sync();

            // 等待客户端链路关闭
            f.channel().closeFuture().sync();
        } finally {
            // 优雅退出，释放线程池资源
            group.shutdownGracefully();
        }
    }

运行结果如下：
在这里插入图片描述
在这里插入图片描述

  • 基于长度的变长包
yemuxiaweiliang
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用netty实现tcp简单通信
mistt的博客
02-16 1万+
一般我们想要使用tcp通信，最原始的方法就是使用socket套接字，但是每次都要创建新的socket对象，并且在finally中关闭，好浪费资源，很麻烦。所以就是用netty工具，可以轻松地实现tcp通信，当然也可以实现http通信，因为我们需要用tcp通信，所以这里只研究tcp。 最好先了解一下netty是干嘛的，以及NIO是什么。 netty： https://blog.csdn.net/qq_34730511/article/details/98472924?ops_request_misc=&
Netty协议之 TCP （一）
shuoshuo132的博客
06-23 2531
前言 本章将会介绍如何使用Netty搭建一个TCP服务器，本系列不会详细介绍Netty本身框架。 TCP 协议 传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议。 Netty 支持 导入依赖包 // gradle compile group: 'io.netty', name: 'netty-all', version: '4.1.50.Final' // maven <dependency> &lt
亲测！超详细的使用netty进行tcp数据通信的流程
最新发布
小红的成长日记
05-17 1631
超详细
【Java】Netty创建网络服务端客户端（TCP/UDP）
DevFrank的博客
11-09 4273
Netty创建网络服务端客户端示例
Netty实现自定义协议
weixin_33722405的博客
04-29 6359
2019独角兽企业重金招聘Python工程师标准>>> ...
Netty进阶篇——协议设计与解析
weixin_52315708的博客
06-29 251
、测试使用redis协议进行与redis的通信 Reids通信协议格式是： set name zhangsan *3 三个部分组成：命令、key、value $3 set $8 zhangsan
Netty.zip_TCP/IP协议栈_Java__TCP/IP协议栈_Java_
08-09
总的来说，Netty结合TCP/IP协议栈和IEC104规约，为电力系统的网络通信提供了一套强大的解决方案。通过定制的解码器和编码器，我们可以高效地处理IEC104数据，同时利用Netty的异步特性来应对高并发场景。在实际开发...
Java实现TCP/IP协议的收发数据（服务端）代码实例
08-25
Java实现TCP/IP协议的收发数据（服务端）代码实例 以下是关于Java实现TCP/IP协议的收发数据（服务端）代码实例的知识点摘要： 一、 Java TCP/IP 协议简介 TCP/IP 协议是一种网络通信协议，用于在不同设备之间进行...
netty搭建tcp自定义协议websocket服务器, 支持ssl demo
05-24
netty搭建tcp自定义协议websocket服务器, 支持ssl demo. 适用于netty初学者, netty搭建自定义协议, websocket服务器, 聊天室, 一个端口集成多协议,包括ssl协议
网络编程及Netty使用Java代码示例.zip
12-27
Java作为一种广泛使用的编程语言，提供了丰富的API来支持网络编程，而Netty则是一个高性能、异步事件驱动的网络应用框架，用于快速开发可维护的高性能协议服务器和客户端。 在Java中，基础的网络编程通常依赖于`...
Netty5.0TCP/IP上传大文件
03-08
Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。在这个“Netty5.0TCP/IP上传大文件”的示例中，我们将探讨如何利用Netty5.x版本处理大文件的上传，特别关注...
Netty进阶-协议设计与解析
adzn1的博客
05-06 1070
魔数(四个字节)：用来在第一时间判定是否是无效数据包版本号(一个字节)：可以支持协议的升级序列化算法(一个字节)：消息正文到底采用哪种序列化反序列化方式，可以由此扩展，例如：json、protobuf、hessian、jdk指令类型(一个字节)：是登录、注册、单聊、群聊... 跟业务相关请求序号(四个字节)：为了双工通信，提供异步能力对齐填充(一个字节)：除正文长度和消息正文凑满16个字节，也就是2的n次方正文长度(四个字节)：正文的长度消息正文：正文内容（根据序列化算法进行序列化成字节）
Netty协议设计与解析
安逸
05-05 1485
简单记录一下netty协议的编写和使用过程，方便后面查看。
网络协议和Netty——第一章 网络协议笔记
hankin的博客
06-28 1557
一、计算机网络体系结构 1、OSI七层模型 开放系统互连参考模型 (Open System Interconnect 简称OSI）是国际标准化组织(ISO)和国际电报电话咨询委员会(CCITT)联合制定的开放系统互连参考模型，为开放式互连信息系统提供了一种功能结构的框架。其目的是为异种计算机互连提供一个共同的基础和标准框架，并为保持相关标准的一致性和兼容性提供共同的参考。这里所说的开放系统，实...
netty系列之:netty对SOCKS协议的支持
程序那些事
01-06 7587
文章目录简介SocksMessageSocks4MessageSocks5Message总结 简介 SOCKS是一个优秀的网络协议，主要被用来做代理，它的两个主要版本是SOCKS4和SOCKS5，其中SOCKS5提供了对认证的支持。通常来说我们使用SSH工具可以构建简单的SOCKS协议通道，那么对于netty来说，是怎么提供对SOCKS的支持呢？一起来看看吧。 SocksMessage 首先是代表SOCKS消息对象的SocksMessage。SocksMessage是一个接口，它里面只有一个返回SocksV
【Netty】九、Netty自定义协议
weixin_43333483的博客
11-06 1779
公有协议（http、tcp）、私有协议（自己定义的，不是行业标准）我们知道使用最为广泛的是HTTP协议，但是在一些服务交互领域，其使用则相对较少，主要原因有三方面：1、HTTP协议会携带诸如header和cookie等信息，其本身对字节的利用率较低，这使得HTTP协议比较臃肿，在承载相同信息的情况下，HTTP协议将需要发送更多的数据包；
使用 Netty 实现 HTTP 和 TCP
weixin_44492502的博客
04-02 3998
使用 Netty 实现 HTTP 和 TCPHttp ClientHttpClient 客户端HttpClientHandler 处理类Http ServerNettyHttpServer 服务端HttpServerInitializer 初始化类HttpServerRequestHandler 处理类Tcp ClientRpcRequest 实体类RpcResponse 实体类RpcEncoder 编码RpcDecoder 解码TcpClient 客户端TcpClientInitializer 初始化
Netty进阶之自定义协议
weixin_38598961的博客
04-26 518
Netty进阶之自定义协议
Netty协议的设计与解析
weixin_46120888的博客
05-06 981
文章目录1.协议的引入2. HTTP协议的编解码实现3. 自定义协议3.1自定义协议的要素3.2 自定义协议通过Netty进行编解码4. 啥时候用@Sharable 参考黑马程序员 1.协议的引入 协议就是客户端向服务端发送消息的时候，双方约定俗成的一套规矩，比如我在redis中创建一个key，value。按理说要用到这个命令，set key value。这个命令在发送的时候会被解析成redis服务器能看懂的形式。比如说set name zhangsan你看到的只是一条命令，实际上向服务端发送的是这样的
netty modbustcp
09-04
Netty是一个高性能的网络编程框架，而Modbus TCP是一种基于TCP/IP协议的通信协议，用于将数据从一台计算机传输到另一台计算机。在Netty中，可以利用其提供的API和功能来实现Modbus TCP通信。 要在Netty中实现Modbus TCP通信，你需要创建一个Netty的服务器端和客户端。服务器端负责监听来自客户端的连接请求，并处理接收到的Modbus请求；而客户端则负责向服务器发送Modbus请求，并处理服务器的响应。 你可以使用Netty的ChannelHandler来处理Modbus请求和响应。在服务器端，你可以编写一个自定义的ChannelInboundHandler来解析和处理接收到的Modbus请求，并根据请求进行相应的业务逻辑处理。而在客户端，你可以使用Netty提供的ChannelFuture来发送Modbus请求，并根据响应进行相应的处理。 除了处理Modbus请求和响应外，你还可以利用Netty的其他功能来提高通信性能，例如使用ByteBuf来进行数据的读写操作，使用EventLoop来实现异步非阻塞的通信等等。 总之，借助Netty框架，你可以方便地实现基于Modbus TCP协议的网络通信。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yemuxiaweiliang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值