我正在尝试使用一个简单的服务器-客户端应用程序(代码见下文)进入 Netty。

我正在努力解决两个问题:

1. ConfigServerHandler 响应。 ConfigClientHandler 被正确调用。但是 FeedbackServerHandler 响应。永远不会调用 FeedbackClientHandler。为什么？根据文档，处理程序应该一个接一个地调用。

2. 我想要多个处理程序。这些处理程序中的每一个只对另一方发送的某些消息感兴趣(例如，客户端发送，服务器接收)。

   • 我应该在处理程序(channelRead)接收到消息后对其进行过滤吗？如何区分不同的字符串？对于不同的对象，通过解析它们应该很容易。
   • 是否可以为 SocketChannel 定义不同的 ChannelPipelines？
   • 进一步的方法？

感谢您的帮助!

KJ<​​>

服务器是这样创建的:

public void run() throws Exception {

    EventLoopGroup bossGroup = new NioEventLoopGroup(1);
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    try {
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup)
         .channel(NioServerSocketChannel.class)
         .handler(new LoggingHandler(LogLevel.INFO))
         .childHandler(new ChannelInitializer<SocketChannel>() {
             @Override
             public void initChannel(SocketChannel ch) throws Exception {
                 ChannelPipeline p = ch.pipeline();
                 p.addLast(
                     new ObjectEncoder(),
                     new ObjectDecoder(ClassResolvers.cacheDisabled(null)),
                     new ConfigServerHandler(),
                     new FeedbackServerHandler());
             }
         });
      b.bind(mPort).sync().channel().closeFuture().sync();
    } finally {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

其中一个处理程序类(FeedbackServerHandler 的作用完全相同，但解析为 Integer):

public class ConfigServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        System.out.println("ConfigServerHandler::channelRead, " +(String)msg);
        ctx.write(msg);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        ctx.flush();
    }

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

客户端看起来非常相似:

public Client(String host, int port) throws InterruptedException {

    EventLoopGroup workerGroup = new NioEventLoopGroup();
    try {
        Bootstrap b = new Bootstrap();
        b.group(workerGroup)
         .channel(NioSocketChannel.class)
         .handler(new ChannelInitializer<SocketChannel>() {
             @Override
             public void initChannel(SocketChannel ch) throws Exception {
                 ChannelPipeline p = ch.pipeline();
                  p.addLast(
                      new ObjectEncoder(),
                      new ObjectDecoder(ClassResolvers.cacheDisabled(null)),
                      new ConfigClientHandler(),
                      new FeedbackClientHandler());
             }
         });
         b.connect(host, port).sync().channel().closeFuture().sync();
    } finally {
        workerGroup.shutdownGracefully();
    }
}

这是客户端处理程序之一(另一个发送 Integer 消息并在“channelRead”方法中解析为 Integer):

public class ConfigClientHandler extends ChannelInboundHandlerAdapter {

    private final String firstMessage = "blubber";

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        System.out.println("ConfigClientHandler::channelActive");
        ctx.writeAndFlush(firstMessage);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        System.out.println("ConfigClientHandler::channelRead, " +(String)msg);
        ctx.write(msg);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        ctx.flush();
    }

最佳答案

您正在使用 ChannelInboundHandlerAdapter ，这对你的“中间”处理程序来说很好 ConfigXxxxxHandler .

但是你用channelRead方法然后在内部使用 ctx.write(msg) . ctx.write(msg)将首先通过前一个处理程序( ObjectDecoder )将消息写回到另一个服务器，而不是下一个处理程序(在您的情况下为 FeedbackClientHandler)。

如果您想将消息发送给下一个处理程序，您应该使用以下内容:

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    System.out.println("ConfigClientHandler::channelRead, " +(String)msg);
    ctx.fireChannelRead(msg);
}

当然没有 ctx.flush()在 channelReadComplete (因为不再在那里写)。 但在你的最后 FeedbackClientHandler ，当然是用ctx.write(yourNewMessage)的flush方法或使用 ctx.writeAndFlush(yourNewMessage) .

所以继续:

• ctx.write将消息发送到线路，然后发送到之前的处理程序，然后发送到 channel ，然后发送到网络，所以Outbound方式
• ctx.fireChannelRead会将消息发送到下一个处理程序(相反的方式)，所以入站方式

参见 http://netty.io/wiki/new-and-noteworthy-in-4.0.html#wiki-h4-16了解详情。

您或许还应该反转编码器/解码器，因为一般来说，在管道中先有解码器，然后是编码器是个好主意。

            p.addLast(
                      new ObjectDecoder(ClassResolvers.cacheDisabled(null)),
                      new ObjectEncoder(),
                      new ConfigClientHandler(),
                      new FeedbackClientHandler());

关于java - 未调用 Netty 处理程序，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27056557/