Netty 需知需会

已于 2024-11-20 17:22:33 修改
阅读量675 收藏 10
点赞数 19
文章标签： 后端 java 分布式
于 2024-11-20 09:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/CJ_L1995/article/details/143899735
版权

        Netty 是一个功能强大的异步事件驱动的网络通信框架，广泛应用于高性能和分布式系统中。以下是学习和使用 Netty 时的核心概念和知识点，掌握这些内容能够帮助你高效使用 Netty。

1. Netty 核心概念

  • Channel：Channel 是 Netty 中的核心抽象，它代表了网络连接。所有的网络 I/O 操作（如读写数据、连接、断开）都通过 Channel 进行。

    • NioServerSocketChannel：服务端用于监听连接。
    • NioSocketChannel：客户端和服务端用于通信。

  • ChannelPipeline 和 ChannelHandler

    ChannelPipeline 是由一系列 ChannelHandler 组成的链式结构，它负责处理所有的数据读取和写入操作。每个 ChannelHandler 都负责不同的任务，如处理入站数据、出站数据、异常处理等。

    • Inbound Handler：处理从网络读取的数据（如解码、处理请求）。
    • Outbound Handler：处理要写入网络的数据（如编码、发送响应）。

  • EventLoop：EventLoop 是线程的抽象，负责监听 I/O 事件并处理任务。它实现了 Reactor 模式，将 I/O 事件和任务调度分配到特定的线程。

  • ChannelFuture：ChannelFuture 是表示异步操作结果的对象，它提供了事件的回调机制，用于等待和获取 I/O 操作的结果。

2. Netty I/O 模型与设计
  • 异步非阻塞：Netty 使用异步和非阻塞的 I/O 操作，允许单线程同时处理多个连接的事件，提高系统的吞吐量和性能。
  • Reactor 模式：Netty 实现了 Reactor 模式，它通过一个或多个 EventLoop 处理所有的 I/O 事件（如连接、数据读取等）。每个连接都对应一个 Channel，而多个 Channel 共享同一个 EventLoop 线程池。
  • NIO（Non-blocking I/O）：底层采用 Java NIO（非阻塞 I/O）来实现高效的数据读写，使用 Selector 来监控多个 Channel 的状态（例如，是否可以读写）。
3. Netty 组件

  • EventLoopGroup：EventLoopGroup 是 Netty 中用来管理和调度线程的组件。NioEventLoopGroup 用于 NIO 操作。

    • bossGroup：负责接收客户端连接。
    • workerGroup：负责处理已连接的客户端的 I/O 操作。

  • ServerBootstrap 和 Bootstrap：ServerBootstrap 用于设置服务器端，Bootstrap 用于设置客户端。它们提供了配置 Channel、EventLoopGroup 等必要参数的方法。

  • ChannelInitializer：ChannelInitializer 是一个特殊的 ChannelHandler，用来在 Channel 创建时初始化 ChannelPipeline。在这里可以添加各种处理器（ChannelHandler）来处理网络事件。

4. Netty 编程流程

  • 服务器端编程（Server）

    1. 创建 EventLoopGroup，通常包括 bossGroup 和 workerGroup。
    2. 配置 ServerBootstrap，设置 channel 类型、handler 等。
    3. 使用 bind() 启动服务并等待连接。

    示例：

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        // 创建两个 EventLoopGroup
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);  // 1个线程用于接收连接
        EventLoopGroup workerGroup = new NioEventLoopGroup();  // 默认线程池大小

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)  // 使用 NIO 通道
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new MyServerHandler());  // 添加自定义处理器
                        }
                    });

            // 绑定端口，启动服务器
            ChannelFuture future = serverBootstrap.bind(8080).sync();  // 绑定端口
            future.channel().closeFuture().sync();  // 等待服务关闭
        } finally {
            bossGroup.shutdownGracefully();  // 关闭 EventLoopGroup
            workerGroup.shutdownGracefully();  // 关闭 EventLoopGroup
        }
    }
}

  • 客户端编程（Client）

    1. 创建 EventLoopGroup。
    2. 配置 Bootstrap，设置 channel 类型、handler 等。
    3. 使用 connect() 连接服务器。

    示例：

public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();  // 创建 EventLoopGroup

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)  // 使用 NIO 通道
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new MyClientHandler());  // 添加自定义处理器
                        }
                    });

            // 连接到服务器
            ChannelFuture future = bootstrap.connect("localhost", 8080).sync();
            future.channel().closeFuture().sync();  // 等待连接关闭
        } finally {
            group.shutdownGracefully();  // 关闭 EventLoopGroup
        }
    }
}
5. Netty 消息编解码

  • ByteBuf：Netty 使用 ByteBuf 代替传统的 ByteBuffer 来处理数据，是 Netty 的基础数据结构。它提供了高效的内存管理，支持自动扩展、动态的内存分配等，能有效避免内存泄漏和频繁的 GC。

  • 编解码器：Netty 提供了内建的编解码器（如 StringDecoder, StringEncoder, ByteToMessageDecoder, MessageToByteEncoder），也支持自定义编解码器来处理复杂的协议（如 JSON、Protobuf）。

    示例：自定义编解码器

public class MyDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        if (in.readableBytes() >= 4) {  // 读取至少 4 字节
            out.add(in.readInt());  // 解码数据
        }
    }
}

public class MyEncoder extends MessageToByteEncoder<Integer> {
    @Override
    protected void encode(ChannelHandlerContext ctx, Integer msg, ByteBuf out) throws Exception {
        out.writeInt(msg);  // 编码数据
    }
}
6. Netty 异常处理

  • 异常捕获：使用 ChannelInboundHandlerAdapter 来捕获和处理异常。一般会覆盖 exceptionCaught() 方法来进行异常处理。

    示例：

public class MyHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();  // 关闭连接
    }
}

7. Netty 性能调优

内存管理

Netty 使用 PooledByteBufAllocator 进行内存池管理，避免了频繁的内存分配和回收，从而提高了性能。

1. 内存池的工作原理

        内存池的核心思想是分配一定大小的内存块，并将这些内存块存储在池中供以后重用。这样，Netty 不需要每次分配新内存，而是复用已分配的内存块，减少了内存分配和回收的开销。

        具体来说，Netty 的 PooledByteBufAllocator 通过以下机制来实现高效的内存管理：

  • 内存池化：通过分配一大块内存，然后将其划分为多个较小的块进行管理，避免了每次操作时都进行系统调用来申请内存。

  • 分配策略：PooledByteBufAllocator 根据缓冲区的大小来选择合适的内存池块。

    • 小块内存通过“块池”分配（例如 512 字节、1024 字节等）。
    • 大块内存则通过“页池”分配。（页池的核心概念是 内存页，通常内存管理系统会按页（Page）来划分内存块，一页通常为 4KB，或者根据系统架构不同可能会有所不同。）

  • 重用已分配的内存：当缓冲区使用完毕后，它不会被立即释放，而是被放回内存池中，等待下一次使用。

  • 减少 GC 压力：通过内存池重用，减少了 JVM 堆内存的分配和垃圾回收的负担，避免了频繁的小对象创建。

2. PooledByteBufAllocator 的使用

        在 Netty 中，默认使用的是 PooledByteBufAllocator，但你也可以手动指定使用它。下面是一个简单的示例，展示如何通过 PooledByteBufAllocator 来管理内存。

        示例：

import io.netty.buffer.ByteBuf;
import io.netty.buffer.PooledByteBufAllocator;

public class NettyMemoryPoolExample {
    public static void main(String[] args) {
        // 通过 PooledByteBufAllocator.DEFAULT 获取默认的内存池实例。你也可以使用 new PooledByteBufAllocator(true) 来启用缓存回收的功能。
        PooledByteBufAllocator allocator = PooledByteBufAllocator.DEFAULT;

        // 分配一个指定大小的 ByteBuf (例如 256 字节)
        ByteBuf buffer = allocator.directBuffer(256);  // 使用 directBuffer 分配直接内存
        try {
            // 使用分配的缓冲区
            buffer.writeBytes("Hello, Netty!".getBytes());
            System.out.println("Buffer content: " + buffer.toString(io.netty.util.CharsetUtil.UTF_8));

        } finally {
            // 释放缓冲区
            buffer.release();
        }
    }
}
TCP 参数调优

        例如，可以通过设置 SO_RCVBUF 和 SO_SNDBUF 来调整 socket 的接收和发送缓冲区大小。

// 创建 Bootstrap
Bootstrap bootstrap = new Bootstrap();

// 设置 TCP 参数
bootstrap.option(ChannelOption.SO_RCVBUF, 1024 * 1024)  // 设置接收缓冲区为 1MB
         .option(ChannelOption.SO_SNDBUF, 1024 * 1024)  // 设置发送缓冲区为 1MB
         .option(ChannelOption.SO_KEEPALIVE, true)  // 需要确保长时间空闲的连接不会被中断时开启
         .group(group)  // 设置 EventLoopGroup
         .channel(NioSocketChannel.class)  // 设置通道类型
         .handler(new MyChannelInitializer());  // 设置处理器
  •  调优建议：
    • 接收和发送缓冲区大小：缓冲区的大小应该根据网络带宽和延迟进行调整。对于高带宽和高延迟的网络，通常需要较大的缓冲区以避免数据丢失和减少阻塞。
    • 内存使用情况：虽然较大的缓冲区可以提高吞吐量，但同时也会占用更多的内存资源。因此，必须平衡缓冲区大小和系统资源。
线程模型

        合理配置 EventLoopGroup 的线程数。一般来说，workerGroup 的线程数应当与 CPU 核数成比例，bossGroup 的线程数通常为 1。

零拷贝

        Netty 支持零拷贝技术，可以通过 FileRegion 直接在底层文件和网络之间传输数据，不需要经过用户空间的缓冲区，从而减少 CPU 开销。

示例：使用 FileRegion 进行零拷贝传输

import io.netty.channel.*;
import io.netty.handler.stream.FileRegion;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.bootstrap.Bootstrap;
import java.io.RandomAccessFile;

public class ZeroCopyFileClient {
    public static void main(String[] args) throws Exception {
        String filePath = "path/to/your/file";  // 要上传的文件路径
        String host = "localhost";  // 服务器地址
        int port = 8080;  // 服务器端口

        // 创建 Netty 客户端引导
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                     .channel(NioSocketChannel.class)
                     .handler(new ChannelInitializer<Channel>() {
                         @Override
                         protected void initChannel(Channel ch) throws Exception {
                             // 可以添加自定义的处理器，这里没有添加其他处理器
                         }
                     });

            // 连接到服务器
            Channel channel = bootstrap.connect(host, port).sync().channel();

            // 准备文件
            RandomAccessFile file = new RandomAccessFile(filePath, "r");
            FileRegion fileRegion = new DefaultFileRegion(file.getChannel(), 0, file.length());

            // 通过 Channel 进行零拷贝传输文件
            channel.writeAndFlush(fileRegion).sync();

            System.out.println("文件传输完成");

            // 记得关闭文件和连接
            file.close();
        } finally {
            group.shutdownGracefully();
        }
    }
}

详细解释：

1.创建文件区域：

RandomAccessFile file = new RandomAccessFile(filePath, "r");
FileRegion fileRegion = new DefaultFileRegion(file.getChannel(), 0, file.length());
  • RandomAccessFile 用于读取文件，并提供文件的 Channel，DefaultFileRegion 通过 Channel 直接指定要传输的文件区域。
  • DefaultFileRegion 需要指定文件 Channel，起始位置（通常是 0），以及文件的长度。

2.通过 writeAndFlush 发送 FileRegion：

channel.writeAndFlush(fileRegion).sync();

服务器端接收文件

        在服务器端，你可以通过类似的方式接收文件。以下是一个简单的服务器端处理逻辑：

import io.netty.channel.*;
import io.netty.handler.stream.FileRegion;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.bootstrap.ServerBootstrap;
import java.io.RandomAccessFile;

public class ZeroCopyFileServer {
    public static void main(String[] args) throws Exception {
        int port = 8080;  // 监听端口

        // 创建 Netty 服务器引导
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                     .channel(NioServerSocketChannel.class)
                     .childHandler(new ChannelInitializer<Channel>() {
                         @Override
                         protected void initChannel(Channel ch) throws Exception {
                             ch.pipeline().addLast(new FileUploadHandler());  // 添加自定义处理器
                         }
                     });

            // 绑定端口并启动服务
            ChannelFuture future = bootstrap.bind(port).sync();
            System.out.println("服务器启动，监听端口：" + port);

            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    // 处理文件上传的 ChannelHandler
    private static class FileUploadHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            if (msg instanceof FileRegion) {
                FileRegion fileRegion = (FileRegion) msg;
                // 这里可以处理接收到的文件内容，例如保存到磁盘
                RandomAccessFile destFile = new RandomAccessFile("received_file", "rw");
                destFile.setLength(fileRegion.getTransferred());
                fileRegion.transferTo(destFile.getChannel(), 0);
                destFile.close();
                System.out.println("文件上传完成");
            }
        }
    }
}

8. Netty 常见问题

  • 内存泄漏：Netty 使用引用计数机制（ReferenceCounting），在处理 ByteBuf 时要确保释放资源。使用 ByteBuf.release() 来显式释放内存。

  • 连接不关闭：由于 Netty 是异步处理的，要确保在连接不再需要时正确关闭 Channel 和 EventLoopGroup。

熬夜的猪
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值