Netty入门

最新推荐文章于 2022-12-02 13:05:33 发布

原创最新推荐文章于 2022-12-02 13:05:33 发布 · 343 阅读

0 ·

CC 4.0 BY-SA版权

Netty 专栏收录该内容

2 篇文章

订阅专栏

1.1 Channel
Netty 网络通信的组件，能够用于执行网络 I/O 操作。Channel 为用户提供：

当前网络连接的通道的状态（例如是否打开？是否已连接？）
网络连接的配置参数（例如接收缓冲区大小）
提供异步的网络 I/O 操作(如建立连接，读写，绑定端口)，异步调用意味着任何 I/O 调用都将立即返回，并且不保证在调用结束时所请求的 I/O 操作已完成。调用立即返回一个 ChannelFuture 实例，通过注册监听器到 ChannelFuture 上，在 I/O 操作成功、失败或取消时回调通知调用方。
支持关联 I/O 操作与对应的处理程序。
不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应。下面是一些常用的 Channel 类型：

NioSocketChannel，异步的客户端 TCP Socket 连接。
NioServerSocketChannel，异步的服务器端 TCP Socket 连接。
NioDatagramChannel，异步的 UDP 连接。
NioSctpChannel，异步的客户端 Sctp 连接。
NioSctpServerChannel，异步的 Sctp 服务器端连接，这些通道涵盖了 UDP 和 TCP 网络 IO 以及文件 IO。

1.2 回调
Netty 在内部使用了回调来处理事件；当一个回调被触发时，相关的事件可以被一个 interfaceChannelHandler 的实现处理。代码清单 1-2 ：当一个新的连接已经被建立时，ChannelHandler 的 channelActive()回调方法将会被调用。

public class ServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    //当一个新的连接被建立时，会调用此函数
    public void channelActive(ChannelHandlerContext ctx) throws Exception{
        System.out.println("Client " + ctx.channel().remoteAddress() + "connected");
    }
}

1.3 Future(实现异步)

Future 提供了另一种在操作完成时通知应用程序的方式。这个对象可以看作是一个异步操作的结果的占位符；在完成时提供对其结果的访问接口;
JDK 预置了 interface java.util.concurrent.Future，但是其所提供的实现，只允许手动检查对应的操作是否已经完成，或者一直阻塞直到它完成。这是非常繁琐的，所以 Netty提供了它自己的实现——ChannelFuture，用于在执行异步操作的时候使用;
ChannelFuture提供了几种额外的方法，这些方法使得我们能够注册一个或者多个ChannelFutureListener实例。监听器的回调方法operationComplete()，将会在对应的操作完成时被调用;由ChannelFutureListener提供的通知机制消除了手动检查对应的操作是否完成的必要;

每个 Netty 的出站 I/O 操作都将返回一个 ChannelFuture；也就是说，它们都不会阻塞。正如我们前面所提到过的一样，Netty 完全是异步和事件驱动的。

  //异步绑定接口
  ChannelFuture connect = channel.connect(new InetSocketAddress("127.0.0.1", 8080));
  //注册到ChannelFutureListener，以便在操作完成时获取通知
  connect.addListener(new ChannelFutureListener()
  {
      @Override
      public void operationComplete(ChannelFuture future) throws Exception
      {
          //检查操作状态
          if(future.isSuccess()){
              //如果操作成功则创建一个ByteBuf以持有数据
              ByteBuf buffer = Unpooled.copiedBuffer("Hello", Charset.defaultCharset());
              //将数据异步的发送给客户端节点
              future.channel().writeAndFlush(buffer);
          }else{
              System.out.println("connect failed.");
          }
      }
  });

1.4 事件和 ChannelHandler

Netty 使用不同的事件来通知我们状态的改变或者是操作的状态。这使得我们能够基于已经发生的事件来触发适当的动作。这些动作可能是：记录日志、数据转换、流控制、应用程序逻辑
每个事件都可以被发给ChannelHandler类中的某个方法处理，这是一个很好的将事件驱动范式直接转换为应用程序构件块的例子，Netty 的 ChannelHandler 为处理器提供了基本的抽象;

2 服务端核心流程:

public class ServerHandler extends ChannelInboundHandlerAdapter {
    
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf)msg;
        //将接受到的消息写给发送者，而不刷新出栈消息
        ctx.write(in);
    }
    
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
    }
    
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

public class Server{
    public void start() throws Exception {
        final ServerHandler sh = new ServerHandler();
        //1、创建EventLoopGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            //2、创建ServerBootstrap
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
            //3、指定所使用的NIO传输Channel
            .channel(NioServerSocketChannel.class)
            //4、使用指定的端口套接字地址
            .localAddress(new InetSocketAddress(8080))
            //添加handler到Channel的ChannelPipeline
            .childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(sh);
                }
            });
        }catch(Exception e){
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

服务端核心流程:
ServerHandler 实现了业务逻辑；
start()方法引导了服务器；

引导过程中所需要的步骤如下：

创建一个 ServerBootstrap 的实例以引导和绑定服务器；
创建并分配一个 NioEventLoopGroup 实例以进行事件的处理，如接受新连接以及读/写数据；
指定服务器绑定的本地的 InetSocketAddress；
使用一个 ServerHandler 的实例初始化每一个新的 Channel；
调用 ServerBootstrap.bind()方法以绑定服务器

3 客户端核心流程
客户端将会：
连接到服务器；
发送一个或者多个消息；
对于每个消息，等待并接收从服务器发回的相同的消息；
关闭连接。

public class ClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg)
        throws Exception {
        System.out.println("server: " + msg.toString(CharsetUtil.UTF_8));
    }
    
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.channel().writeAndFlush(Unpooled.copiedBuffer("Netty rocks", CharsetUtil.UTF_8));
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

public class Client {
    public void start() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            //创建Bootstrap
            Bootstrap bs = new Bootstrap();
            //指定EventLoopGroup以处理客户端事件
            bs.group(group)
            //需要适用于NIO传输的Channel类型
            .channel(NioSocketChannel.class)
            .remoteAddress(new InetSocketAddress("127.0.0.1", 8080))
            //创建Channel时向ChannelPipeline中添加一个ClientHandler实例
            .handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ClientHandler());
                }
            });
            //连接到远程节点，阻塞等待直到节点完成
            ChannelFuture f = bs.connect().sync();
            //阻塞直到channel关闭
            f.channel().closeFuture().sync();
        }finally {
            //关闭线程池并且释放所有的资源
            group.shutdownGracefully();
        }
    }
}

流程
为初始化客户端，创建了一个 Bootstrap 实例；
为进行事件处理分配了一个 NioEventLoopGroup 实例，其中事件处理包括创建新的连接以及处理入站和出站数据；
为服务器连接创建了一个 InetSocketAddress 实例；
当连接被建立时，一个ClientHandler 实例会被安装到（该 Channel 的）ChannelPipeline 中；
在一切都设置完成后，调用 Bootstrap.connect()方法连接到远程节点；

4 Netty的组件和设计

Channel – Socket
EventLoop – 控制流、多线程处理、并发
ChannelFuture – 异步通知
4.1 Channel接口

基本的I/O操作（bin() ，connect()，read()，write()）依赖于底层网络传输提供的原语；
Netty的Channel接口所提供的API，大大地降低了直接使用socket类的复杂性；
ChannelUnregistered Channel 已经被创建，但还未注册到 EventLoop
ChannelRegistered Channel 已经被注册到了 EventLoop
ChannelActive Channel 处于活动状态（已经连接到它的远程节点）。它现在可以接收和发送数据了
ChannelInactive Channel 没有连接到远程节点

Channel的生命周期：当这些状态发生改变时，将会生成对应的事件。这些事件将会被转发给 ChannelPipeline 中的 ChannelHandler，其可以随后对它们做出响应；
在这里插入图片描述

4.2 EventLoop接口

EventLoop定义了Netty的核心抽象，用于处理连接的生命周期中所发生的事件；
下图详细描述了Channel 、EventLoop、EventLoopGroup之间的具体关系；

关系：
一个EventLoopGroup为线程池，包含了一个或多个EventLoop；
一个EventLoop在生命周期内只与一个Thread绑定；
所有的EventLoop处理的I/O事件都将在它专有的Thread上被处理；
一个Channel在它的生命周期内只能注册在一个EventLoop上
一个EventLoop可能会被分配给一个或多个Channel

4.3 ChannelFuture接口
Netty中所有的I/O操作都是异步的，为此Netty提供了ChannelFuture接口，其addListener()方法注册了一个ChannelFutureListener，以便在事件完成时通过回调调到通知。

4.4 ChannelHandler
Netty的主要组件是ChannelHandler，它充当了所有处理入站和出站数据的应用程序的逻辑的处理。

4.5 ChannelPipeline

ChannelPipeline提供了ChannelHandler链的容器，并定义了用于在该链上传播入站和出站事件流的API。当Channel被创建时，会被自动的分配到专属的ChannelPipeline。
ChannelHnadler安装到ChannelPipeline中的过程：
- 一个ChannelInitializer的实现被注册到ServerBootstrap
- 当ChannelInitializer.initChannel()方法被调用时，ChannelInitializer将在ChannelPipeline中安装一组自定义的ChannelHandler
- ChannelInitializer将自己从ChannelPipeline中移除;

下图从客户端的角度来看，如果事件的运动方向是从客户端到服务端，那么这些事件为出站，反之则为入站：
在这里插入图片描述
4.6 编码器和解码器

当通过Netty发送或接收数据时会发生一次数据转换。入站消息会被解码，即从字节转换为Java对象；
出站消息会将数据从当前格式(Java对象)转换为字节；这两种方向转换的原因为：网络数据总是一系列的字节。

4.7 自定义ChannelHandler

自定义ChannelHander，在里面实现数据的接收并完成对应的业务逻辑，需要实现SimpleChannelInboundHandler或者ChannelInboundHandlerAdapter，并重写相应的方法，其中 T 是你要处理的消息的 Java 类型。
ChannelHandler 的典型用途包括：
- 将数据从一种格式转换为另一种格式；
- 提供异常的通知；
- 提供 Channel 变为活动的或者非活动的通知；
- 提供当 Channel 注册到 EventLoop 或者从 EventLoop 注销时的通知；
- 提供有关用户自定义事件的通知

4.8 ChannelHandler 适配器

可以使用 ChannelInboundHandlerAdapter 和 ChannelOutboundHandlerAdapter类作为自己的 ChannelHandler 的起始点，这两个适配器分别提供了 ChannelInboundHandler和ChannelOutboundHandler 的基本实现。
ChannelHandlerAdapter 还提供了实用方法 isSharable()。如果其对应的实现被标注为 Sharable，那么这个方法将返回 true，表示它可以被添加到多个 ChannelPipeline中

参考：
Netty入门