Netty系列-NIO入门

最新推荐文章于 2020-06-23 10:33:38 发布
最新推荐文章于 2020-06-23 10:33:38 发布
阅读量510 收藏 1
点赞数
分类专栏： Java Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuchangqing123/article/details/53457785
版权
Java 同时被 2 个专栏收录
56 篇文章 0 订阅
订阅专栏
Netty
6 篇文章 0 订阅
订阅专栏

Netty封装了java的NIO实现了非阻塞NIO网络通信，大大提高了效率。为了更好的理解Netty中NIO的使用，还是需要对java的NIO回顾一下。


从普通的socket网络通信到使用NIO的方式实现，还是有很大差别的。最关键的区别是处理IO的线程是否是阻塞的，在下面的分析中就可以看得出来。

1）同步阻塞式的网络通信

2）伪异步IO

3）NIO实现


以下的程序演示的是客户端请求服务端拿到当前日期的功能。

1.先看第一种方式

在学习socket编程的时候应该写过这种通信方式，上代码

server端代码

package com.netty.server;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;

/**
 * Created by lcq on 12/4/2016.
 * 同步阻塞式IO
 */
public class TimeServer {
    public static void main(String[] args) throws IOException {
        int port = 8080;
        ServerSocket server = null;
        try {
            server = new ServerSocket(port);
            System.out.println("server is start in port:" + port);
            Socket socket = null;
            while (true){
                socket = server.accept();//等待客户端连接，如果没有连接则阻塞
                new Thread(new TimeServerHandler(socket)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(server != null){
                System.out.println("server is close");
                server.close();
                server = null;
            }
        }

    }
    private static class TimeServerHandler implements Runnable {
        private Socket socket;
        public TimeServerHandler(Socket socket) {
            this.socket = socket;
        }
        @Override
        public void run() {
            BufferedReader in = null;
            PrintWriter out = null;
            try {
                in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
                out = new PrintWriter(this.socket.getOutputStream(),true);
                String body = null;
                String currentTime = null;
                while (true){
                    body = in.readLine();
                    if(body == null){
                        break;
                    }
                    System.out.println("server receive order:" + body);
                    currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
                    out.println(currentTime);
                }
            } catch (IOException e) {
                if(in != null){
                    try {
                        in.close();
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                }
                if(out != null){
                    out.close();
                    out = null;
                }
                if(socket != null){
                    try {
                        socket.close();
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                }
            }
        }
    }
}

client端代码 

package com.netty.server;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * Created by lcq on 12/4/2016.
 * 阻塞时IO
 */
public class TimeClient {

    public static void main(String[] args) {
        int port = 8080;
        Socket socket = null;
        BufferedReader in = null;
        PrintWriter out = null;

        try {
            socket = new Socket("127.0.0.1",port);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(),true);
            out.println("QUERY TIME ORDER");
            System.out.println("send order succeed");
            String resp = in.readLine();
            System.out.println("Now is : " + resp);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(out != null){
                out.close();
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

运行结果 

server is start in port:8080
server receive order:QUERY TIME ORDER

send order succeed
Now is : Sun Dec 04 23:36:55 CST 2016

2.第二种伪异步IO 

package com.netty.server;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by lcq on 12/4/2016.
 * 伪造异步IO
 */
public class ForgeAsynTimeServer {
    public static void main(String[] args) throws IOException {
        int port = 8080;
        ServerSocket server = null;
        try {
            server = new ServerSocket(port);
            System.out.println("server is start in port:" + port);
            Socket socket = null;
            TimeServerHanlerExecutePool singleExecutor = new TimeServerHanlerExecutePool(50,10000);
            while (true){
                socket = server.accept();//等待客户端连接，如果没有连接则阻塞
                singleExecutor.execute(new TimeServerHandler(socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(server != null){
                System.out.println("server is close");
                server.close();
                server = null;
            }
        }

    }
    private static class TimeServerHanlerExecutePool {
        private ExecutorService executor;
        public TimeServerHanlerExecutePool(int maxPoolSize,int queueSize){
            executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),maxPoolSize,120L, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
        }
        public void execute(Runnable task){
            executor.execute(task);
        }
    }
    private static class TimeServerHandler implements Runnable {
        private Socket socket;
        public TimeServerHandler(Socket socket) {
            this.socket = socket;
        }
        @Override
        public void run() {
            BufferedReader in = null;
            PrintWriter out = null;
            try {
                in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
                out = new PrintWriter(this.socket.getOutputStream(),true);
                String body = null;
                String currentTime = null;
                while (true){
                    body = in.readLine();
                    if(body == null){
                        break;
                    }
                    System.out.println("server receive order:" + body);
                    currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
                    out.println(currentTime);
                }
            } catch (IOException e) {
                if(in != null){
                    try {
                        in.close();
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                }
                if(out != null){
                    out.close();
                    out = null;
                }
                if(socket != null){
                    try {
                        socket.close();
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                }
            }
        }
    }


}
客户端的代码不变，结果输出同上。

从代码逻辑可以看出，相比第一种只是使用了线程池去处理IO事件，其实并没有真正解决读和写还是同步阻塞的问题，当连接数比较多的时候还是效率比较低。


3.NIO实现

package com.netty.server;

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.Date;
import java.util.Iterator;
import java.util.Set;

/**
 * Created by lcq on 12/4/2016.
 * NIO时间服务器
 */
public class NIOTimeServer {
    public static void main(String[] args) {
        int port = 8080;
        MultiplexerTimeServer timeServer = new MultiplexerTimeServer(port);
        new Thread(timeServer,"NIO-MutiplexerTimeServer-001").start();
    }

    private static class MultiplexerTimeServer implements Runnable{
        private Selector selector;
        private ServerSocketChannel serverSocketChannel;
        private volatile boolean stop;
        public MultiplexerTimeServer(int port) {
            try {
                selector = Selector.open();//创建多路复用器
                serverSocketChannel = ServerSocketChannel.open();//
                serverSocketChannel.configureBlocking(false);
                serverSocketChannel.socket().bind(new InetSocketAddress(port), 1024);
                serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
                System.out.println("server is start in port:" + port);
            } catch (IOException e) {
                e.printStackTrace();
                System.exit(1);
            }

        }

        public void stop(){
            this.stop = true;
        }

        @Override
        public void run() {
            while(!stop){
                try {
                    selector.select(1000);
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    Iterator<SelectionKey> iterator = selectionKeys.iterator();
                    SelectionKey key = null;
                    while(iterator.hasNext()){
                        key = iterator.next();
                        iterator.remove();
                        try {
                            handleInput(key);
                        }catch (Exception e){
                            if(key != null){
                                key.cancel();
                                if(key.channel() != null){
                                    key.channel().close();
                                }
                            }
                        }

                    }
                } catch (Throwable t) {
                    t.printStackTrace();
                }
            }

            if(selector != null){
                try {
                    selector.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        private void handleInput(SelectionKey key) throws IOException {
            if(key.isValid()){
                //处理请求消息
                if(key.isAcceptable()){
                    ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                    SocketChannel sc = ssc.accept();
                    sc.configureBlocking(false);
                    sc.register(selector,SelectionKey.OP_READ);
                }
                if(key.isReadable()){
                    SocketChannel sc = (SocketChannel) key.channel();
                    ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                    int readBytes = sc.read(readBuffer);
                    if(readBytes > 0){
                        readBuffer.flip();//缓冲区由写模式转换为读模式
                        byte[] bytes = new byte[readBuffer.remaining()];
                        readBuffer.get(bytes);
                        String body = new String(bytes,"UTF-8");
                        System.out.println("time server order:" + body);
                        String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
                        doWrite(sc,currentTime);
                    }else if(readBytes < 0){
                        //对端链路关闭
                        key.cancel();
                        sc.close();
                    }else{
                        //读到0个字节
                    }
                }
            }
        }

        private void doWrite(SocketChannel sc, String currentTime) throws IOException {
            if(currentTime != null && currentTime.trim().length() > 0){
                byte[] bytes = currentTime.getBytes();
                ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
                writeBuffer.put(bytes);
                writeBuffer.flip();
                sc.write(writeBuffer);
            }
        }
    }
}


package com.netty.server;

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.SocketChannel;
import java.util.Iterator;
import java.util.Set;

/**
 * Created by lcq on 12/4/2016.
 * NIO
 */
public class NIOTimeClient {
    public static void main(String[] args) {
        int port = 8080;
        new Thread(new TimeClientHandler("127.0.0.1",port),"TimeClient-001").start();
    }

    private static class TimeClientHandler implements Runnable {
        private String host;
        private int port;
        private Selector selector;
        private SocketChannel socketChannel;
        private volatile boolean stop;
        public TimeClientHandler(String host, int port) {
            this.host = host == null ? "127.0.0.1":host;
            this.port = port;
            try {
                selector = Selector.open();
                socketChannel = SocketChannel.open();
                socketChannel.configureBlocking(false);
            } catch (IOException e) {
                e.printStackTrace();
                System.exit(1);
            }
        }

        @Override
        public void run() {
            try {
                doConnect();
            } catch (IOException e) {
                e.printStackTrace();
                System.exit(1);
            }

            while (!stop){
                try {
                    selector.select(1000);
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    Iterator<SelectionKey> iterator = selectionKeys.iterator();
                    SelectionKey key = null;
                    while(iterator.hasNext()){
                        key = iterator.next();
                        iterator.remove();
                        try {
                            handleInput(key);
                        }catch (Exception e){
                            if(key != null){
                                key.cancel();
                                if(key.channel() != null){
                                    key.channel().close();
                                }
                            }
                        }

                    }
                } catch (Throwable t) {
                    t.printStackTrace();
                }

            }

            if(selector != null){
                try {
                    selector.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        private void handleInput(SelectionKey key) throws IOException {
            if(key.isValid()){
                SocketChannel sc = (SocketChannel) key.channel();
                //判断连接是否成功
                if(key.isConnectable()){
                    if(sc.finishConnect()){
                        sc.register(selector,SelectionKey.OP_READ);
                        doWrite(sc);
                    }else{
                        System.exit(1);
                    }
                }
                if(key.isReadable()){
                    ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                    int readBytes = sc.read(readBuffer);
                    if(readBytes > 0){
                        readBuffer.flip();//缓冲区由写模式转换为读模式
                        byte[] bytes = new byte[readBuffer.remaining()];
                        readBuffer.get(bytes);
                        String body = new String(bytes,"UTF-8");
                        System.out.println("Now is :" + body);
                        this.stop = true;
                    }else if(readBytes < 0){
                        //对端链路关闭
                        key.cancel();
                        sc.close();
                    }else{
                        //读到0个字节
                    }
                }
            }
        }
        private void doConnect() throws IOException {
            if(socketChannel.connect(new InetSocketAddress(host,port))){
                socketChannel.register(selector, SelectionKey.OP_READ);
                doWrite(socketChannel);
            }else{
                socketChannel.register(selector,SelectionKey.OP_CONNECT);
            }
        }

        private void doWrite(SocketChannel socketChannel) throws IOException {
            byte[] req = "QUERY TIME ORDER".getBytes();
            ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
            writeBuffer.put(req);
            writeBuffer.flip();
            socketChannel.write(writeBuffer);
            if(!writeBuffer.hasRemaining()){//判断消息是否发送完成
                System.out.println("send order succeed");
            }
        }
    }
}

其中关键的步骤是使用了异步非阻塞的处理方式，如何实现的呢？是selector多路复用器发挥的作用。多路复用的核心就是通过Selector来轮询注册在其上的Channel，当发现某个或者多个Channel处于就绪状态后，从阻塞状态返回就绪的Channel的选择键集合，进行IO操作。

为了方便理解，借用Netty权威指南中的截图说明下程序调用流程









liuchangqing123
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty与NIO
qq_30118563的博客
05-12 5218
Linux的 网络IO 一、简介 1、Linux上所有外部设备都抽象为file。 2、对一个文件的读写会调用kernel命令，返回file descriptor (fd)； 3、对一个socket的读写会调用kernel命令，返回socketfd 4、描述符实际就是一个数字，指向内核中一个结构体（文件路径、数据区等一些属性） 二、Linux 对Socket IO模型的抽象 ...
Netty之NIO基础
qq_36781386的博客
09-03 138
Netty入门前NIO基本概念介绍
Netty-NIO 详解、说明、优缺
wmburst
06-23 417
Liunx IO模型 1、阻塞IO模型 2、非阻塞IO模型 3、IO复用 4、信号驱动式IO 5、异步IO Liunx IO流程 等待数据准备好 从内核向进程复制数据 阻塞IO模式 非阻塞式IO模型 复用IO模型 信号驱动式I/O模型 异步I/O模型 各种I/O模型的比较 同步、异步 同步I/O操作：导致请求进程阻塞，直到I/O操作完成。 异步I/O操作：不导致请求进程阻塞。 Blocking I/O package demo07; import java.io.BufferedReade
Netty（一）
qq_34800986的博客
12-27 240
Netty介绍 Netty是由JBOSS提供的一个java开源框架，现为Github上独立的项目。 一个异步事件驱动的网络应用程序框架，用于快速开发高性能、高可靠性的IO网络框架。 Netty主要针对在TCP协议下，面向Clients端的高并发应用，或者Peer-to-Peer场景下的大量数据传输的应用 Netty本质是一个NIO框架，适用于服务器通讯的相关业务场景 Netty 的应用场景 ...
探秘Netty2：Netty与Java NIO
Java技术江湖
06-20 5352
Netty与Java NIO的渊源 netty是什么     Netty是一个基于Java NIO的client-server网络服务框架，人们可以利用netty快速地开发网络应用。同时netty相对于其他网络框架更加简单并且扩展性更强，这主要得益于其提供的简单易用的api将业务逻辑和网络处理代码解耦开来。能够使你更加专注于业务的实现而不需要太多关心网络底层实现。 异步设计     ...
Netty大纲-同步netty专栏
07-07
Netty 底层基于 NIO（非阻塞I/O）库，允许开发者创建高效的并发服务器，同时处理大量并发连接。本文将深入探讨Netty的基础、进阶特性以及优化策略。 1. **NIO基础** - **三大组件**：在Java NIO中，主要包括`...
Netty 快速入门系列-源码
03-26
Netty快速入门系列源码， 参考 https://blog.csdn.net/netcobol Netty是一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。 Netty是...
掘金-Netty 入门与实战-netty-demo.zip
最新发布
01-30
这个压缩包“掘金-Netty 入门与实战-netty-demo.zip”包含了关于 Netty 的入门教程和实战示例，特别是通过 "netty-demo-pipeline-channelHandler" 这个文件名我们可以推测，它可能包含了一个展示 Netty ...
netty入门与实战-netty-learn.zip
01-29
这个“netty入门与实战-netty-learn.zip”文件包含了学习 Netty 的资源，帮助初学者理解并掌握这个强大的网络库。Netty-learn-master 可能是一个包含源代码、教程文档或者示例项目的目录。 Netty 的核心概念： 1. ...
Netty-讲义.zip
10-09
这个“Netty 讲义.zip”压缩包包含了一系列关于 Netty 的学习资料，主要分为四个部分：入门、进阶、NIO 和优化与源码分析。 首先，我们来探讨 Netty 的入门知识。`Netty02-入门.md` 可能会涵盖以下内容：Netty 的...
nio框架netty在项目中的应用
热门推荐
不断出发，永无抵达！
05-04 1万+
背景: 省分短信发送每天都差不多要1000W条上下,遇到特殊节假日和政府通告时量会更大!boss系统中存放的是短信发送内容,而真正完成发送短信指令动作是的华为方做的短厅,这么大的通信量选择了netty来完成数据传输并自定义了一套基于netty的SGIP协议进行通信; 省分boss系统—>短信营业厅(); 基本知识 2.1 TCP/IP网络协议 网上很多有关这个协议的解释,自行googl
从bio到nio到netty实现原理浅析
嘎嘎的博客
06-24 8783
今天记录一下这一块的演变历史~~
对Netty和NIO的基础熟悉
点点的博客
06-13 3765
RPC：远程调用过程，通过网络远程计算机的进程某一个方法，从而获取想要的数据，过程也如同本地调用一样。 阻塞IO：当阻塞IO调用inputStream.read()方法是阻塞的，一直等到数据到来时才返回，同样ServerScoket.accpt()方法时，也是阻塞，直到客户端连接才返回。 缺点：当客户端多时，才创建大量的处理线程，并且每一个线程分配一定的资源；阻塞可能打来频繁切换上下文，引...
Java中的NIO与Netty框架
Hopefully Sky的博客
12-16 5845
前言　　随着移动互联网的爆发性增长，小明公司的电子商务系统访问量越来越大，由于现有系统是个单体的巨型应用，已经无法满足海量的并发请求，拆分势在必行。 　　在微服务的大潮之中， 架构师通常会把系统拆分成了多个服务，根据需要部署在多个机器上，这些服务非常灵活，可以随着访问量弹性扩展。 　　世界上没有免费的午餐， 拆分成多个“微服务”以后虽然增加了弹性，但也带来了一个巨大的挑战：各个服务之间互相调用的开销
Java NIO框架Netty教程(十四)-Netty中OIO模型(对比NIO)
11-15 1177
OneCoder这个周末搬家，并且新家目前还没有网络，本周的翻译的任务尚未完成，下周一起补上，先上一篇OIO和NIO对比的小研究。 Netty中不光支持了Java中NIO模型，同时也提供了对OIO模型的支持。（New IO vs Old IO）。 首先，在Netty中，切换OIO和NIO两种模式是非常方便的，只需要初始化不同的Channel工程即可。 ?
设计模式——责任链
长青树呀
03-23 8581
责任链模式（Chain of Responsibility）的目标是使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。 在处理用户的请求时可能要根据不同的情况对请求添加不同的处理逻辑，在这时候就可以利用责任链进行设计。当需要添加一个处理逻辑时可以很方便的添加一个处理的节点。 现在我们的需求是处理用户的请
对接alipay支付遇到的问题
长青树呀
11-21 7715
在支付宝支付接入过程中遇到几个需要注意和理解的地方，记录一下。相比微信支付，支付宝流程上感觉还是简单不少，网上和官方给的文档和demo还是很全的。在我的支付逻辑中包括：发起支付请求、用户支付、支付通知（支付成功后自动发货）、订单状态更新。 以下是几个问题： 1）.支付完成后同步通知和异步通知区别，有问题就要去好好看看支付宝文档（https://cshall.alipay.com/support
Red5的安装配置以及AS3连接red5简单示例
长青树呀
11-13 7502
近来做一个有关视频会议系统的项目，用到了Red5做服务器端，AS搭建客户端，从网上找了些材料，可是资源真是少的可怜。好不容易找到一个但是遇到不少问题，还好纠结半天终于解决了。 以下是找到的资料： Windows环境下+配置+运行red5源码 Red5发展很快，目前最新版本为0.9.1，与以前的版本(0.8.+、0.7.+、0.6.+)差别很大，中文资料奇缺，鉴于此，我写下这篇文章，希望能帮上
java学习之路——基于UDP的Socket网络通信实例
长青树呀
10-06 6392
1： UDP协议的工作原理 UDP协议是一个面向无连接的协议。其连接的建立不必像TCP那样需要服务器端侦听，也不需要有客户机请求连接，属于一种“强制”性的网络连接。UDP提供一对一或一对多的、无连接的数据报服务。该服务对消息中传输的数据提供不可靠的、最大努力的传送，这意味着它不
NettyInAction中文版.docx
12-27
Netty是基于Java NIO的网络应用框架，如果你是Java网络方面的新手，那么本章将是你学习Java网络应用的开始；对于有经验的开发者来说，学习本章内容也是很好的复习。如果你熟悉NIO和NIO2，你可以随时跳过本章直接从第二章开始学习。在你的机器上运行第二章编写的Netty服务器和客户端。 Netty是一个NIO client-server(客户端服务器)框架，使用Netty可以快速开发网络应用，例如服务器和客户端协议。Netty提供了一种新的方式来使开发网络应用程序，这种新的方式使得它很容易使用和有很强的扩展性。Netty的内部实现时很复杂的，但是Netty提供了简单易用的api从网络处理代码中解耦业务逻辑。Netty是完全基于NIO实现的，所以整个Netty都是异步的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值