netty 简介

原文链接：https://www.baeldung.com/netty#client-application

1.简介

在本文中，我们将研究Netty —一个异步事件驱动的网络应用程序框架。

Netty的主要目的是基于NIO（或可能是NIO.2）构建具有网络和业务逻辑组件分离和松耦合的高性能协议服务器。它可能实现了众所周知的协议，例如HTTP或自定义的特定协议。

2.核心概念

Netty是一个非阻塞框架。与阻塞IO相比，这导致高吞吐量。了解无阻塞IO对于了解Netty的核心组件及其关系至关重要。

2.1 Channel

Channel是Java NIO的基础。它表示一个开放的连接，能够执行IO操作，例如读取和写入。

2.2 ChannelFuture

Netty 通道中的每个IO操作都是非阻塞的。

这意味着调用后立即返回所有操作。标准Java库中有一个Future接口，但是对于Netty而言并不方便-我们只能向Future询问操作的完成情况，或在操作完成之前阻塞当前线程。

这就是Netty拥有自己的ChannelFuture接口的原因。我们可以将回调传递给ChannelFuture，该回调将在操作完成时被调用。

2.3 事件和处理器

Netty使用事件驱动的应用程序范例，因此数据处理的管道是经过处理程序的一系列事件。事件和处理程序可以与入站和出站数据流相关。入站事件可以是以下各项：

• 通道激活和停用
• 读取操作事件
• 异常事件
• 用户事件

出站事件更简单，通常与打开/关闭连接以及写入/刷新数据有关。

Netty应用程序由几个联网和应用程序逻辑事件及其处理程序组成。通道事件处理程序的基本接口是ChannelHandler及其祖先ChannelOutboundHandler和ChannelInboundHandler。

Netty提供了ChannelHandler实现的巨大层次结构。值得注意的是适配器只是空的实现，例如ChannelInboundHandlerAdapter和ChannelOutboundHandlerAdapter。当我们只需要处理所有事件的子集时，可以扩展这些适配器。

而且，有许多特定协议（例如HTTP）的实现，例如HttpRequestDecoder，HttpResponseEncoder，HttpObjectAggregator。

在Netty的Javadoc中熟悉它们会很好。

2.4 编码器和解码器

在使用网络协议时，我们需要执行数据序列化和反序列化。为此，Netty 为能够解码传入数据的解码器引入了ChannelInboundHandler的特殊扩展。大多数解码器的基类是ByteToMessageDecoder。

为了对传出的数据进行编码，Netty具有ChannelOutboundHandler的扩展，称为编码器。MessageToByteEncoder是大多数编码器实现的基础。我们可以使用编码器和解码器将消息从字节序列转换为Java对象，反之亦然。

3.示例服务器应用程序

让我们创建一个代表简单协议服务器的项目，该服务器接收请求，执行计算并发送响应。

3.1 依赖关系

首先，我们需要在pom.xml中提供Netty依赖项：

>
    >io.netty>
    >netty-all>
    >4.1.10.Final>
>

可以在Maven Central上找到最新版本。

3.2 Data Model

请求数据类将具有以下结构：

public class RequestData {
    private int intValue;
    private String stringValue;
     
    // standard getters and setters
}

假设服务器接收到请求并返回将intValue乘以2。响应将具有单个int值：

public class ResponseData {
    private int intValue;
 
    // standard getters and setters
}

3.3 请求(request)解码器

现在，我们需要为我们的协议消息创建编码器和解码器。

应当注意，Netty与套接字接收缓冲区一起使用，该缓冲区不是以队列的形式而是以一堆字节的形式表示。这意味着当服务器未收到完整消息时，可以调用我们的入站处理程序。

我们必须确保在处理之前已收到完整的消息，并且有很多方法可以做到这一点。

首先，我们可以创建一个临时的ByteBuf并将所有入站字节附加到该字节上，直到获得所需的字节数为止：

public class SimpleProcessingHandler 
  extends ChannelInboundHandlerAdapter {
    private ByteBuf tmp;
 
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) {
        System.out.println("Handler added");
        tmp = ctx.alloc().buffer(4);
    }
 
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) {
        System.out.println("Handler removed");
        tmp.release();
        tmp = null;
    }
 
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf m = (ByteBuf) msg;
        tmp.writeBytes(m);
        m.release();
        if (tmp.readableBytes() >= 4) {
            // request processing
            RequestData requestData = new RequestData();
            requestData.setIntValue(tmp.readInt());
            ResponseData responseData = new ResponseData();
            responseData.setIntValue(requestData.getIntValue() * 2);
            ChannelFuture future = ctx.writeAndFlush(responseData);
            future.addListener(ChannelFutureListener.CLOSE);
        }
    }
}

上面显示的示例看起来有些怪异，但可以帮助我们了解Netty的工作方式。处理程序的每个方法在发生相应事件时都会被调用。因此，我们在添加处理程序时初始化缓冲区，在接收到新字节时将其填充数据，并在获得足够数据时开始对其进行处理。

我们故意不使用stringValue，以这种方式进行解码会不必要地复杂。这就是Netty提供有用的解码器类的原因，这些类是ChannelInboundHandler的实现：ByteToMessageDecoder和ReplayingDecoder 。

如上所述，我们可以使用Netty创建通道处理管道。因此，我们可以将解码器作为第一个处理程序，而处理逻辑处理程序可以紧随其后。

接下来显示RequestData的解码器：

public class RequestDecoder extends ReplayingDecoder<RequestData> {
 
    private final Charset charset = Charset.forName("UTF-8");
 
    @Override
    protected void decode(ChannelHandlerContext ctx, 
      ByteBuf in, List<Object> out) throws Exception {
  
        RequestData data = new RequestData();
        data.setIntValue(in.readInt());
        int strLen = in.readInt();
        data.setStringValue(
          in.readCharSequence(strLen, charset).toString());
        out.add(data);
    }
}

这个解码器的想法很简单。它使用ByteBuf的实现，当缓冲区中的数据不足以进行读取操作时，该实现将引发异常。
当捕获到异常时，缓冲区将倒退到开头，并且解码器等待数据的新部分。解码停止时进行列表不是空后解码的执行。

3.4 响应(response)编码器

除了解码RequestData之外，我们还需要对消息进行编码。此操作更为简单，因为在发生写操作时，我们拥有完整的消息数据。

我们可以在主处理程序中将数据写入Channel，或者可以分离逻辑并创建扩展MessageToByteEncoder的处理程序，该处理程序将捕获write ResponseData操作：

public class ResponseDataEncoder 
  extends MessageToByteEncoder<ResponseData> {
 
    @Override
    protected void encode(ChannelHandlerContext ctx, 
      ResponseData msg, ByteBuf out) throws Exception {
        out.writeInt(msg.getIntValue());
    }
}

3.5 请求处理

由于我们在单独的处理程序中执行了解码和编码，因此我们需要更改ProcessingHandler：

public class ProcessingHandler extends ChannelInboundHandlerAdapter {
 
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) 
      throws Exception {
  
        RequestData requestData = (RequestData) msg;
        ResponseData responseData = new ResponseData();
        responseData.setIntValue(requestData.getIntValue() * 2);
        ChannelFuture future = ctx.writeAndFlush(responseData);
        future.addListener(ChannelFutureListener.CLOSE);
        System.out.println(requestData);
    }
}

3.6 服务器 Bootstrap

现在，将它们放在一起并运行我们的服务器：

public class NettyServer {
 
    private int port;
 
    // constructor
 
    public static void main(String[] args) throws Exception {
  
        int port = args.length > 0
          ? Integer.parseInt(args[0]);
          : 8080;
  
        new NettyServer(port).run();
    }
 
    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
              .channel(NioServerSocketChannel.class)
              .childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) 
                  throws Exception {
                    ch.pipeline().addLast(new RequestDecoder(), 
                      new ResponseDataEncoder(), 
                      new ProcessingHandler());
                }
            }).option(ChannelOption.SO_BACKLOG, 128)
              .childOption(ChannelOption.SO_KEEPALIVE, true);
 
            ChannelFuture f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

上面的服务器引导程序示例中使用的类的详细信息可以在其Javadoc中找到。最有趣的部分是这一行：

ch.pipeline().addLast(
  new RequestDecoder(), 
  new ResponseDataEncoder(), 
  new ProcessingHandler());

在这里，我们定义了入站和出站处理程序，它们将以正确的顺序处理请求和输出。

4.客户端应用

客户端应执行反向编码和解码，因此我们需要具有RequestDataEncoder和ResponseDataDecoder：

public class RequestDataEncoder 
  extends MessageToByteEncoder<RequestData> {
 
    private final Charset charset = Charset.forName("UTF-8");
 
    @Override
    protected void encode(ChannelHandlerContext ctx, 
      RequestData msg, ByteBuf out) throws Exception {
  
        out.writeInt(msg.getIntValue());
        out.writeInt(msg.getStringValue().length());
        out.writeCharSequence(msg.getStringValue(), charset);
    }
}

public class ResponseDataDecoder 
  extends ReplayingDecoder<ResponseData> {
 
    @Override
    protected void decode(ChannelHandlerContext ctx, 
      ByteBuf in, List<Object> out) throws Exception {
  
        ResponseData data = new ResponseData();
        data.setIntValue(in.readInt());
        out.add(data);
    }
}

另外，我们需要定义一个ClientHandler，它将发送请求并从服务器接收响应：

public class ClientHandler extends ChannelInboundHandlerAdapter {
  
    @Override
    public void channelActive(ChannelHandlerContext ctx) 
      throws Exception {
  
        RequestData msg = new RequestData();
        msg.setIntValue(123);
        msg.setStringValue(
          "all work and no play makes jack a dull boy");
        ChannelFuture future = ctx.writeAndFlush(msg);
    }
 
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) 
      throws Exception {
        System.out.println((ResponseData)msg);
        ctx.close();
    }
}

现在编写客户端：

public class NettyClient {
    public static void main(String[] args) throws Exception {
  
        String host = "localhost";
        int port = 8080;
        EventLoopGroup workerGroup = new NioEventLoopGroup();
 
        try {
            Bootstrap b = new Bootstrap();
            b.group(workerGroup);
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.SO_KEEPALIVE, true);
            b.handler(new ChannelInitializer<SocketChannel>() {
  
                @Override
                public void initChannel(SocketChannel ch) 
                  throws Exception {
                    ch.pipeline().addLast(new RequestDataEncoder(), 
                      new ResponseDataDecoder(), new ClientHandler());
                }
            });
 
            ChannelFuture f = b.connect(host, port).sync();
 
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}

现在，我们可以运行客户端的main方法，并查看控制台输出。如预期的那样，我们获得了具有intValue等于246的ResponseData。

5.结论

在本文中，我们对Netty进行了快速介绍。我们展示了其核心组件，例如Channel和ChannelHandler。另外，我们已经制作了一个简单的非阻塞协议服务器和一个客户端。

与往常一样，所有代码示例都可以在GitHub上获得。