java Netty 之 字符串消息收发（ChannelBuffer）

最新推荐文章于 2025-06-13 15:14:11 发布
最新推荐文章于 2025-06-13 15:14:11 发布
阅读量2.4k 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： java--NIO--Netty 文章标签： netty java 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yjc0403/article/details/84876598
本文介绍了在Netty中如何处理字符串消息，强调所有消息必须以ChannelBuffer形式传递。通过示例代码展示了如何将字符串转换为ChannelBuffer，以及ChannelBuffer的基本操作，包括读写、缓冲区划分、常见方法的使用等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

java Netty 之 字符串消息收发（ChannelBuffer）

 

 

ChannelBuffer



 

      Netty中的消息传递，都必须以字节的形式，以ChannelBuffer为载体传递。简单的说，就是你想直接写个字符串过去，对不起，抛异常。虽然，Netty定义的writer的接口参数是Object的，这可能也是会给新上手的朋友容易造成误会的地方。Netty源码中，是这样判断的：

 

SendBuffer acquire(Object message) {
	if (message instanceof ChannelBuffer) {
		return acquire((ChannelBuffer) message);
	} else if (message instanceof FileRegion) {
		return acquire((FileRegion) message);
	}
 
	throw new IllegalArgumentException("unsupported message type: " + message.getClass());
}

 

 

所以，我们要想传递字符串，那么就必须转换成ChannelBuffer。明确了这一点，接下来我们上代码：

 

 

public class MessageServer {
 
	public static void main(String args[]) {
		// Server服务启动器
		ServerBootstrap bootstrap = new ServerBootstrap(
			new NioServerSocketChannelFactory(
			Executors.newCachedThreadPool(),
			Executors.newCachedThreadPool()));

		// 设置一个处理客户端消息和各种消息事件的类(Handler)
		bootstrap.setPipelineFactory(new ChannelPipelineFactory() {

			@Override
			public ChannelPipeline getPipeline() throws Exception {
				return Channels.pipeline(new MessageServerHandler());
			}
		});

		// 开放8000端口供客户端访问。
		bootstrap.bind(new InetSocketAddress(8000));
	}
 
	private static class MessageServerHandler extends SimpleChannelHandler {
 
		/**
		* 用户接受客户端发来的消息，在有客户端消息到达时触发
		*
		*/
		@Override
		public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
			ChannelBuffer buffer = (ChannelBuffer) e.getMessage();
			System.out.println(buffer.toString(Charset.defaultCharset()));
		}
		
	}
}


public class MessageClient {
 
	public static void main(String args[]) {
		// Client服务启动器
		ClientBootstrap bootstrap = new ClientBootstrap(
			new NioClientSocketChannelFactory(
			Executors.newCachedThreadPool(),
			Executors.newCachedThreadPool()));
	
		// 设置一个处理服务端消息和各种消息事件的类(Handler)
		bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
			@Override
			public ChannelPipeline getPipeline() throws Exception {
				return Channels.pipeline(new MessageClientHandler());
			}
		});

		// 连接到本地的8000端口的服务端
		bootstrap.connect(new InetSocketAddress("127.0.0.1", 8000));
	}
 
	private static class MessageClientHandler extends SimpleChannelHandler {
 
		/**
		* 当绑定到服务端的时候触发，给服务端发消息。
		*/
		@Override
		public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) {
			
			// 将字符串，构造成ChannelBuffer，传递给服务端
			String msg = "Hello, I'm client.";
			ChannelBuffer buffer = ChannelBuffers.buffer(msg.length());
			buffer.writeBytes(msg.getBytes());
			e.getChannel().write(buffer);
		}
	}
}
 

 

       与 前面“Hello World” 样例代码不同的是，客户端在channel连通后，不是在本地打印，而是将消息转换成ChannelBuffer传递给服务端，服务端接受到ChannelBuffer后，解码成字符串打印出来。

 

 

 

 

数据的读和写

 

      在TCP/IP这种基于流传递的协议中。他识别的不是你每一次发送来的消息，不是分包的。而是，只认识一个整体的流，即使分三次分别发送三段话：ABC、DEF、GHI。在传递的过程中，他就是一个具有整体长度的流。在读流的过程中，如果我一次读取的长度选择的不是三个，我可以收到类似AB、CDEFG、H、I这样的信息。这显然是我们不想看到的。所以说，在你写的消息收发的系统里，需要预先定义好这种解析机制，规定每帧(次)读取的长度。通过代码来理解一下：

 

 

public class ServerBufferHandler extends SimpleChannelHandler {
 
	/**
	* 用户接受客户端发来的消息，在有客户端消息到达时触发
	*
	*/
	@Override
	public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
		
		ChannelBuffer buffer = (ChannelBuffer) e.getMessage();

		// 五位读取
		while (buffer.readableBytes() >= 5) {
			ChannelBuffer tempBuffer = buffer.readBytes(5);
			System.out.println(tempBuffer.toString(Charset.defaultCharset()));
		}

		// 读取剩下的信息
		System.out.println(buffer.toString(Charset.defaultCharset()));
	}
}
 

 

 

public class ClientBufferHandler extends SimpleChannelHandler {
 
	/**
	* 当绑定到服务端的时候触发，给服务端发消息。
	*
	*/
	@Override
	public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) {

		// 分段发送信息
		sendMessageByFrame(e);
	}
 
	/**
	* 将<b>"Hello, I'm client."</b>分成三份发送。 
	* Hello, 
	* I'm
	* client.
	*
	* @param e	Netty事件
	*/
	private void sendMessageByFrame(ChannelStateEvent e) {
		String msgOne = "Hello, ";
		String msgTwo = "I'm ";
		String msgThree = "client.";
		e.getChannel().write(tranStr2Buffer(msgOne));
		e.getChannel().write(tranStr2Buffer(msgTwo));
		e.getChannel().write(tranStr2Buffer(msgThree));
	}
 
	/**
	* 将字符串转换成{@link ChannelBuffer}，私有方法不进行字符串的非空判断。
	*
	* @param str	待转换字符串，要求非null
	*            
	* @return 转换后的ChannelBuffer
	*/
	private ChannelBuffer tranStr2Buffer(String str) {
		ChannelBuffer buffer = ChannelBuffers.buffer(str.length());
		buffer.writeBytes(str.getBytes());
		return buffer;
	}
}
 

 

输出结果：

Hello

, I'm

 clie

nt.

 

 

注意：

       这里其实，服务端是否分段发送并不会影响输出结果，也就是说，你一次性的把"Hi, I'm client."这段信息发送过来，输出的结果也是一样的。这就是开头说的，传输的是流，不分包。而只在于你如何分段读写。

 

 

 

 

ChannelBuffer的结构

 

ChannelBuffer是Netty中比较常用的一个类，其功能类似于字符数组，可以对其进行读写操作。

 

ChannelBuffer的模型图如下：



 

 

如上图所示，一个ChannelBuffer被划分为三个部分：

 

  • discardable：表示已经读过的内容缓冲区
  • readable：表示可读的内容缓冲区
  • writable：表示可写的内容缓冲区

 

 

ChannelBuffer的这三个缓冲区由2个内部控制指针来控制：

 

  • readerIndex：控制读缓冲区首地址
  • writerIndex：控制写缓冲区首地址

 

因此，ChannelBuffer提供的大部分操作都是围绕readerIndex和writerIndex来进行的。

 

 

 

 

ChannelBuffer的常用方法

 

1、

 

read()/skip()

从readerIndex读出或跳过指定数目的字节，同时readerIndex = readerIndex + byteNumber.如果readerIndex > capacity，表示读取下标越界，会抛出IndexOutOfBoundsException异常

 

 

readable()：boolean

如果buffer有可读内容（此时writerIndex > readerIndex）,则返回true，否则返回false

 

 

readerIndex():int

返回readerIndex

 

readableBytes():int

返回可读的字节数目(writerIndex - readerIndex)

 

 

2、

 

write();

写入指定数目的字节，同时writerIndex = writerIndex + byteNumber. 如果writerIndex > capacity，表示写入下标越界，会抛出IndexOutOfBoundsException异常

 

 

writable():boolean

如果buffer有可写入空间（此时writerIndex < capacity），则返回true，否则返回false。

 

 

writerIndex(): int

返回writerIndex

 

 

writeableIndex():int

返回可写入的字节数（capacity - writerIndex）。

 

 

3、

 

discardReadBytes()

丢弃已读的内容。其执行过程如下：



 

 

4、

 

clear()

丢弃所有的数据，并将readerIndex和writerIndex重置为0。



 

 

5、

 

markReaderIndex()

markWriterIndex()

 

保存readerIndex或writerIndex的状态

 

 

6、

 

resetReaderIndex()

resetWriterIndex()

 

重置readerIndex或writerIndex为最后一次保存的状态，如果没有保存过，则置为0

 

 

7、

 

duplicate()

slice()

 

拷贝和源目标共享buffer的数据区域，但是拷贝有自己的readerIndex和writerIndex以及markIndex，实际上只是拷贝了控制指针，数据区还是与源buffer共享。

 

 

8、

 

copy()

拷贝整个buffer，包括控制指针和数据区

 

 

 

测试代码：

 

 

package test;

import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;

public class ChannelBufferTest {

    public static void main( String[] args ) {
        // TODO Auto-generated method stub
        ChannelBuffer buffer = ChannelBuffers.buffer( 10 );
        System.out.println("readable bytes: " + buffer.readableBytes( ));
        System.out.println("readable index: " + buffer.readerIndex( ));
        System.out.println("writable bytes: " + buffer.writableBytes( ));
        System.out.println("writable index: " + buffer.writerIndex( ));
        
        buffer.writeInt( 10 );
        System.out.println("after write one integer");
        System.out.println("readable bytes: " + buffer.readableBytes( ));
        System.out.println("readable index: " + buffer.readerIndex( ));
        System.out.println("writable bytes: " + buffer.writableBytes( ));
        System.out.println("writable index: " + buffer.writerIndex( ));

        buffer.writeInt( 10 );
        System.out.println("after write two integer");
        System.out.println("readable bytes: " + buffer.readableBytes( ));
        System.out.println("readable index: " + buffer.readerIndex( ));
        System.out.println("writable bytes: " + buffer.writableBytes( ));
        System.out.println("writable index: " + buffer.writerIndex( ));
        
        int i = buffer.readInt( );
        System.out.println("after read one integer: " + i);
        System.out.println("readable bytes: " + buffer.readableBytes( ));
        System.out.println("readable index: " + buffer.readerIndex( ));
        System.out.println("writable bytes: " + buffer.writableBytes( ));
        System.out.println("writable index: " + buffer.writerIndex( ));
        
        buffer.discardReadBytes( );
        System.out.println("after discard read bytes");
        System.out.println("readable bytes: " + buffer.readableBytes( ));
        System.out.println("readable index: " + buffer.readerIndex( ));
        System.out.println("writable bytes: " + buffer.writableBytes( ));
        System.out.println("writable index: " + buffer.writerIndex( ));
        
        buffer.resetReaderIndex( );
        System.out.println("after reset reader index");
        System.out.println("readable bytes: " + buffer.readableBytes( ));
        System.out.println("readable index: " + buffer.readerIndex( ));
        System.out.println("writable bytes: " + buffer.writableBytes( ));
        System.out.println("writable index: " + buffer.writerIndex( ));
        
        buffer.resetWriterIndex( );
        System.out.println("after reset writer index");
        System.out.println("readable bytes: " + buffer.readableBytes( ));
        System.out.println("readable index: " + buffer.readerIndex( ));
        System.out.println("writable bytes: " + buffer.writableBytes( ));
        System.out.println("writable index: " + buffer.writerIndex( ));
    }
}
 

 

 

结果：

 

readable bytes: 0

readable index: 0

writable bytes: 10

writable index: 0

after write one integer

readable bytes: 4

readable index: 0

writable bytes: 6

writable index: 4

after write two integer

readable bytes: 8

readable index: 0

writable bytes: 2

writable index: 8

after read one integer: 10

readable bytes: 4

readable index: 4

writable bytes: 2

writable index: 8

after discard read bytes

readable bytes: 4

readable index: 0

writable bytes: 6

writable index: 4

after reset reader index

readable bytes: 4

readable index: 0

writable bytes: 6

writable index: 4

after reset writer index

readable bytes: 0

readable index: 0

writable bytes: 10

writable index: 0

netty源码分析(一)——ChannelBuffer
weixin_48674103的博客
06-27 503
netty源码分析持续更新文章，建议先关注收藏哦~以免下次不好找 netty源码分析之ChannelBuffer netty源码分析之Channel接口 netty源码分析之ServerChannel netty源码分析之ChannelConfig netty源码分析之ChannelEvent netty源码分析之ChannelSink netty源码分析之ChannelHandler netty源码分析之ChannelPipeline netty源码分析之ChannelFuture n
Netty ChannelBuffer 简介
热门推荐
lxgwm2008的专栏
07-11 1万+
ChannelBuffer是Netty中比较常用的一个类，其功能类似于字符数组，可以对其进行读写操作。 ChannelBuffer的模型图如下：  +-------------------+------------------+------------------+  | discardable bytes |  readable bytes  |  writable bytes
java中使用netty框架对客户端消息进行收发操作
最新发布
LiuGangsama的博客
06-13 183
编写NettyServerChannelInitializer类，对netty框架进行整体配置。专门编写一个ChannelHandler1类，使用ChannelGroup对消息进行广播。编写启动LaunchRunner类，当项目启动时，netty服务一起启动。编写收发消息的配置类DecoderUtil和EncoderUtil。ChannelHandler类，使用通道进行收发消息等操作。编写ChannelMap类，用来管理全局连接通道。NettyListener类，对通道进行监听。首先导入netty的依赖。
Netty源码解读（二）Netty中的buffer
kobejayandy的专栏
02-16 2266
上一篇文章我们概要介绍了Netty的原理及结构，下面几篇文章我们开始对Netty的各个模块进行比较详细的分析。Netty的结构最底层是buffer模块，这部分也相对独立，我们就先从buffer讲起。 What: buffer二三事 buffer中文名又叫缓冲区，按照维基百科的解释，是”在数据传输时，在内存里开辟的一块临时保存数据的区域”。它其实是一种化同步为异步的机制，可以解决数据传输的速
netty ChannelBuffer
yyhwyd的博客
03-14 334
       ChannelBuffer是netty自己的缓冲区，用于替代nio的Buffer，这种替代具有显著的优势，解决了Buffer存在的一些问题，满足了日常网络应用程序开发的需求。具有以下特点: 如果必要的话,可以定义自己的ChannelBuffer。 通过复合缓冲区CompositeChannelBuffer实现透明的零拷贝”Zero-Copy-Capable”。 提供了一个...
netty之channelbuffer
weixin_34128411的博客
12-08 203
2019独角兽企业重金招聘Python工程师标准>>> ...
JAVA netty 获取串口数据并且下发数据
03-19
Java Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。在标题中提到的“JAVA Netty 获取串口数据并且下发数据”，这意味着我们将探讨如何利用Netty来处理串行...
Java NIO框架Netty教程（四）- ChannelBuffer
CoderCoding的博客
07-25 846
​ 在字符串消息收发中提到。ChannelBuffer是Netty中非常重要的概念。所有消息的收发都依赖于这个Buffer。我们通过Netty的官方的文档来了解一下，基于流的消息传递机制。
Netty发送字符串
zsj777的专栏
04-15 1020
服务端代码： EchoServer 启动类 package com.tcp.echo; /** * @Description TODO * @Date 2020/4/15 19:08 * @Author zsj */ import java.nio.charset.Charset; import io.netty.bootstrap.ServerBootstrap; imp...
Netty之ByteBuf读写字符串
zsj777的专栏
04-14 1204
1、pom <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.75.Final</version> </dependency> package com.example.demo.
Socket通讯-Netty框架实现Java通讯(字符串信息的传输)
半度微凉
09-16 1万+
Netty简介Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。
netty学习之ChannelBuffer
勤奋的asialee的博客
11-21 303
[size=large][color=blue] 这个类的学习其实我感觉看ChannelBuffer的javadoc就能明白大概，也就是网上说的有readerIndex和writerIndex,以及和这两个相关的 markedReaderIndex和markedWriterIndex，我这里重点看一下discardReadBytes 这个函数的实现吧： [/color][/size] ...
netty 源码分析之（七）ChannelBuffer
liao49的专栏
03-06 752
来自：http://fbi.taobao.org/?p=51   整体的类图在API文档上已经有了详细的说明：http://netty.io/docs/stable/api/ 基本上的类都是继承自AbstractChannelBuffer，其他的都是接口或者工厂类，另外也有部分会实现WrappedChannelBuffer接口。 这里使用了典型的模板模式，AbstractChannel...
Netty中ChannelBuffer详解
yangfanchao的专栏
05-18 9735
最近在项目中要用到Netty框架，期间碰到了很多ChannelBuffer的使用，但是了解不多，被各种readable、readableBytes……搞的晕晕的，所以仔细研究了一下这个ChannelBuffer的结构，算是做个笔记吧。 首先上个简单的结构图吧： +-------------------+------------------+------------------+ | d
Java NIO框架Netty教程(四) ChannelBuffer（转）
jguangyou的专栏
03-01 221
在学字符串消息收发(http://www.it165.net/pro/html/201207/3174.html)的时候，已经提到过。ChannelBuffer是Netty中非常重要的概念。所有消息的收发都依赖于这个Buffer。我们通过Netty的官方的文档来了解一下，基于流的消息传递机制。   In a stream-based transport such as TCP/IP, rec...
一个参考Java开源框架Netty-ChannelBuffer类的简单实现
huangjh2017的博客
07-01 714
ChannelBuffer是参考Java开源框架Netty的ChannelBuffer，整个ChannelBuffer的模型如下：
netty大白话--字符串的收发（三）
影子
05-05 665
了解了Netty的基本概念，开发起来应该会顺手很多。在“Hello World”代码中，我们只是在完成绑定的时候，在各自的本地打印了简单的信息，并没有客户端和服务端的消息传递。这个肯定是最基本的功能。在上代码之前，先补充一个Netty中重要的概念，ChannelBuffer。 ChannelBuffer Netty中的消息传递，都必须以字节的形式，以ChannelBuffer为载体传递。简单的...
Netty工作笔记0017---Channel和Buffer梳理
添柴程序猿的专栏
09-17 308
技术交流QQ群【JAVA,C++,Python,.NET,BigData,AI】：170933152
Java Netty 学习(二) - NIO基础知识Buffer
anLA_的专栏
03-20 1833
对于NIO，需要知道几个概念，Channel，Buffer，非阻塞，Selectors： - 标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。 即相关的操作，是针对Channel与与Buffer的。 - 另一方面，Java NIO可以让你非阻塞的使用IO，例如：当线程从通道读取数据到缓冲区时
Java Netty实现串口数据接收与测试工具教程
根据给定的文件信息，本知识点将围绕如何使用Java中的Netty框架来接收串口数据进行展开。同时，将涉及到串口通信的基础知识、如何使用Netty进行串口数据处理以及相关的工具和文档资源的使用方法。 首先，Netty是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值