`
san_yun
  • 浏览: 2662321 次
  • 来自: 杭州
文章分类
社区版块
存档分类
最新评论

ChannelBuffer介绍介绍

 
阅读更多

A random and sequential accessible sequence of zero or more bytes (octets). This interface provides an abstract view for one or more primitive byte arrays (byte[] ) and  NIO buffers .

Creation of a buffer

It is recommended to create a new buffer using the helper methods in  ChannelBuffers   rather than calling an individual implementation's constructor.

Random Access Indexing

Just like an ordinary primitive byte array,  ChannelBuffer   uses  zero-based indexing . It means the index of the first byte is always  0   and the index of the last byte is always  capacity - 1 . For example, to iterate all bytes of a buffer, you can do the following, regardless of its internal implementation:

 ChannelBuffer buffer = ...;
 for (int i = 0; i < buffer.capacity(); i ++) {
     byte b = array.getByte(i);
     System.out.println((char) b);
 }
 

Sequential Access Indexing

ChannelBuffer   provides two pointer variables to support sequential read and write operations -  readerIndex   for a read operation and  writerIndex   for a write operation respectively. The following diagram shows how a buffer is segmented into three areas by the two pointers:

      +-------------------+------------------+------------------+
      | discardable bytes |  readable bytes  |  writable bytes  |
      |                   |     (CONTENT)    |                  |
      +-------------------+------------------+------------------+
      |                   |                  |                  |
      0      <=      readerIndex   <=   writerIndex    <=    capacity
 

Readable bytes (the actual content)

This segment is where the actual data is stored. Any operation whose name starts with  read   or  skip   will get or skip the data at the current  readerIndex   and increase it by the number of read bytes. If the argument of the read operation is also a  ChannelBuffer   and no destination index is specified, the specified buffer's  readerIndex   is increased together.

If there's not enough content left,  IndexOutOfBoundsException   is raised. The default value of newly allocated, wrapped or copied buffer's  readerIndex   is  0 .

 // Iterates the readable bytes of a buffer.
 ChannelBuffer buffer = ...;
 while (buffer.readable()) {
     System.out.println(buffer.readByte());
 }
 

Writable bytes

This segment is a undefined space which needs to be filled. Any operation whose name ends with  write   will write the data at the current  writerIndex   and increase it by the number of written bytes. If the argument of the write operation is also a  ChannelBuffer , and no source index is specified, the specified buffer's  readerIndex   is increased together.

If there's not enough writable bytes left,  IndexOutOfBoundsException   is raised. The default value of newly allocated buffer's  writerIndex   is  0 . The default value of wrapped or copied buffer's  writerIndex   is the  capacity   of the buffer.

 // Fills the writable bytes of a buffer with random integers.
 ChannelBuffer buffer = ...;
 while (buffer.writableBytes() >= 4) {
     buffer.writeInt(random.nextInt());
 }
 

Discardable bytes

This segment contains the bytes which were read already by a read operation. Initially, the size of this segment is  0 , but its size increases up to the  writerIndex   as read operations are executed. The read bytes can be discarded by callingdiscardReadBytes()   to reclaim unused area as depicted by the following diagram:

  BEFORE discardReadBytes()

      +-------------------+------------------+------------------+
      | discardable bytes |  readable bytes  |  writable bytes  |
      +-------------------+------------------+------------------+
      |                   |                  |                  |
      0      <=      readerIndex   <=   writerIndex    <=    capacity


  AFTER discardReadBytes()

      +------------------+--------------------------------------+
      |  readable bytes  |    writable bytes (got more space)   |
      +------------------+--------------------------------------+
      |                  |                                      |
 readerIndex (0) <= writerIndex (decreased)        <=        capacity
 

Please note that there is no guarantee about the content of writable bytes after calling  discardReadBytes() . The writable bytes will not be moved in most cases and could even be filled with completely different data depending on the underlying buffer implementation.

Clearing the buffer indexes

 You can set both  readerIndex   and  writerIndex   to  0   by calling  clear() . It does not clear the buffer content (e.g. filling with  0 ) but just clears the two pointers. Please also note that the semantic of this operation is different fromByteBuffer.clear() .

  BEFORE clear()

      +-------------------+------------------+------------------+
      | discardable bytes |  readable bytes  |  writable bytes  |
      +-------------------+------------------+------------------+
      |                   |                  |                  |
      0      <=      readerIndex   <=   writerIndex    <=    capacity


  AFTER clear()

      +---------------------------------------------------------+
      |             writable bytes (got more space)             |
      +---------------------------------------------------------+
      |                                                         |
      0 = readerIndex = writerIndex            <=            capacity
 

Search operations

Various  indexOf()   methods help you locate an index of a value which meets a certain criteria. Complicated dynamic sequential search can be done with  ChannelBufferIndexFinder   as well as simple static single byte search.

Mark and reset

There are two marker indexes in every buffer. One is for storing  readerIndex   and the other is for storing  writerIndex . You can always reposition one of the two indexes by calling a reset method. It works in a similar fashion to the mark and reset methods in  InputStream   except that there's no  readlimit .

Derived buffers

You can create a view of an existing buffer by calling either  duplicate() ,  slice()   or  slice(int, int) . A derived buffer will have an independent  readerIndex ,  writerIndex   and marker indexes, while it shares other internal data representation, just like a NIO buffer does.

In case a completely fresh copy of an existing buffer is required, please call  copy()   method instead.

Conversion to existing JDK types

NIO Buffers

Various  toByteBuffer()   and  toByteBuffers()   methods convert a  ChannelBuffer   into one or more NIO buffers. These methods avoid buffer allocation and memory copy whenever possible, but there's no guarantee that memory copy will not be involved or that an explicit memory copy will be involved.

Strings

Various  toString(String)   methods convert a  ChannelBuffer   into a  String . Please note that  toString()   is not a conversion method.

I/O Streams

Please refer to  ChannelBufferInputStream   and  ChannelBufferOutputStream .

 

分享到:
评论

相关推荐

    netty3.1中文用户手册.pdf

    - **ChannelBuffer替代**:探讨了如何使用POJO来替代传统的ChannelBuffer,以提高代码的可读性和可维护性。 #### 1.9. 关闭你的应用 - **资源释放**:讲解了在应用程序结束时如何正确释放资源,确保系统的稳定性和...

    Netty 3.1 中文用户手册

    - **使用 POJO 代替 ChannelBuffer**: 介绍了一种更加面向对象的方式处理网络数据。 - **关闭应用**: 介绍了如何优雅地关闭 Netty 应用,释放资源。 #### 第二章 架构总览 - **缓冲实现**: - 提供了多种缓冲实现...

    Netty 3.2 用户手册

    这个过程介绍了如何构建一个基础的Netty服务端和客户端,以及如何处理ChannelBuffer,即Netty中的数据容器。 手册接着提供了对ReceivedData的详解,通过编写Echo服务,即对收到的任何消息进行回显,来进一步解释...

    Netty+3.1中文用户手册.doc

    这一章通过一系列示例介绍了 Netty 的基本用法,展示了如何快速地构建网络服务和客户端。 2. 架构总览 Netty 的架构设计包含以下关键特性: 2.1. 丰富的缓冲实现 除了 ByteBuf,Netty 还提供了多种缓冲类型,如 ...

    Netty_3.2_中文用户手册

    此外,手册还指导开发者如何用 POJO 替换 ChannelBuffer,以提高代码的可读性和易用性,以及如何优雅地关闭应用程序。 第二章则深入介绍了 Netty 的架构概览,包括其丰富的缓存数据结构、统一的异步 I/O API、基于...

    Netty+3.1中文用户手册

    - **使用 POJO 代替 ChannelBuffer**:介绍如何使用普通的 Java 对象(POJOs)替代 ChannelBuffer 进行数据交换,提高代码的可读性和可维护性。 - **关闭应用**:正确的关闭顺序对于资源释放至关重要,Netty 提供...

    netty3.1中文手册

    此外,还讨论了流数据传输处理中的问题和解决方案,比如如何避免 Socket 缓冲区的缺陷,以及如何利用 POJO(Plain Old Java Object)替代 ChannelBuffer。最后,介绍了如何优雅地关闭应用,并对第一章的内容进行了...

    Netty user guid

    - **1.8 使用 POJO 而不是 ChannelBuffer**:这里介绍了如何使用普通的 Java 对象 (POJO) 来代替 ChannelBuffer 进行数据处理。 - **1.9 关闭你的应用程序**:讲解如何优雅地关闭 Netty 应用程序。 - **1.10 总结**...

    Netty 3.1中文用户手册

    - "响应协议服务":介绍了如何向客户端发送响应。 - "时间协议服务":创建一个定时发送消息的服务,展示了 Netty 处理定时任务的能力。 - "时间协议服务客户端":对应的客户端实现,展示如何接收和处理服务端发送...

    netty 官方文档

    - **使用 POJO 替代 ChannelBuffer:**Netty 允许开发者使用普通的 Java 对象 (POJO) 来替代 ChannelBuffer 进行数据处理。 - **应用程序关闭:**介绍了如何优雅地关闭 Netty 应用程序,确保所有资源被正确释放。 #...

    Netty实现原理浅析

    通过对Netty的总体结构、网络模型以及缓冲机制的介绍,我们可以看出Netty在设计上充分考虑了高性能和灵活性的需求。它不仅提供了简洁易用的API,还通过灵活的配置选项让开发者可以根据具体的业务场景进行定制化调整...

    Netty教程用户手册

    - **1.8 使用POJO代替`ChannelBuffer`**:学习如何使用普通的Java对象(POJOs)代替`ChannelBuffer`进行数据处理。 - **1.9 应用程序关闭**:了解如何优雅地关闭Netty应用程序。 - **1.10 总结**:回顾本章所学的...

    netty源码阅读笔记.pdf

    2. **ChannelBuffer**:Netty中的ChannelBuffer是用于存储和传输数据的基本单元,类似于Java NIO中的ByteBuffer,但提供了更高级别的操作。它支持零拷贝,高效地处理网络I/O,并提供了一种线程安全的方式来读写数据...

    netty-3.2.5终极手册

    《Netty-3.2.5终极手册》是一本全面介绍Netty 3.2.5版本的指南书籍,旨在为开发者提供快速开发网络应用的方法与技巧。本书不仅涵盖了Netty的基本概念和入门教程,还深入探讨了其架构设计原理及高级特性。 #### 二、...

Global site tag (gtag.js) - Google Analytics