java - 在处理程序中组装Netty消息

我正在为我的项目制作Netty原型(prototype)。我正在尝试在Netty之上实现一个简单的面向文本/字符串的协议(protocol)。在我的管道中，我正在使用以下内容:

public class TextProtocolPipelineFactory implements ChannelPipelineFactory
{
@Override
public ChannelPipeline getPipeline() throws Exception
{
    // Create a default pipeline implementation.
    ChannelPipeline pipeline = pipeline();

    // Add the text line codec combination first,
    pipeline.addLast("framer", new DelimiterBasedFrameDecoder(2000000, Delimiters.lineDelimiter()));
    pipeline.addLast("decoder", new StringDecoder());
    pipeline.addLast("encoder", new StringEncoder());

    // and then business logic.
    pipeline.addLast("handler", new TextProtocolHandler());

    return pipeline;
}
}

我在管道中有DelimiterBasedFrameDecoder，String Decoder和String Encoder。

作为此设置的结果，我的传入消息被拆分为多个字符串。这导致对我的处理程序的“messageReceived”方法的多次调用。这可以。但是，这要求我将这些消息累积在内存中，并在收到消息的最后一个字符串包时重新构造该消息。

我的问题是，“累积字符串”然后“将它们重新构造为最终消息”是最有效的内存存储方式。到目前为止，我有3个选择。他们是:

使用StringBuilder进行累加，并使用toString进行构造。 (这会带来最差的内存性能。实际上，对于具有大量并发用户的大型有效负载，这会带来 Not Acceptable 性能)

通过ByteArrayOutputStream累积到ByteArray中，然后使用字节数组进行构造(这比选项1的性能要好得多，但仍占用大量内存)

累积到动态 channel 缓冲区中，并使用toString(charset)进行构造。我尚未对此设置进行概要分析，但是我很好奇它与以上两个选项的比较。有人使用动态 channel 缓冲区解决了此问题吗？

我是Netty的新手，可能在结构上我可能做错了什么。您的输入将不胜感激。

提前致谢
索希尔

添加我的自定义FrameDecoder实现，以供Norman查看

public final class TextProtocolFrameDecoder extends FrameDecoder
{
public static ChannelBuffer messageDelimiter()
{
      return ChannelBuffers.wrappedBuffer(new byte[] {'E','O','F'});
    }

@Override
protected Object decode(ChannelHandlerContext ctx, Channel channel,ChannelBuffer buffer)
throws Exception
{
    int eofIndex = find(buffer, messageDelimiter());

    if(eofIndex != -1)
    {
        ChannelBuffer frame = buffer.readBytes(buffer.readableBytes());
        return frame;
    }

    return null;
}

private static int find(ChannelBuffer haystack, ChannelBuffer needle) {
    for (int i = haystack.readerIndex(); i < haystack.writerIndex(); i ++) {
        int haystackIndex = i;
        int needleIndex;
        for (needleIndex = 0; needleIndex < needle.capacity(); needleIndex ++) {
            if (haystack.getByte(haystackIndex) != needle.getByte(needleIndex)) {
                break;
            } else {
                haystackIndex ++;
                if (haystackIndex == haystack.writerIndex() &&
                    needleIndex != needle.capacity() - 1) {
                    return -1;
                }
            }
        }

        if (needleIndex == needle.capacity()) {
            // Found the needle from the haystack!
            return i - haystack.readerIndex();
        }
    }
    return -1;
   }
  }

最佳答案

我认为，如果您实现自己的FrameDecoder，您将获得最佳性能。这将允许您缓冲所有数据，直到您真正需要将其分派(dispatch)到链中的下一个Handler为止。请引用FrameDecoder apidocs。

如果您不想自己处理CRLF，也可以保留DelimiterBasedFrameDecoder并在其后添加一个自定义FrameDecoder来组装表示一行文本的ChannelBuffer。

在这两种情况下，FrameDecoder都会通过尝试仅“包装”缓冲区而不是每次都不复制来尽量减少内存副本。

就是说，如果您想获得最佳性能，则可以选择第一种方法；如果您想要轻松地使用第二种方法，则；)