面试 - Java IO和Netty_java 简历中 nio和netty怎么写-优快云博客

面试 - Java IO和Netty

对应的知识点内容，可以看我的这个专栏中的介绍：

IO部分

Netty部分

一：BIO和NIO的区别

在这里插入图片描述

面向流和面向缓冲区

Java IO面向流意味着每一次从流中读取一个或者多个字节，直到读取所有的字节，没有被缓存在任何的地方，此外，不能前后移动流中的数据，如果要前后移动流中的数据，需要先将他缓存到一个缓冲区

在这里插入图片描述

JavaNIO的缓冲导向方法略有不同，数据读取到一个它稍后处理的缓冲区，需要时可以在缓冲区中的前后移动，这就增加了处理过程的灵活性，但是还是要检查缓冲区中是否有需要处理的数据，而且，需要确保当更多的数据到缓冲区的时候，不要覆盖缓冲区中还没有处理的数据

在这里插入图片描述

二：NIO三大核心组成部分

Buffer负责存取数据，Channel负责传输数据，而Selector则会决定操作那个通道中的数据

1：Buffer缓冲区

缓冲区其实本质上就是一块支持读/写操作的内存，底层是由多个内存页组成的数组，我们可以将其称之为内存块

在Java中这块内存则被封装成了Buffer对象，需要使用可直接通过已提供的API对这块内存进行操作和管理

当缓冲区被创建出来后，同一时刻只能处于读/写中的一个状态，同一时间内不存在即可读也可写的情况。

所以需要一个filp()方法进行来回切换

在这里插入图片描述

buffer的三个指针 - position, capacity, limit

position：表示当前操作的索引位置（下一个要读/写数据的下标）。
capacity：表示当前缓冲区的容量大小。
limit：表示当前可允许操作的最大元素位置（不是下标，是正常数字）。

操作数据的时候，这三个指针会反复来回移动

但它的子类有几十之多，但一般较为常用的子类就只有八大基本数据类型的缓冲区

🎉 在Netty中对这块进行了优化 - ByteBuf

2：Channel通道

NIO中的通道与BIO中的流对象类似，但BIO中要么是输入流，要么是输出流，通常流操作都是单向传输的。

而通道的功能也是用于传输数据，但它却是一个双向通道，代表着我们即可以从通道中读取对端数据，也可以使用通道向对端发送数据

这个通道可以是一个本地文件的IO连接，也可以是一个网络Socket套接字连接：

Channel通道仅被定义成了一个接口，具体的实现都在其子类下

3：Selector选择器

Selector是NIO的核心组件，它可以负责监控一个或多个Channel通道

选择器能够检测出那些通道中的数据已经准备就绪，可以支持读取/写入了，因此一条线程通过绑定一个选择器，就可以实现对多个通道进行管理，最终达到一条线程处理多个连接的效果，能够在很大程度上提升网络连接的效率

选择器一共支持4种事件：

SelectionKey.OP_READ/1：读取就绪事件，通道内的数据已就绪可被读取。
SelectionKey.OP_WRITE/4：写入就绪事件，一个通道正在等待数据写入。
SelectionKey.OP_CONNECT/8：连接就绪事件，通道已成功连接到服务端。
SelectionKey.OP_ACCEPT/16：接收就绪事件，服务端通道已准备好接收新的连接。

// 开启selector选择器
Selector selector = Selector.open();
// 把当前通道注册到Selector选择器上：
// sel：要注册的选择器、ops：事件类型 <- 这里是accept类型
server.register(selector, SelectionKey.OP_ACCEPT);

当一个通道注册时，会为其绑定对应的事件，当该通道触发了一个事件，就代表着该事件已经准备就绪，可以被线程操作了

// 可用异或的方式绑定好几个事件
int event = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

一条通道除开可以绑定多个事件外，还能注册多个选择器，但同一选择器只能注册一次，如多次注册相同选择器就会报错。

并非所有的通道都可使用选择器，比如FileChannel无法支持非阻塞特性，因此不能与Selector一起使用

并非所有的事件都支持任意通道，比如OP_ACCEPT事件则仅能提供给ServerSocketChannel使用。

package io_study.base;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

/**
 * <p>
 * 功能描述：nio 多路复用器模型
 * </p>
 *
 * @author cui haida
 * @date 2024/02/29/13:07
 */
public class NioSelectorTest {
    public static void main(String[] args) throws IOException, InterruptedException {
        // 创建NioServerSocket
        ServerSocketChannel channel = ServerSocketChannel.open();
        // 绑定监听的端口为9000
        channel.socket().bind(new InetSocketAddress(9000));
        // 设置为非阻塞
        channel.configureBlocking(false);
        // 打开多路复用器Selector处理channel，创建epoll
        // epoll_create <---- 声明一个epoll实例
        // 底层就是创建了一个linux epoll 实例，底层通过c语言调用epoll_create方法，返回一个非负作为文件描述符
        // 这里面有一个事件集合，epollArray
        Selector selector = Selector.open();
        // selector中有一个channels，用于存储注册到这里的channel
        // 将channel注册到selector上，并指定对连接事件感兴趣
        // 底层是调用pollWrapper.add(fd), fd -> socketChannel添加到内部的集合中[所有的channel]
        // fd => 文件描述符，Linux的内核为高效管理已被打开的文件所创建的索引，用这个索引可以找到文件
        channel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务器启动成功");

        while (true) {
            // 阻塞等待需要处理的事件的发生
            // 如果注册的所有的channel的所有事件都没有发生，将会阻塞

            // 底层一路调用，调用的是Linux内核的两个方法：epoll_wait() & epoll_ctl

            // epoll_ctl <-- 监听转移到就绪数组【channels -> rdList <--- 通过os的中断程序实现】
            // 到真正的注册绑定updateRegistrations()，先回调用epollCtl方法进行事件的绑定
            // epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) fd[channel]

            // epoll_wait <-- 监听就绪队列，就绪队列中有的就处理，没有就绪的channel将会阻塞
            // epoll中海还有一个队列就是就绪阻塞队列rdList, 如果有channel的事件就绪，会循环处理
            // 如果没有事件就绪，就会调用epoll_wait方法进行阻塞
            selector.select();

            // 获取selector中注册的全部事件的SelectionKey的实例
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();

            // 遍历迭代器进行处理
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                // 对各种事件进行判断处理
                if (key.isAcceptable()) { // 如果是连接事件
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    // 接受客户端连接，拿到连接通道
                    SocketChannel socketChannel = server.accept();
                    socketChannel.configureBlocking(false);
                    // 连接通道注册到selector中
                    // 这里只关注了读的事件，如果需要给客户端发送数据，可以注册写的事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) { // 如果是读事件，进行读取和打印
                    SocketChannel read = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(6); // 定义字节缓冲区存储读取的内容
                    int len = read.read(buffer); // 将读就绪的channel的内容读到buffer中
                    if (len > 0) {
                        // todo业务处理
                        System.out.println("接受到消息：" + new String(buffer.array()));
                        iterator.remove();
                    } else if (len == -1) { // 如果客户端断开了连接，关闭socket
                        System.out.println("客户端断开了连接");
                        read.close();
                    }
                }
            }
        }
    }
}

三：NIO多路复用模型

所谓NIO的多路复用 - 是一种高效的I/O处理机制，它允许单个线程同时监控多个通道(Channel)的I/O状态。这是Java NIO的核心特性之一，显著提高了I/O操作的效率。(一次调用可以查询到多个通道的状态)

在这里插入图片描述

1：select 和 poll

客户端操作服务器时就会产生这三种文件描述符(简称fd)：

writefds(写)
readfds(读)
exceptfds(异常)。

select和poll都会监视内核空间中三种文件描述符的状态，唯一的区别是select对于传入的fd有限制1024个，poll没有

优点：几乎在所有的平台上支持，跨平台支持性好

缺点：

由于是采用轮询方式全盘扫描，会随着文件描述符 FD 数量增多而性能下降
每次调用select()，都需要把fd集合从用户态拷贝到内核态，并进行遍历(消息传递都是从内核到用户空间)
单个进程打开的fd是有限制(通过FD_SETSIZE设置)的，默认是1024个，可修改宏定义，但是效率仍然慢

2：epoll

epoll -> event_poll

三大方法和两大核心结构【红黑树 + 就绪的双向链表】

没有fd个数限制，用户态拷贝到内核态只需要一次，使用时间通知机制来触发。

通过epoll_ctl注册fd，一旦fd就绪就会通过callback回调机制来激活对应fd，进行相关IO操作

epoll_create -> 创建数据结构(红黑树和双向链表，双向链表中存储的是就绪的fd)

在这里插入图片描述

epoll_ctl -> 将文件描述符fd 放入红黑树中, 并标记为可连接的状态

在这里插入图片描述

epoll_wait -> 遍历双向链表，将就绪的fd从双向链表中取出来，准备进行IO

在这里插入图片描述

🎉 这个双向链表是什么时候有东西的呢？就绪的fd是何时放到双向链表中的呢？ -> 中断技术

四：reactor模型

1：单线程的Reactor模型

在这里插入图片描述

select监听到client请求之后，会将client请求给EventDispatcher事件分发

EventDispatcher将事件分成建立连接请求和处理请求：

对于建立连接请求，交给Acceptor的accept处理
对于处理请求，交给Handler处理

2：多线程的Reactor模型

在这里插入图片描述

对于请求的处理有两大改进：

工作线程和连接进行分开(连接的只处理连接，工作的只处理工作)
工作线程使用的是线程池，大大加快处理速度

Redis6.0之前采用的是单线程的Reactor模型，6.0之后采用的是多线程的Reactor模型

3：主从多线程的Reactor模型

在这里插入图片描述

对应到Netty中

在这里插入图片描述

由main reactor进行建立连接的处理，剩下的处理请求都交给sub reactor处理

五：Netty相关的面试题

1：什么是Netty

Netty是一个高性能、异步事件驱动的NIO（非阻塞IO）框架，它使得网络应用程序开发变得简单而高效。

Netty广泛用于构建服务器和客户端的网络通信程序。

是Java语言编写的，建立在Java NIO库之上，针对快速开发可维护的网络协议应用程序和服务进行了优化

2：Netty的核心组件有哪些

核心组件	介绍
BootStrap / ServerBootStrap	启动器，就是BIO中的Socket，NIO中的SocketChannel
EventLoopGroup	可以理解为NIO中的选择器，不需要我们管理线程池了，内部维护了
ChannelFuture	支持了异步，通道的加强版本
Handler(入站和出站)	通道处理器，最为关键的部分，处理Channel通道上的各种事件
ByteBuf	缓冲区的优化，全部是byteBuf，池化技术，不用手动filp()

3：Netty的特性(大概说一说)

核心就是：高性能，异步，事件驱动，零拷贝这几个

高性能：Netty旨在提供高吞吐量、低延迟和最小化资源消耗的能力。它通过有效的资源管理和复用来实现这些设计目标。

简化的API：Netty提供了一套统一的API来处理各种传输类型，如TCP和UDP。这简化了网络应用的软件开发过程。

异步和事件驱动：程序员可以编写非阻塞代码，同时Netty本身也是异步和事件驱动的。

可伸缩性：Netty的设计可以让你充分利用可用的硬件资源，轻松扩展应用以处理数千甚至数百万的并发连接。

灵活性：Netty的架构很灵活，你可以使用它构建各种网络应用程序，从简单的HTTP服务器到复杂的协议栈。

安全性：Netty支持SSL和TLS，可确保数据在网络传输过程中的加密与安全性。

零拷贝：Netty实现了零拷贝特性，可以通过减少不必要的内存拷贝来提高性能。

4：Netty中的零拷贝技术

Netty中的零拷贝(Zero-Copy)技术是一种高效的数据传输机制，它减少了数据在内存中的拷贝次数，从而降低了CPU使用率和内存带宽消耗，提高了应用程序的性能。

所以所谓的零拷贝，并不是不需要经过数据拷贝，而是减少内存拷贝的次数

详细过程可以看我的这个文章

在这里插入图片描述

Netty中的零拷贝是一种用户进程级别的零拷贝体现，主要包含三个方面：

Netty的发送、接收数据的ByteBuf缓冲区，默认会使用堆外本地内存创建，采用直接内存进行Socket读写，数据传输时无需经过二次拷贝。

Netty的文件传输采用了transferTo()/transferFrom()方法，它可以直接将文件缓冲区的数据发送到目标Channel（Socket），底层就是调用了sendfile()内核函数，避免了文件数据的CPU拷贝过程。

Netty提供了组合、拆解ByteBuf对象的API，咱们可以基于一个ByteBuf对象，对数据进行拆解，也可以基于多个ByteBuf对象进行数据合并，这个过程中不会出现数据拷贝，这个也就是上面说的程序数据的零拷贝

下面是Netty中主要的零拷贝技术

1️⃣ CompositeByteBuf

组合多个ByteBuf对象而不进行实际的数据拷贝
允许将多个ByteBuf逻辑上组合成一个完整的ByteBuf
避免了合并多个缓冲区时的内存拷贝操作

public class NettyTest {
    public static void main(String[] args) {
        // 创建一个byteBuf
        ByteBuf header = ByteBufAllocator.DEFAULT.buffer();
        header.writeBytes(new byte[]{1, 2, 3, 4});
        System.out.println(header);

        ByteBuf body = ByteBufAllocator.DEFAULT.buffer();
        body.writeBytes(new byte[]{1, 2, 3, 4});
        System.out.println(body);

        // 创建一个组合的byteBuf
        CompositeByteBuf compositeByteBuf = ByteBufAllocator.DEFAULT.compositeBuffer();
        compositeByteBuf.addComponents(true, header, body);
        System.out.println(compositeByteBuf); // [1, 2, 3, 4, 1, 2, 3, 4]
        System.out.println(compositeByteBuf.getByte(5));
    }
}

2️⃣ 文件传输的零拷贝

使用FileRegion实现文件到网络的直接传输
通过DefaultFileRegion利用操作系统的sendfile系统调用
文件数据直接从文件系统缓存传输到网络通道，不经过用户空间

File file = ...;
FileInputStream in = new FileInputStream(file); // 将文件流化
FileRegion region = new DefaultFileRegion(in.getChannel(), 0, file.length());
channel.writeAndFlush(region);

3️⃣ 内存池(ByteBuf内存池)

重用ByteBuf对象，减少内存分配和回收的开销
使用PooledByteBufAllocator作为默认分配器
通过引用计数管理内存生命周期

4️⃣ 切片和视图

slice()和duplicate()方法创建ByteBuf的视图
共享底层存储，不拷贝实际数据
适合需要处理部分数据或共享数据的场景

5：粘包/半包问题的解决

TCP粘包/拆包问题是指当我们在使用TCP协议进行数据传输时，发送方发送的多个包可能会被TCP协议根据其内部机制合并为一个包发送给接收方（粘包），或者一个包可以被分割成多个小包进行发送（拆包）。

这是TCP协议为了效率在底层的传输过程中作出的优化，但对于应用层的协议解析来说可能造成问题。

Netty中是通过各种解码器完成粘包和半包的问题，区分那一段消息是一个包

解码器	说明
固定长度解码器	通过约定每个包的长度固定
行分隔符解码器	在文本协议中，通常以换行符（\n）或者回车换行符（\r\n）作为一个数据包的结束标志
分隔符解码器	适用于消息以特定的分隔符结尾的场景
长度字段解码器	对于将消息长度发送在消息头部的协议
自定义解码器	用户可以根据自己的协议设计
使用编码器/解码器对	通常把数据编码器（Encoder）与数据解码器（Decoder）结合使用

6：如何对Netty进行性能优化

在 Netty 中进行性能优化通常涉及到对资源的高效管理和对各种网络操作的精细化调整。

以下是一些在 Netty 中进行性能优化的建议：

1️⃣ 线程模型的优化：

EventLoopGroup 配置：合理地配置 EventLoopGroup 的线程数量。对于大多数应用(2 * 核心数)

业务逻辑线程和 I/O 线程分离：避免在 I/O 线程中执行耗时业务逻辑，以防止阻塞 I/O 处理

可以使用ChannelPipeline.addLast(group, handlers) 添加额外的线程池来处理耗时操作。

2️⃣ 缓冲区的管理：

ByteBuf 优化：使用 Netty 提供的 ByteBuf 替代 JDK 的 ByteBuffer

合理配置 ByteBuf 分配器：考虑使用 PooledByteBufAllocator 来减少内存的分配和释放，提高内存利用率

3️⃣ 减少内存的复制

当处理入站和出站数据时，尽量避免不必要的内存复制。

例如，使用 ByteBuf 的 slice() 方法来避免真正的字节数组复制。

4️⃣ 调整TCP的参数

合理配置 Socket 选项，如 SO_REUSEADDR、SO_KEEPALIVE、TCP_NODELAY（减少延迟）、SO_LINGER、SO_SNDBUF、SO_RCVBUF（发送和接收缓冲区大小）等

5️⃣ 减少对象的创建，请求批处理等等…

7：Netty是如何管理内存和资源的

Netty是一个为快速开发可维护的高性能网络应用程序而设计的异步事件驱动的网络应用程序框架。

资源和内存管理是Netty性能快速响应的关键之一。以下是Netty如何管理资源和内存的一些关键机制：

ByteBuf

ByteBuf是Netty中用于处理字节数据的主要数据结构。

与Java原生的ByteBuffer相比，ByteBuf提供了更强的功能和更好的性能。

Netty通过ByteBuf提供了高效的数据处理能力，且使得内存的分配和管理更加灵活。

ByteBuf支持引用计数（reference counting），这使得内存可以在不再需要时立即释放。

引用计数（Reference Counting）

Netty 使用引用计数来管理对象生命周期，比如ByteBuf和其他资源。

当一个新的ByteBuf被分配时，它的引用计数设置为1。每次ByteBuf被传递给另一个组件时，引用计数会增加。

当使用完毕时，可以调用release()方法以减少引用计数

一旦减至0，ByteBuf所占用的内存就会被释放或回收重用。

池化（Pooling）

Netty提供了基于池化的内存分配选项，这种机制减少了对象的创建和垃圾收集的频率。

池化的ByteBuf会在使用完毕后返回到池中，从而被后续操作重复利用。

这有助于减少GC压力，尤其在大量小对象的情况下。

Unpooled vs Pooled

Netty 分为 unpooled 和 pooled 两种内存分配模型。

Unpooled内存分配不会重复利用已分配的内存，而是每次都进行新的内存分配。

而pooled内存分配则优先重用已分配的内存，通过在内存区块之间共享来达到内存利用率的优化。

Direct vs Heap Buffer

Netty允许使用堆外（direct）缓冲区来减少内存拷贝。

堆外内存直接受操作系统管理，不受JVM控制，可以进行更快的I/O操作

堆外内存可以直接传递给操作系统完成网络传输。

Leak Detection（内存泄漏检测）

Netty 提供了一个可选的内存泄漏检测机制，该机制可以帮助开发者找出潜在的内存泄漏问题。

开发者可以按需调整检测级别，比如在开发和测试阶段使用较高的敏感度和在生产环境使用较低的敏感度。

预分配和重用

Netty 的优化之一是预分配和重用网络传输所需的内存。

例如，在一个网络连接的生命周期内，通道的数据写缓冲区可以被预分配，并在需要时被重用。

8：Netty中如何实现心跳机制

在Netty中实现心跳机制通常涉及到使用一些特殊的处理器（handler）来管理连接的保活（keep-alive），确保连接在没有数据交互的情况下仍然保持开启状态。

Netty提供了IdleStateHandler来帮助实现这一功能:

1️⃣ 添加IdleStateHandler到你的ChannelPipeline

在你的通道设置中（通常在ChannelInitializer中），增加一个IdleStateHandler。这个处理器会触发一个

IdleStateEvent事件，该事件表示连接可能由于超时而变为不活跃状态。可以设置读、写或读写的空闲时间。

@Override
protected void initChannel(SocketChannel ch) throws Exception {
    ChannelPipeline pipeline = ch.pipeline();
    
    // 添加IdleStateHandler
    int readerIdleTimeSeconds = 60; // 无读操作的超时时间（时间单位为秒）
    int writerIdleTimeSeconds = 30; // 无写操作的超时时间（时间单位为秒）
    int allIdleTimeSeconds = 100; // 无读写操作的超时时间（时间单位为秒）
    pipeline.addLast("idleStateHandler", new IdleStateHandler(readerIdleTimeSeconds, writerIdleTimeSeconds, allIdleTimeSeconds));
    
    // 添加你的其他处理器
    // ...
}

2️⃣ 检测空闲和发送心跳

然后在自定义的ChannelInboundHandlerAdapter中检测IdleStateEvent事件。

当检测到空闲时，可以选择发送一个心跳消息到对端或者做其他操作。

public class HeartbeatHandler extends ChannelInboundHandlerAdapter {
    
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            String idleType = null;
            switch (event.state()) {
                case READER_IDLE:
                    idleType = "读空闲";
                    break;
                case WRITER_IDLE:
                    idleType = "写空闲";
                    // 你可以发送心跳消息
                    sendHeartbeatMessage(ctx);
                    break;
                case ALL_IDLE:
                    idleType = "读写空闲";
                    break;
            }
            System.out.println(ctx.channel().remoteAddress() + "超时事件：" + idleType);
        } else {
            super.userEventTriggered(ctx, evt);
        }
    }
    
    private void sendHeartbeatMessage(ChannelHandlerContext ctx) {
        // 这里你可以写自己的心跳消息逻辑
        ctx.writeAndFlush("心跳包"); // 仅示例，实际中应该发送更加合适的数据
    }
}

添加自定义处理器到管道

确保自定义的ChannelInboundHandlerAdapter可以处理IdleStateEvent事件，添加它到ChannelPipeline。

pipeline.addLast("heartbeatHandler", new HeartbeatHandler());

如此配置后，如有任何空闲事件发生，你的处理器会对其作出反应，你可以在处理器中根据不同的空闲类型制定不同的心跳策略，如仅当写操作空闲时发送心跳消息。

请注意，心跳机制通常需要服务器和客户端共同配合才能正常工作，双方要约定心跳消息的内容和检测到断连后的处理逻辑

9：Netty适用于哪些类型的应用

Netty是一个非常灵活且功能强大的网络编程框架，它广泛应用于许多类型的网络应用程序和服务。

以下是Netty适用的一些场景示例：

Web服务器和应用服务器：Netty可以用于开发高性能的Web服务器，支持大量的并发客户端连接。
实时通讯系统：对于需要低延迟和高吞吐量的实时聊天应用程序或游戏服务器，Netty提供了理想的解决方案。
协议转换网关：Netty可以用来实现支持多种私有协议的网关，进行不同协议之间的转换。
物联网（IoT）平台：对于需要高并发和低延迟通讯的物联网平台，Netty可以作为设备和服务器之间通讯的核心组件。
代理服务器：利用Netty可以轻易构建功能丰富的代理服务器，如HTTP代理、SOCKS代理。
负载均衡器：由于Netty高性能的IO处理能力，可用作构建高效的负载均衡器。
RPC框架：许多开源的RPC框架都是基于Netty实现的，比如gRPC的Java版本。
API网关：Netty适合作为API网关，处理大量的RESTful请求，为微服务架构提供动态路由、监控和身份验证。
文件传输应用程序：Netty的异步和事件驱动特性使其成为构建高效、稳定文件传输应用程序的最佳选择。
自定义网络协议服务器和客户端：如果你需要针对特定需求实现一个自定义的网络协议，Netty提供了创建服务器和客户端所需的API和工具。

Netty的设计使得它不仅适用于这些场景，还适用于任何需要使用TCP/UDP协议栈进行网络通信的场合。它的核心优势在于高性能、高吞吐量、安全性和易于使用，尤其适合构建能够支持多连接和长连接的应用程序。

10：Netty是如何支持SSL/TLS的

Netty 支持 SSL/TLS 来增强数据传输的安全性，使用了 Java 的 SSLEngine 来实现 SSL/TLS 协议的处理。

这允许 Netty 基于配置的安全套接字层(SSL)或传输层安全(TLS)加密网络连接，确保数据加密和身份验证。

以下是 Netty 支持 SSL/TLS 的关键步骤：

1️⃣ 初始化SSLContext

// 首先，需要初始化 SSLContext 实例，它将为应用程序提供加密、解密、会话管理等能力。
// 一般需要提供密钥仓库（KeyStore）和信任仓库（TrustStore）的信息。
// 示例代码初始化 SSLContext
SSLContext sslContext = SSLContext.getInstance("TLS"); // 使用TLS协议
sslContext.init(
    keyManagerFactory.getKeyManagers(), 
    trustManagerFactory.getTrustManagers(), 
    new SecureRandom()
);

2️⃣ 创建SSL Handler

// SSLContext 被用来创建 SslHandler，这是一个 ChannelHandler，用于在 Netty 的 ChannelPipeline 中管理 SSL/TLS 操作。
// 示例代码创建 SslHandler
SslHandler sslHandler = sslContext.newHandler(channel.alloc());

3️⃣ 添加 SslHandler 到 ChannelPipeline

// SslHandler 必须被添加到 ChannelPipeline 中，以确保它能截获所有通过管道的 IO 事件进行加密(decrypt)/解密(encrypt)操作。
// 示例代码将 SslHandler 添加到 ChannelPipeline
pipeline.addLast("ssl", sslHandler);

4️⃣ 配置并启动服务器/客户端

无论是编写服务器还是客户端代码，应该在 ChannelPipeline 中添加 SslHandler。

对于服务器，SslHandler 必须在 bind() 操作之前添加到服务器的管道中；

对于客户端，在 connect() 操作之前添加。

// -------------- 服务端 ------------------
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
    .channel(NioServerSocketChannel.class) // 管道设置nio
    .handler(new LoggingHandler(LogLevel.INFO)) // 日志handler boos
    // 工作线程handler设置是
    .childHandler(new ChannelInitializer<SocketChannel>() {
        @Override
        public void initChannel(SocketChannel ch) {
            ChannelPipeline p = ch.pipeline();
            // SSL加持
            SSLEngine engine = sslContext.createSSLEngine();
            engine.setUseClientMode(false);
            p.addLast(new SslHandler(engine));
            // 添加其他 ChannelHandler
        }
    })
    // 端口的绑定，同步
    .bind(port).sync();

// ------------------- 客户端 --------------------------
Bootstrap b = new Bootstrap();
b.group(group)
    .channel(NioSocketChannel.class)
    .handler(new ChannelInitializer<SocketChannel>() {
        @Override
        public void initChannel(SocketChannel ch) {
            ChannelPipeline p = ch.pipeline();
            SSLEngine engine = sslContext.createSSLEngine();
            engine.setUseClientMode(true);
            p.addLast(new SslHandler(engine));
            // 添加其他 ChannelHandler
        }
    })
    // SSL加持发生在connect之前
    .connect(host, port).sync();

5️⃣ 自带签名证书的替代方案

Netty 提供了支持自签名证书的安全通信的简化方法，例如通过 SelfSignedCertificate。注意事项如下：

强烈推荐在生产环境中使用权威的证书颁发机构（CA）签发的证书来避免自签名证书相关的安全问题。
要确保 SslHandler 位于 ChannelPipeline 的正确位置，在任何需要数据加密的自定义 ChannelHandler 之前。
Netty 提供的 SSL/TLS 支持非常灵活，可以满足大多数加密通信的需要。

11：如何监控和调试Netty服务器

日志记录

使用内置日志记录：Netty提供了日志记录功能，可以通过调整日志等级来监控网络操作和内部状态。

InternalLoggerFactory.setDefaultFactory(Slf4JLoggerFactory.INSTANCE);

自定义日志处理器：创建自定义的ChannelHandler，并在ChannelPipeline中添加它以打印消息和异常。

pipeline.addLast("log", new LoggingHandler(LogLevel.INFO));

性能指标监控

将如Micrometer、Dropwizard Metrics等监控工具集成到Netty服务器中

以收集有关线程状态、内存使用、GC活动等的性能指标。

处理器定制

自定义处理器：编写自定义ChannelHandler，用于记录关键事件，并对异常情况采取相应操作。

输出ChannelPipeline配置：在应用启动时或运行过程中打印出ChannelPipeline的配置，以确保处理器按预期顺序执行

工具和插件

使用Netty提供的编解码器：使用如LoggingHandler和ByteBuf日志器来记录网络交互细节，对入站和出站数据进行调试。

使用网络监控工具：使用如Wireshark、tcpdump等网络抓包工具来监听和分析网络上的数据流。

压力测试和基准测试

压力测试：使用工具如JMeter、Gatling等对服务器进行压力测试，模拟高并发场景，识别瓶颈和潜在问题。
基准测试：使用基准测试框架定期运行性能测试，比较不同部署和优化的效果。

调试支持

使用IDE调试器：在开发环境中，可以直接在IDE（如IntelliJ IDEA或Eclipse）里设置断点进行交互式调试。

远程调试：配置远程调试，允许你在服务器上运行时附加调试器。

分析工具

JFR：使用JFR对JVM进行低开销的数据采集，分析运行时性能问题。
VisualVM：通过工具如VisualVM对JVM内存、线程和CPU使用情况进行实时监控和分析。

面试 - Java IO和Netty

面试 - Java IO和Netty

文章目录

一：BIO和NIO的区别

二：NIO三大核心组成部分

1：Buffer缓冲区

2：Channel通道

3：Selector选择器

三：NIO多路复用模型

1：select 和 poll

2：epoll

四：reactor模型

1：单线程的Reactor模型

2：多线程的Reactor模型

3：主从多线程的Reactor模型

五：Netty相关的面试题

1：什么是Netty

2：Netty的核心组件有哪些

3：Netty的特性(大概说一说)

4：Netty中的零拷贝技术

5：粘包/半包问题的解决

6：如何对Netty进行性能优化

7：Netty是如何管理内存和资源的

8：Netty中如何实现心跳机制

9：Netty适用于哪些类型的应用

10：Netty是如何支持SSL/TLS的

11：如何监控和调试Netty服务器