Java | IO 模式之 JavaBIO 应用

已于 2023-03-01 14:50:12 修改
阅读量663 收藏 4
点赞数 1
分类专栏： —— Java —— 文章标签： java 服务器 servlet
于 2023-03-01 14:33:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xt199711/article/details/129280874
版权

文章目录

IO模型

Java BIO

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

Java NIO

同步非阻塞，服务实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器（也可以说是Selector选择器）上，多路复用器轮询到连接有IO请求就进行处理，如果没有请求是可以做其他事情的。

Java AIO（NIO.2）

异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的IO请求都是由OS先完成了再通知服务器应用去启动线程进行处理，一般适用于连接数较多且连接时间较长的应用

BIO、NIO、AIO的使用场景

BIO 适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中。JDK4以前的唯一选择，但是代码比较好理解

NIO 适用于链接数目较多且连接时长比较短（轻操作）的架构，比如聊天服务器、弹幕系统、服务器间通信等。编程比较复杂，JDK4开始出现

AIO 方式适用于连接山姆较多且连接时长较长（重操作）的架构，比如相册服务器、充分调用OS参与并发操作。编程比较复杂，JDK7开始出现。

BIO

1 BIO 基本介绍

Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.io

BIO 可以通过线程池进行改善

2 BIO 的工作机制

对 BIO 编程流程的梳理

  1. 服务器端启动一个 ServerSocket，注册端口，调用accpet方法监听客户端的Socket连接。
  2. 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户 建立一个线程与之通讯

在这里插入图片描述

3 BIO 传统通信实现

3.1 业务需求

客户端向服务器端发送一串文字

3.2 实现思路

客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户 建立一个线程与之通讯

服务器端启动一个 ServerSocket，注册端口，调用accpet方法监听客户端的Socket连接。

3.3 代码实现

客户端：

  1. 创建socket对象请求服务器连接
  2. 从socket对象中获取一个字节输出流
  3. 把字节流改装成自己需要的流进行数据的发送
  4. 开始发送消息
public class ClientBIO {
    public static void main(String[] args) throws IOException {
        //1、创建socket对象请求服务器连接
        Socket socket = new Socket("127.0.0.1", 9999);
        //2、从socket对象中获取一个字节输出流
        OutputStream os = socket.getOutputStream();
        //3、把字节流改装成自己需要的流进行数据的发送
        PrintStream ps = new PrintStream(os);
        //4、 开始发送消息
        ps.println("hello!");
        // 刷新流中可能存在或可能不存在的任何元素的流
        ps.flush();
    }
}

服务器端：

  1. 定义一个ServiceSocket对象进行服务端的端口注册
  2. 监听客户端的Socket连接请求，得到一个端到端的Socket管道
  3. 从Socket管道中得到一个字节输入流。
  4. 把字节输入流包装成一个缓冲字符输入流
  5. 读取缓冲流中的数据，如果缓冲流中还有数据，继续读取数据；如果缓冲流中没有数据
public class ServerBIO {
    public static void main(String[] args) {
        try {
            System.out.println("====服务器端启动了====");
            // 1 定义一个ServiceSocket对象进行服务端的端口注册
            ServerSocket ss = new ServerSocket(9999);
            // 2 监听客户端的Socket连接请求
            Socket socket = ss.accept();
            // 3 从Socket管道中得到一个自己输入流对象
            InputStream is = socket.getInputStream();
            // 4 把字节输入流包装成一个缓冲字符输入流，将字节输入流转为字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while ((msg = br.readLine())!=null) {
                System.out.println("服务器端接收到的："+ msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

这里代码有两个问题

第一个问题发生在客户端中。 这条代码 ps.print("hello!"); 传入到服务器中，就会出现 Connection reset 发生异常阻塞。原因如下：由于在服务器中，以行作为结束标记。因此 hello 在传入后并没有换行，于是 while 语句继续等待。此时客户端中，hello 语句发完后，客户端线程已经关闭，此时服务器端在监听是发现与客户端的socket连接断开，于是就发生了 Connection reset

第二个发生在服务器段中。当纠正了 ps.print("hello!"); 为 ps.println("hello!"); 后，传入到服务器中，由于客户端发送完毕后就断开了socket连接，而服务器端则在while中等待是否有下一条语句到来，此时监听到socket连接已经断开，就报异常。解决的方法是，将 while ((msg = br.readLine())!=null) 修改为 if ((msg = br.readLine())!=null)，也就是说，客户端如果只发送一次数据，那么服务器端也只接受一次。

4 BIO 模式下的多发和多收消息

4.1 业务需求

实现客户端可以反复发送消息和服务器端可以持续接收消息

4.2 实现思路

客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户 建立一个线程与之通讯。将输入数据和发送数据放在一个循环嵌套之中。

服务器端启动一个 ServerSocket，注册端口，调用accpet方法监听客户端的Socket连接。使用while持续监听，如果有数据进行数据，没有数据保持等待

4.3 代码实现

客户端：

  1. 创建socket对象请求服务器连接
  2. 从socket对象中获取一个字节输出流
  3. 把字节流改装成自己需要的流进行数据的发送
  4. 输入数据和发送数据放在一个循环嵌套之中
public class ClientBIO {
    public static void main(String[] args) throws IOException {
        //1、创建socket对象请求服务器连接
        Socket socket = new Socket("127.0.0.1", 9999);
        //2、从socket对象中获取一个字节输出流
        OutputStream os = socket.getOutputStream();
        //3、输出流包装成一个打印流
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while(true) {
            System.out.print("请说：");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}

服务器端：

  1. 定义一个ServiceSocket对象进行服务端的端口注册
  2. 监听客户端的Socket连接请求，得到一个端到端的Socket管道
  3. 从Socket管道中得到一个字节输入流。
  4. 把字节输入流包装成一个缓冲字符输入流
  5. 使用while持续监听，readLine()是一个阻塞函数,当没有数据读取时,就一直会阻塞在那，如果有数据进行数据，没有数据保持等待
public class ServerBIO {
    public static void main(String[] args) {

        try {
            System.out.println("====服务器端启动了====");
            // 1 定义一个ServiceSocket对象进行服务端的端口注册
            ServerSocket ss = new ServerSocket(9999);
            // 2 监听客户端的Socket连接请求
            Socket socket = ss.accept();
            // 3 从Socket管道中得到一个自己输入流对象
            InputStream is = socket.getInputStream();
            // 4 把字节输入流包装成一个缓冲字符输入流，将字节输入流转为字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while ((msg = br.readLine())!=null) {
                System.out.println("服务器端接收到的："+ msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5 BIO 模式下接收多个客户端

5.1 业务需求

服务端需要处理很多个客户端的消息通信请求，同时要求每个请求都需要一个对应的线程去实现请求
在这里插入图片描述

5.2 实现思路

客户端不需要变，但是在idea编译器中需要打开“allow multiple instances”

服务器端在循环中，启动对应的线程，线程里是解决方法

5.3 代码实现

客户端

public class ClientBIO {
    public static void main(String[] args) throws IOException {
        //1、创建socket对象请求服务器连接
        Socket socket = new Socket("127.0.0.1", 9999);
        //2、从socket对象中获取一个字节输出流
        OutputStream os = socket.getOutputStream();
        //3、输出流包装成一个打印流
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while(true) {
            System.out.print("请说：");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}

服务器端

public class ServerBIO {
    public static void main(String[] args) {
        try {
            System.out.println("====服务器端启动了====");
            // 1 定义一个ServiceSocket对象进行服务端的端口注册
            ServerSocket ss = new ServerSocket(9999);
            while (true) {
                Socket socket = ss.accept();
                new ServerThreadReader(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

对应线程

public class ServerThreadReader extends Thread{
    private Socket socket;
    public ServerThreadReader(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
         //3 从Socket管道中得到一个自己输入流对象
        try {
            InputStream is = socket.getInputStream();
            // 4 把字节输入流包装成一个缓冲字符输入流，将字节输入流转为字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while ((msg = br.readLine())!=null) {
                System.out.println("服务器端接收到的："+ msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

小结，其实就是把在服务器中的处理方法放到了线程中去处理

6 BIO伪异步IO编程

​ 在接受多个客户端时，存在这样一个问题：随着客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

​ 解决方案是，搭建伪异步I/O的通信框架。采用线程池和任务队列实现，当客户端接入时，将客户端的 Socket 封装成一个Task(该任务实现 java.lang.Runnable 线程任务接口)交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中Socket任务进行处理，由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。

6.1 业务需求

使用有限个线程去处理多个客户端的请求。

6.2 实现思路

客户端不变

增加一个线程池处理类

服务器端调用线程池处理类

写一个处理的线程

6.3 代码实现

客户端：

public class ClientBIO {
    public static void main(String[] args) throws IOException {
        //1、创建socket对象请求服务器连接
        Socket socket = new Socket("127.0.0.1", 9999);
        //2、从socket对象中获取一个字节输出流
        OutputStream os = socket.getOutputStream();
        //3、输出流包装成一个打印流
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while(true) {
            System.out.print("请说：");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}

线程池处理类：

// 线程池处理类
public class HandlerSocketThreadPool {
   
   // 线程池 
   private ExecutorService executor;
   
   public HandlerSocketThreadPool(int maxPoolSize, int queueSize){
      
      this.executor = new ThreadPoolExecutor(
            3, // 8
            maxPoolSize,  
            120L, 
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<Runnable>(queueSize) );
   }
   
   public void execute(Runnable task){
      this.executor.execute(task);
   }
}

服务器端：

public class Server {
   public static void main(String[] args) {
      try {
         System.out.println("----------服务端启动成功------------");
         ServerSocket ss = new ServerSocket(9999);

         // 一个服务端只需要对应一个线程池
         HandlerSocketThreadPool handlerSocketThreadPool =
               new HandlerSocketThreadPool(3, 1000);

         // 客户端可能有很多个
         while(true){
            Socket socket = ss.accept() ; // 阻塞式的！
            System.out.println("有人上线了！！");
            // 每次收到一个客户端的socket请求，都需要为这个客户端分配一个
            // 独立的线程 专门负责对这个客户端的通信！！
            handlerSocketThreadPool.execute(new ReaderClientRunnable(socket));
         }

      } catch (Exception e) {
         e.printStackTrace();
      }
   }

}

线程处理类：

class ReaderClientRunnable implements Runnable{

   private Socket socket ;

   public ReaderClientRunnable(Socket socket) {
      this.socket = socket;
   }

   @Override
   public void run() {
      try {
         // 读取一行数据
         InputStream is = socket.getInputStream() ;
         // 转成一个缓冲字符流
         Reader fr = new InputStreamReader(is);
         BufferedReader br = new BufferedReader(fr);
         // 一行一行的读取数据
         String line = null ;
         while((line = br.readLine())!=null){ // 阻塞式的！！
            System.out.println("服务端收到了数据："+line);
         }
      } catch (Exception e) {
         System.out.println("有人下线了");
      }

   }
}
  • 伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但由于底层依然是采用的同步阻塞模型，因此无法从根本上解决问题。
  • 如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的i/o消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量连接超时。

7 基于BIO形式下的文件上传

7.1 业务需求

支持任意类型文件形式的上传。

7.2 实现思路

客户端在原来的基础上，需要选择上传文件，然后添加缓冲池，因为考虑到文件可能过大

服务器端则需要选择保存的位置，然后从缓冲池中获取数据

7.3 代码实现

客户端：

public class Client {
    public static void main(String[] args) {
        try(
                InputStream is = new FileInputStream("‪E:\\note\\01-java\\img\\JavaBIO工作机制.png");
        ){
            //  1、请求与服务端的Socket链接
            Socket socket = new Socket("127.0.0.1" , 8888);
            //  2、把字节输出流包装成一个数据输出流
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            //  3、先发送上传文件的后缀给服务端
            dos.writeUTF(".png");
            //  4、把文件数据发送给服务端进行接收
            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer)) > 0 ){
                dos.write(buffer , 0 , len);
            }
            dos.flush();
            Thread.sleep(10000);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

服务器端：

public class Server {
    public static void main(String[] args) {
        try{
            ServerSocket ss = new ServerSocket(8888);
            while (true){
                Socket socket = ss.accept();
                // 交给一个独立的线程来处理与这个客户端的文件通信需求。
                new ServerReaderThread(socket).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

线程处理类：

public class ServerReaderThread extends Thread {
    private Socket socket;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try{
            // 1、得到一个数据输入流读取客户端发送过来的数据
            DataInputStream dis = new DataInputStream(socket.getInputStream());
            // 2、读取客户端发送过来的文件类型
            String suffix = dis.readUTF();
            System.out.println("服务端已经成功接收到了文件类型：" + suffix);
            // 3、定义一个字节输出管道负责把客户端发来的文件数据写出去
            OutputStream os = new FileOutputStream("‪E:\\note\\01-java\\server\\img\\"+
                    UUID.randomUUID().toString()+suffix);
            // 4、从数据输入流中读取文件数据，写出到字节输出流中去
            byte[] buffer = new byte[1024];
            int len;
            while((len = dis.read(buffer)) > 0){
                os.write(buffer,0, len);
            }
            os.close();
            System.out.println("服务端接收文件保存成功！");

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

客户端怎么发，服务端就怎么接收

学习渠道

黑马程序员NIO+BIO全套教程，Java教程之IO模式精讲

_之桐_
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析
01-04
IO模型决定了数据的传输方式，Java支持BIO，NIO，AIO三种IO模型。BIO是同步阻塞模型，特点是一对一的客户端与处理线程关系，适用场景是连接数量较小并且固定的，优点是编程简单，但对服务器资源要求高。NIO是同步非...
一文彻底理解Java中IO的BIO、NIO、AIO
最新发布
05-23
在Java的发展历程中，IO模型经历了三个主要阶段：BIO（Blocking IO）、NIO（Non-blocking IO）和AIO（Asynchronous IO），这三种模型各自有其特性和适用场景，下面将详细解析它们的工作原理和区别。 **1. BIO（阻塞...
Java基础BIO、NIO、AIO小结
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
10-25 850
BIO通信过程如下图所示，可以看到客户端成功与服务端建立连接后会因为等待服务端处理并响应结果而需要进行阻塞。而服务端在没有客户端发起请求时也会进入循环阻塞。并且服务端必须只有处理完这个请求后，才会去处理其他用户的请求。所以在高并发场景下，无论用户体验，还是服务器处理效率和压力都是灾难性的打击。
Java I/O大揭秘：BIO、NIO、AIO到底有何区别？
孤芳不自赏
06-22 546
这篇文章你值得一阅！讲技术我觉得应该让外行也能看明白，而不是一堆专业术语堆砌，像在读天书一般，到最后感觉云里雾里。
Netty之JavaBIO编程模型介绍
2401_84048338的博客
05-13 627
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
JAVA中BIO
爪哇人的博客
10-24 352
1 BIO基本介绍 BIO是就是传统的io编程，其相关的类和接口在Java.io BIO:同步阻塞，服务器实现模式为一个线程一个连接，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器) 2 BIO工作机制 3 同步阻塞案例 服务端代码： public class Server { /** * 客户端发送消息,服务端接收消息 *...
Java BIO 模型示例
qq_33471737的博客
12-11 489
Java BIO
深入探索Java BIO与NIO输入输出模型：基于文件复制和socket通信
码到三十五
02-02 1558
Java BIO和NIO是两种不同的I/O模型，它们在设计、工作原理和使用上有显著的区别。BIO是同步阻塞的I/O模型，它简单直接但性能有限；而NIO是同步非阻塞的I/O模型，它引入了多路复用器和缓冲区的概念，提高了系统的吞吐量和性能。在选择使用哪种模型时，需要根据具体的应用场景和需求进行权衡。如果并发连接数较少且对性能要求不高，可以选择使用BIO；如果并发连接数较多且对性能要求较高，可以选择使用NIO。
Java三种IO模型原理实例详解
08-19
"Java三种IO模型原理实例详解" Java中的IO模型可以分为三种：BIO（同步阻塞）、NIO（同步非...Java中的IO模型有三种：BIO、NIO和AIO，每种模型都有其特点和应用场景，选择合适的IO模型可以大大提高服务器端的性能。
JAVA IO的3种类型区别解析
08-25
JAVA IO的三种类型，即BIO（ Blocking IO）、NIO（Non-blocking IO）和AIO（Asynchronous IO），是Java中处理输入输出流的关键技术，它们各有特点，适应不同的应用场景。 1. **BIO（Blocking IO）** BIO是传统的IO...
javaIO模型1
08-08
Java IO模型1主要涉及到的是Java在处理网络数据交互时的不同方式。这里有五种主要的IO模型，它们分别是阻塞IO（BIO）、非阻塞IO、IO多路复用、信号量和异步IO（AIO）。理解这些模型的关键在于区分同步与异步以及阻塞...
Java中网络IO的实现方式（BIO、NIO、AIO）介绍
08-31
主要介绍了Java中网络IO的实现方式（BIO、NIO、AIO）介绍的相关资料,需要的朋友可以参考下
JAVA BIO AIO NIO测试代码
09-01
对java io总结时编写的测试代码，包括BIO,NIO,AIO的实现，Java io操作是编程人员经常使用到的，以前只是使用没有对这三种IO做系统的了解，本文将对这三种IO作详细的介绍并附有测试完整代码
Java -- 什么是BIO
ZeroWdd的博客
05-04 2123
Java – 什么是BIO 1. Java BIO 基本介绍 Java BIO 就是传统的java io编程， 其相关的类和接口在java.io。 BIO：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器)。 BIO 方式适用于连接数目比较小且固定的架...
Java BIO
了凡
11-24 230
Java BIO Java BIO指的是blocking I/O，同步并阻塞式的IO 同步vs异步 同步和异步关注的是消息通信机制 (synchronous communication/ asynchronous communication) 所谓同步，就是在发出一个调用时，在没有得到结果之前，该调用就不返回。但是一旦调用返回，就得到返回值了。换句话说，就是由调用者主动等待这个调用的结果。 而异步则是相反，调用在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不
day-2-1-1
haodi12138的博客
08-01 109
java初识输出输入流
BIO_java代码_测试demo
fudaolai的博客
11-22 308
一,客户端 public class BioClient { public static void main(String[] args) throws IOException { //创建客户端socket Socket socket = new Socket("127.0.0.1",9001); OutputStream outputStream = socket.getOutputStream(); PrintStrea
Java BIO编程
qq_45596525的博客
10-26 246
文章目录前言一、BIO、NIO、AIO基本概念二、BIO编程实例1. 简单流程2.编码3.如何使用CMD与服务器建立socket连接总结 前言 基于BIO的网络编程模型在大并发量下会浪费掉大量的I/O资源 , 基于Netty的网络编程方案则能较好的应对这一问题 提示：以下是本篇文章正文内容，下面案例可供参考 一、BIO、NIO、AIO基本概念 I/O模型就是使用什么样的通道进行数据的收发 Java支持三种网络编程的模型 : BIO,NIO,AIO BIO : 同步阻塞,传统的阻塞型 , 客户端发起连
java的BIO实现
张青山
06-25 1820
概述        该篇博客主要讲解BIO的使用，以及使用中存在一些问题。 单线程处理 package one; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; /** * BIO服务端 */ public
2024年Java常见的-BIO,NIO,AIO,Netty面试题
04-20
主要是介绍java方面网络方面 网络通信方面的面试题，核心内容主要是关于BIO,NIO,AIO,Netty的面试，算是一套八股文吧，还是老话，该背的还是要背一背！！！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_之桐_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值