只是针对MessageClient你说的问题，我觉得用不着跨过netty来实现啊。 其实连接一但建立，对客户端和服务器端得处理来说，没有什么区别啊。

“但是，我想要的是一个连接池，并且如何写数据也不应该在channelConnected中，这样对于动态的数据，只能在构造函数中传递需要写的数据了。”

你说的连接池是connection的连接池吧？这个你只需要将建立成功的channel放到一个池里即可啊。

写数据是不一定在channelConnected中啊，只不过对于客户端而言，一般都是协议请求的发起者，所以一旦建立好就发送数据，但是这个不是强制的，完全可以根据自己协议来处理的。

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

readableBytes

int readableBytes()
Returns the number of readable bytes which is equal to (this.writerIndex – this.readerIndex).
writableBytes

int writableBytes()
Returns the number of writable bytes which is equal to (this.capacity – this.writerIndex).

2.根据netty的上述图中api中所示
readableBytes= this.writerIndex – this.readerIndex
所以，我们必须知道，此时writerIndex和readerIndex的pointer位置啊
根据netty api的描述，每次读的时候指针readerIndex是会移动变化的啊

3.楼上上面提到了头4个字节表示“真正的内容长度”, buffer.getInt(buffer.readerIndex())表示”实际的内容长度”,这两个概念如何具体理解？有些迷惑！
int dataLength = buffer.getInt(buffer.readerIndex());
if (buffer.readableBytes() < dataLength + 4) {
return null;//(2)
}

@Override
protected Object decode(
ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) throws Exception {
if (buffer.readableBytes() < 4) {
return null;//(1)
}
int dataLength = buffer.getInt(buffer.readerIndex());
if (buffer.readableBytes() < dataLength + 4) {
return null;//(2)
}

buffer.skipBytes(4);//(3)
byte[] decoded = new byte[dataLength];
buffer.readBytes(decoded);
String msg = new String(decoded);//(4)
return msg;
}
}

这段代码的readerIndex ,writerIndex的指针如何变化，十分迷惑，不知道兄弟能否具体说明一下，谢了

经检测，MTU 在我的机器上最多是 1492 个字节，在 windows xp 中，cmd中运行：

> ping -l 1492 -f localhost

是可以正确ping成功的。

如果用：

> ping -l 1493 -f localhost

则会回应说：
Packet needs to be fragmented but DF set.

如果是这样，那么，根据您前面说的，只能在超时后要求重传吗？
如果不是，那么，应该采取什么样的策略来避免这样的情况发生呢？

启动时，我使用的是：ServerBootstrap，Netty 版本是：3.2.2

发送方：channel.write(message) , message 长度是4096，在这里，我想实现的是文件分块传输的功能，这里的message是指某个文件的一部份，其大小是4096字节。

然后在接收端，我要将这段文件重新组装成一个文件：

while (buf.readableBytes() < 4096) {
buf = (ChannelBuffer) e.getMessage();
// log.debug("buffer size:"+buf.capacity());
}

问题就在于，发送方已经成功地 write，但是接收方运行到这一段语句的时候，如果去掉注释，会发现一个情况，就是buf的大小有可能始终在1500个字节，然后就陷入死循环无法继续读取下去,不断地会打印：buffer size : 1500。
——–

如果发送端和接收端的都在同一台机器上，若message的比较小，比如128个字节的话，是不会出现死循环的情况的；然而，默认情况下，如果message到了1024个字节就已经会陷入死循环。

如果，单机测试时加一段这样的配置代码：

channelconfig.setOption("receiveBufferSizePredictorFactory", new FixedReceiveBufferSizePredictorFactory(8192));

那么单机上就可以实现4096个字节的传输，但注意，5000字节又可能会出现死循环。（所以我也不清楚这句话中的8192究竟起到什么作用）。

不过，最麻烦的地方是，如果发送端和接收端在不同的机器上，即使加了上面的配置代码，也仍然无效，无法传输4096个字节，经常在1500个字节左右就停止了，再也没能新的数据过来。

不知道描述得是否清楚，总之，就是发送方write成功，但接收方可能收不到对方write的所有字节（如果坚持读取，可能陷入死循环），似乎有时会出现数据缺失的现象。单机上配置一下参数，可以暂时地不会出现这个问题，但切换到多机情况下，又不行了。

在发送方 channel.write(message) 成功，不过这里message比较大，比如是4096个字节。

在接收方如果使用：

if (buffer.readableBytes() < 4096) {
return null;//(1)
}

有时会发生这样的情况，即 buffer.readableBytes 一直都无法读够4096，比如只能读到 1500 个字节，那么这样的话，本次接受到的消息将无法被解析，返回null。

而我的需求是每次必须读到4096字节才往下运行，有什么方法可以做到吗？

比如设置参数？或者什么其它的变通的方法？或者说这种情况是不可避免的，即 write 成功，接收端receive到的字节数总有可能小于 write 的字节数？

thanks!

ChannelFuture future = bootstrap.connect(new InetSocketAddress(host, port));
Channel channel = future.awaitUninterruptibly().getChannel();
if (future.isSuccess()) {
channel.write(“哈哈，发一次”)
}

下面就是失败的处理以及释放资源