Java和Linux的IO模型探索

已于 2023-11-12 10:25:02 修改
阅读量591 收藏
点赞数 19
分类专栏： Java Linux 文章标签： java linux
于 2023-10-22 23:57:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60505735/article/details/133976182
版权

1、什么是IO？

IO：计算机系统中用于与外部设备进行数据交换的过程。主要分为磁盘IO和网络IO：

  • 磁盘IO：

    • 读 ： 将磁盘中的数据读到内存中
    • 写： 将内存中的数据写到磁盘中

  • 网络IO:

    • 读： 将网卡中的数据读到内存中
    • 写： 将内存中的数据写到网卡中

2、Linux下的网络IO模型

2.1、用户空间与内核空间

Linux把内存划分为用户空间和内核空间，当用户空间的进程要读取硬件资源时，需要调用内核空间提供的函数进行调用，分为两阶段：

  • 第一阶段将硬件资源拷贝到内核缓冲区，称为等待数据
  • 第二阶段将内核缓冲区拷贝到用户缓冲区，称为数据拷贝

由于用户空间的程序是无法直接访问计算机硬件的，而是要调用内核空间提供的接口，由内核空间帮我们访问

2.2、阻塞IO (BIO)

顾名思义，阻塞IO就是两个阶段都必须阻塞等待:

2.3、非阻塞IO (NIO)

顾名思义，非阻塞IO的recvfrom操作会立即返回结果而不是阻塞用户进程：

可以看到，非阻塞IO模型中，用户进程在第一个阶段是非阻塞，第二个阶段是阻塞状态。虽然是非阻塞，但性能并没有得到提高。而且忙等机制会导致CPU空转，CPU使用率暴增。

recvfrom 是UDP无连接的，不知道消息何时发过来，会有一个进程一直执行recvfrom去监听
这里的用户进程指Linux上的用户应用（如：Redis服务器）

2.4、IO多路复用

复用一个线程去监听多个FD（统一资源描述符，如Socket），当有FD就绪时，通知线程处理。

socket（网卡，硬件），将socket的内容拷贝到内核空间，如果现在只有一个线程，有多个socket，处理这个socket内容复制到内核空间的时间很长，那么当前线程就会阻塞，其他socket即使已经复制完成了，也阻塞不能执行，而IO多路复用会监听这些socket，当这个socket内容复制完成就绪了，内核空间有数据，当前线程才去执行。

Linux中的IO多路复用的实现有三种：select、poll 、epoll

1、select

底层实现：

fd集合： 32 个 int ,一个int 4字节 --> 一个 int 32个字节 --> 1024位 --> 监听1024个比特位

流程如下:

select模式存在的问题:

  • 需要将整个fd_set从用户空间拷贝到内核空间,select结束还要再次拷贝回用户空间
  • select无法得知具体是哪个fd就绪，需要遍历整个fd_set
  • fd_set监听的fd数量不能超过1024
2、poll

底层实现：
image-20230325115305296

具体流程：

  • 创建pollfd数组，向其中添加关注的fd信息，数组大小自定义
  • 调用poll函数，将pollfd数组拷贝到内核空间，转链表存储，无上限
  • 内核遍历fd，判断是否就绪
  • 数据就绪或超时后，拷贝pollfd数组到用户空间，返回就绪fd数量n
  • 用户进程判断n是否大于0
  • 大于0则遍历pollfd数组，找到就绪的fd

poll模式存在的问题：

  • 需要将整个pollfd从用户空间拷贝到内核空间,poll结束还要再次拷贝回用户空间
  • 第四步拷贝pollfd数组是拷贝所有的pollfd元素，包括没准备就绪的，用户空间得到之后仍然要遍历所有

注意：poll模式只解决了select模式下只能存1024个元素的问题

3、epoll

底层实现：

具体流程：

epoll实现依赖于三个方法：

  • epoll_create(): 在内核空间创建一棵名为rb_root的红黑树监听所有的FD，创建名为list_head链表存放所有就绪的FD
  • epoll_ctl() : 将FD添加到rb_root红黑树中，并绑定一个回调事件，当FD就绪时，将就绪的FD加入到list_head就绪链表中
  • epoll_wait(): 监听list_head中有没有就绪的FD事件，如果有，将就绪的FD事件拷贝到用户空间中

epoll完美解决了select模式的三种问题：

  • 基于epoll实例中的红黑树保存要监听的FD，理论上无上限，而且增删改查效率都非常高，性能不会随监听的FD数量增多而下降
  • 每个FD只需要执行一次epoll_ctl添加到红黑树，以后每次epo_wait，无需传递任何参数，无需重复拷贝FD到内核空间
  • 内核会将就绪的FD直接拷贝到用户空间的指定位置，用户进程无需遍历所有FD就能知道就绪的FD是谁

2.5、信号驱动IO

信号驱动IO是与内核建立SIGIO的信号关联并设置回调，当内核有FD就绪时，会发出SIGIO信号通知用户，期间用户应用可以执行其它业务，无需阻塞等待

2.6、异步IO (AIO)

异步IO就是一二阶段都处理完，才给你结果

3、Java中的IO模型

Java中的BIO、NIO、AIO是一种编程模型，用于处理网络通信，而Linux中的IO模型是一个操作系统概念，用于处理设备I/O。

3.1、BIO

Java BIO：同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不作任何事情会造成不必要的线程开销。

在这里插入图片描述

服务端代码如下：

public class SocketServer {

    public static void main(String[] args) {

        try {
            ServerSocket socket = new ServerSocket(8082);
            while (true) {
                System.out.println("等待客户端连接...");
                // 同步阻塞，直到建立连接
                Socket client = socket.accept();
                // 有客户端连接了，发送一个消息给客户端
                OutputStream output = client.getOutputStream();
                output.write(("客户端[" + client.getPort() + "]你好，你已成功连接到8082服务端").getBytes());
                output.flush();
                System.out.println("客户端已连接:" + client.getPort());
                try {
                    InputStream input = client.getInputStream();
                    byte[] bytes = new byte[1024];
                    // 同步阻塞 读取客户端数据 直到输入数据
                    while (input.read(bytes) != -1) {
                        output.write(("收到了你的消息:" + new String(bytes)).getBytes());
                        output.flush();
                        System.out.println("收到客户端消息:" + new String(bytes));
                    }
                } catch (IOException ex) {
                    // 客户端链接断开则引发异常
                    System.err.println("引发异常：" + ex.getMessage());
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端代码：

public class SocketClient {

    public static void main(String[] args) {
        try {
            // 接收控制台用户输入的数据
            Scanner scanner = new Scanner(System.in);
            // 要绑定的主机和端口号
            Socket socketClient = new Socket("127.0.0.1", 8082);
            OutputStream output = socketClient.getOutputStream();
            while (true) {
                String str = scanner.nextLine();
                if ("exit".equals(str)) {
                    output.close();
                    socketClient.close();
                    break;
                } else {
                    // 向服务端发送消息
                    output.write(str.getBytes());
                    output.flush();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

测试如下，多个client只有一个能连接上，尽管连接上的client没有命令，也不能处理连接：
在这里插入图片描述

针对这一情况，对每个连接都启用一个线程去处理：

在这里插入图片描述

服务器通过一个Acceptor线程负责监听客户端请求和为每个客户端创建一个新的线程进行链路处理。典型的一请求一应答模式。若客户端数量增多，频繁地创建和销毁线程会给服务器打开很大的压力。后改良为用线程池的方式代替新增线程，被称为伪异步IO。

3.2、NIO

Java NIO：同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求会被注册到多路复用器上，多路复用器轮询到有 I/O 请求就会进行处理。

三个核心组件：

  1. 通道（Channel）：
    通道提供了一个双向传输数据的路径，可以用于读取和写入数据。常见的通道类型包括文件通道（FileChannel）和网络套接字通道（SocketChannel、ServerSocketChannel等）。
  2. 缓冲区（Buffer）：
    缓冲区是一种用于存储数据的对象。在Java NIO中，所有的I/O操作都是通过缓冲区进行的。缓冲区提供了对数据的统一访问操作，包括读取数据到缓冲区和从缓冲区写出数据。不同类型的数据可以使用不同类型的缓冲区来处理，例如ByteBuffer、CharBuffer、IntBuffer等。缓冲区有一个内部指针，用于跟踪读写操作的位置。
  3. 选择器（Selector）：
    选择器是Java NIO中的一个核心组件，它允许一个线程同时监控多个通道的I/O事件。选择器可以管理一组通道，监听它们上注册的感兴趣的事件，如读、写、连接和接收等。一旦有就绪的事件发生，选择器就会通知应用程序进行处理。通过选择器，可以使用单个线程有效地处理多个通道的I/O操作，实现非阻塞的事件驱动编程。

在使用Java NIO时，一般的步骤如下：

  1. 创建一个通道（Channel），绑定到适当的I/O源。
  2. 创建一个缓冲区（Buffer），用于读写数据。
  3. 利用选择器（Selector）注册通道，并设置感兴趣的事件类型。
  4. 轮询选择器（Selector）以检测已就绪的事件。
  5. 处理已就绪的事件，读取或写入数据。

服务端代码如下：

@Slf4j
public class Server {
    public static void main(String[] args) throws IOException {

        //创建服务端
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        ssc.bind(new InetSocketAddress(8080));
        //创建Selector
        Selector selector = Selector.open();

        //将 ssc注册到selector上, 0表示ssc不关心任何事件
        //通过 SelectionKey就是将来事件发生之后，可以拿到事件，和关心这个事件的channel

        SelectionKey sscKey = ssc.register(selector, 0, null);
        //关心接收连接事件
        sscKey.interestOps(SelectionKey.OP_ACCEPT);

        while (true) {
            //没有事件发生时，线程阻塞，有事件，线程才会恢复执行
            log.info("before...select...");
            selector.select();
            //处理事件，selectedKeys()返回的是所有发生的事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                if (selectionKey.isAcceptable()) {
                    //拿到上面注册的ServerSocketChannel
                    ServerSocketChannel serverSocketChannel = (ServerSocketChannel) selectionKey.channel();
                    log.info("before...connection...");
//                    selectionKey.cancel();
                    //处理事件,接收连接
                    SocketChannel channel = serverSocketChannel.accept();
                    channel.configureBlocking(false);
                    log.info("after...connection...{}", channel);
                    ByteBuffer byteBuffer = ByteBuffer.allocate(4);
                    //添加附件，实现将buffer与通道关联
                    SelectionKey scKey = channel.register(selector, 0, byteBuffer);
                    scKey.interestOps(SelectionKey.OP_READ);
                } else if (selectionKey.isReadable()) {
                    try {
                        SocketChannel channel = (SocketChannel) selectionKey.channel();
                        ByteBuffer buffer = (ByteBuffer) selectionKey.attachment();
                        log.info("before...read...");
                        int read = channel.read(buffer);
                        if (read == -1 ){
                            //客户端都关闭了，当然可以把通道撤销，并处理事件
                            //这里不用担心将其他通道关闭，因为能执行到这，说明有读事件发生，且读到的是-1，说明是关闭
                            //如果客户端没有消息发送，虽然read也是-1，但是没有读事件，根本不会执行到这
                            //而真正的读事件，肯定不是-1，走的else，直接执行就好，而不会关闭通道
                            selectionKey.cancel();
                        }else {
                            split(buffer);
                            if (buffer.position() == buffer.limit()){ //没有拆分，字符串太大，buffer装不下
                                ByteBuffer newBuffer = ByteBuffer.allocate(buffer.capacity() * 2);
                                buffer.flip();//切换读模式
                                newBuffer.put(buffer);
                                selectionKey.attach(newBuffer);
                            }
//                            System.out.println(StandardCharsets.UTF_8.decode(buffer));
//                            debugAll(buffer);
//                            log.info("after...read...");
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        selectionKey.cancel();
                    }
                }

                //void remove(): 从集合中移除迭代器最后访问过的元素。注意，
                // 这个方法只能在调用了next()方法之后才能调用一次
                //删除使用过的key
                iterator.remove();
            }
        }
    }
    private static void split(ByteBuffer source) {
        //切换读模式
        source.flip();
        for (int i = 0; i < source.limit(); i++) {
            //get(i) 不改变position的位置
            if (source.get(i) == '\n'){
                int length = i - source.position() + 1 ;
                ByteBuffer target = ByteBuffer.allocate(length);
                for (int j = 0; j < length; j++) {
                    target.put(source.get());
                }
                debugAll(target);
            }
        }
        //把未读的前移
        source.compact();
    }
}

客户端代码如下：

public class Client {
    public static void main(String[] args) throws InterruptedException {
        new Bootstrap()
                .group(new NioEventLoopGroup())
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<Channel>() {
                    @Override
                    protected void initChannel(Channel channel) throws Exception {
                        channel.pipeline().addLast(new StringEncoder());
                    }
                }).connect(new InetSocketAddress("127.0.0.1",8080))
                .sync()
                .channel()
                .writeAndFlush("hello world");

    }
}

测试如下，复用一个线程监听多个client：
在这里插入图片描述

3.3、AIO

Java AIO：异步非阻塞，AIO使用回调机制，应用程序发起I/O操作后不需要等待操作完成，而是可以继续执行其他任务。当I/O操作完成时，系统会通知应用程序。

主线程只负责将当前client分配给一个子线程，子线程去执行client的任务，而子线程处理完之后，可以给主线程反馈结果，主线程注册完之后，不会等待子线程执行完client任务，而是可以去执行其他的命令，这就是异步。而NIO中，复用的线程并不能解放出来，即同步。

服务端代码：

public class AIOServer {

    public static void main(String[] args) {
        try {
            final int port = 8080;
            //首先打开一个ServerSocket通道并获取AsynchronousServerSocketChannel实例：
            AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open();
            //绑定需要监听的端口到serverSocketChannel:  
            serverSocketChannel.bind(new InetSocketAddress(port));
            //实现一个CompletionHandler回调接口handler，
            //之后需要在handler的实现中处理连接请求和监听下一个连接、数据收发，以及通信异常。
            CompletionHandler<AsynchronousSocketChannel, Object> handler = new CompletionHandler<AsynchronousSocketChannel,
                    Object>() {
                @Override
                public void completed(final AsynchronousSocketChannel result, final Object attachment) {
                    // 继续监听下一个连接请求  
                    serverSocketChannel.accept(attachment, this);
                    try {
                        System.out.println("接受了一个连接：" + result.getRemoteAddress()
                                                              .toString());
                        // 给客户端发送数据并等待发送完成
                        result.write(ByteBuffer.wrap("From Server:Hello i am server".getBytes()))
                              .get();
                        ByteBuffer readBuffer = ByteBuffer.allocate(128);
                        // 阻塞等待客户端接收数据
                        result.read(readBuffer)
                              .get();
                        System.out.println(new String(readBuffer.array()));

                    } catch (IOException | InterruptedException | ExecutionException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void failed(final Throwable exc, final Object attachment) {
                    System.out.println("出错了：" + exc.getMessage());
                }
            };
            serverSocketChannel.accept(null, handler);
            // 由于serverSocketChannel.accept(null, handler);是一个异步方法，调用会直接返回，
            // 为了让子线程能够有时间处理监听客户端的连接会话，
            // 这里通过让主线程休眠一段时间(当然实际开发一般不会这么做)以确保应用程序不会立即退出。
            TimeUnit.MINUTES.sleep(Integer.MAX_VALUE);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

客户端代码：

public class AIOClient {

    public static void main(String[] args) {
        try {
            // 打开一个SocketChannel通道并获取AsynchronousSocketChannel实例
            AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
            // 连接到服务器并处理连接结果
            client.connect(new InetSocketAddress("127.0.0.1", 8080), null, new CompletionHandler<Void, Void>() {
                @Override
                public void completed(final Void result, final Void attachment) {
                    System.out.println("成功连接到服务器!");
                    try {
                        // 给服务器发送信息并等待发送完成
                        client.write(ByteBuffer.wrap("From client:Hello i am client".getBytes()))
                              .get();
                        ByteBuffer readBuffer = ByteBuffer.allocate(128);
                        // 阻塞等待接收服务端数据
                        client.read(readBuffer)
                              .get();
                        System.out.println(new String(readBuffer.array()));
                    } catch (InterruptedException | ExecutionException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void failed(final Throwable exc, final Void attachment) {
                    exc.printStackTrace();
                }
            });
            TimeUnit.MINUTES.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException | IOException e) {
            e.printStackTrace();
        }
    }
}

运行如下：
在这里插入图片描述

Chaimek
关注
专栏目录
Java IO模型：BIO、NIO、AIO讲解
流楚丶格念的博客
10-17 2032
IO，Input/Output 简写，是指内存和外设之间的数据复制的过程。输入是指数据从外设复制到内存中， 输出则是指数据从内存复制到外设。目前，IO 可以通过数据流、序列化和文件系统为系统提供输入和输出而Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。Java IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。
Java 五种IO模型
qq_63353796的博客
07-16 632
Java 五种IO模型
深入理解JAVA I/O系列六：Linux中的IO模型
weixin_30528371的博客
08-14 158
IO模型 　　linux系统IO分为内核准备数据和将数据从内核拷贝到用户空间两个阶段。 这张图大致描述了数据从外部磁盘向运行中程序的内存中移动的过程。 用户空间、内核空间 　　现在操作系统都是采用虚拟存储器，那么对32位操作系统而言，它的寻址空间（虚拟储存空间）为4G（2的32次方）。操作系统的核心是内核，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限...
java linux io流_Java基础之IO流
weixin_39597399的博客
03-01 212
补充JavaSE的一些细节部分关于IO流的一些总结首先要介绍的是File类，File类用于对文件和目录的一些操作1.创建文件CreateNewFile()2.对文件的信息的获取getName(),getAbsolutePath()3.判断是否是文件isFile()4.遍历整个目录下的文件 File[] listFile(),返回一个元素为文件的对象数组，可以使用方法来遍历数组然后引入了流的概念以内...
学习Java——Linux 5种IO模型
L170311的博客
03-19 1613
人终将被年少不可得之物困其一生，也终将因一事一景解开一生困惑
Linux网络IO模型及JAVA中IO模型
凶猛的小蜜蜂
06-27 610
文章目录1.概述2.Linux网络IO模型2.1.阻塞IO模型2.2.非阻塞IO模型2.3.IO复用模型2.3.1.select2.3.2.poll2.3.3.epoll2.4.信号驱动IO模型2.5.异步IO3.JAVA中IO模型 1.概述 在jdk1.4之前JAVA只有同步阻塞IO，在jdk1.4版本更新同步非阻塞的NIO，在jdk1.7又更新了异步的NIO2.0，本文将简单介绍下Linux有哪些网络IO模型，以及JAVA中的IO所对应的网络IO模型。 理解本文之前需要先知道一个概念：用户空间与内核空间
javaIO模型1
08-08
总结起来，Java IO模型1涵盖了同步与异步、阻塞与非阻塞的基本概念，以及五种不同的IO处理方式，每种都有其适用场景和优缺点，开发者需要根据具体需求选择合适的IO模型。对于高并发、高效率的网络应用，通常会选择非...
Java网络IO模型分析与实现
m0_71777195的博客
03-14 176
本篇文章会对Java中的网络IO模型的概念进行解释，并给出具体的Java代码实现，主要涉及如下部分。BIO（同步阻塞IO模型）的概念和Java编程实现；（同步非阻塞IO模型）的概念和Java编程实现；IO多路复用的概念；NIONew IO）的概念和Java编程实现。在开始本篇文章内容之前，有一个简单的关于Socket的知识需要说明：在进行网络通信的时候，需要一对Socket，一个运行于客户端，一个运行于服务端，同时服务端还会有一个服务端Socket，用于监听客户端的连接。下图进行一个简单示意。
从Linux五种IO模型到JAVA NIO，一文理解IO模型的本质
KDLin‘s Blog
12-27 504
BIO,NIO 2020年12月25日 15:01 目录 - - 引言 - Linux中五种IO模型 - 预备知识 - 阻塞式I/O - 非阻塞IO模型 - IO复用模型 - 信号驱动的IO模型 - 异步IO模型 - JAVA中的IO模型 - BIO - NIO - 三大模块： ...
Java三种IO模型以及Linux五种IO模型
Yufail的博客
03-26 1137
理解Linux五种IO模型是理解Java IO模型的基础，以钓鱼的例子为例，是否等待鱼上钩（数据准备）用来区分阻塞和非阻塞，是否手动将鱼捞出用来区分同步和异步（真正的读写操作），链接：https://mp.weixin.qq.com/s?__biz=Mzg3MjA4MTExMw==&mid=2247484746&idx=1&sn=c0a7f9129d780786cabfca...
linux编写java io,java io涉及到的一些linux知识
weixin_42109178的博客
05-09 155
简介本文最重要的一个收获是我们要知道：一次网络io 程序与内核的交互是两个阶段，正是按照这个两个阶段的不同处理，linux 网络io 分为5种模型。io设备磁盘(和内存)是一个可寻址的大数组(内存寻址：段 ==> 页 => 字节，磁盘寻址 磁盘 ==> xx ==> 字节)，而os和应用都无法直接访问这个大数组(强调一下，即便是os，也是通过文件系统，即/xx/xx的方式来...
深入理解Linux与Java的IO模型
林木森的博客
03-24 1171
不同的I/O模型（阻塞、非阻塞、I/O多路复用、信号驱动、异步）在用户空间与内核空间的交互方式、进程状态管理、以及数据传输的时机和方式上有所不同，但它们共同构成了Linux系统强大灵活的I/O处理能力。Linux提供了多种I/O模型，例如阻塞I/O、非阻塞I/O、I/O多路复用（select/poll/epoll）、信号驱动I/O和异步I/O。Java的NIO虽然名为“非阻塞I/O”，但它更准确地描述为支持非阻塞模式和I/O多路复用的I/O模型，而非纯粹的非阻塞I/O。
javaIO与Linux IO的关系
e891377的专栏
11-20 289
javaIO与Linux IO的关系 javaIO与Linux IO的关系，如图
java IO初识与Linux网络I/O模型简介
持之以恒！
12-31 1672
Java的 I/O发展简史 从 JDK1.0到 JDK1.3, Java的 I/O类库都非常原始,很多 UNIX网络编程中的概念或接口在l/O类库中都没有体现,例如 Pipe、 Channel、 Buffler和 Selector等。在 JDKl.4推出 Java NlO之前, 基于 Java的所有 socket通信都采用了同步阻塞模式( BIO) , 这种一请求一应答的通信模型简化了上层的应用...
JAVA-01-变量
LJH_laura_li的博客
11-08 435
在方法、构造函数或块内部定义的变量。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
最新发布
chusheng1840的博客
11-09 1040
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 657
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 337
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
理解Linux网络IO模型：同步与异步，阻塞与非阻塞的区别
"这篇文档详细探讨了网络IO模型，包括同步IO、异步IO、阻塞IO和非阻塞IO的概念及其区别。作者指出，由于不同的知识背景和上下文，人们对这些概念的理解可能存在差异。文章主要关注Linux环境下的网络IO，并引用了...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值