netty BIO、NIO、AIO简单例子

最新推荐文章于 2024-07-15 03:19:05 发布
最新推荐文章于 2024-07-15 03:19:05 发布
阅读量187 收藏
点赞数
分类专栏： socket 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_35418518/article/details/90202252
版权

socket

套接字分4个部分
1、服务器监听
2、客户端发起请求
3、服务器确认
4、客户端确认

 

BIO

同步阻塞

public class Server {

	final static int PORT = 8765;

	public static void main(String[] args) {
		ServerSocket server = null;
		BufferedReader in = null;
		PrintWriter out = null;
		try {
			server = new ServerSocket(PORT);
			System.out.println("server start");
			Socket socket = null;
            //这里是自定义了一个线程池
			HandlerExecutorPool executorPool = new HandlerExecutorPool(50, 1000);
			while(true){
				socket = server.accept();
				executorPool.execute(new ServerHandler(socket));
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(in != null){
				try {
					in.close();
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}
			if(out != null){
				try {
					out.close();
				} catch (Exception e2) {
					e2.printStackTrace();
				}
			}
			if(server != null){
				try {
					server.close();
				} catch (Exception e3) {
					e3.printStackTrace();
				}
			}
			server = null;				
		}
	}
}
public class Client {
	
	final static String ADDRESS = "127.0.0.1";
	final static int PORT =8765;
	
	public static void main(String[] args) {
		Socket socket = null;
		BufferedReader in = null;
		PrintWriter out = null;
		try {
			socket = new Socket(ADDRESS, PORT);
			in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			out = new PrintWriter(socket.getOutputStream(), true);
			
			out.println("Client request");
			String response = in.readLine();
			System.out.println("Client:" + response);
		}  catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if(in != null){
				try {
					in.close();
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}
			if(out != null){
				try {
					out.close();
				} catch (Exception e2) {
					e2.printStackTrace();
				}
			}
			if(socket != null){
				try {
					socket.close();
				} catch (Exception e3) {
					e3.printStackTrace();
				}
			}
			socket = null;				
		}
	}
}
public class ServerHandler implements Runnable {

	private Socket socket;
	public ServerHandler (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;
			while(true){
				body = in.readLine();
				if(body == null) break;
				System.out.println("Server:" + body);
				out.println("Server response");
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(in != null){
				try {
					in.close();
				} catch (Exception e1) {
					e1.printStackTrace();
				}
			}
			if(out != null){
				try {
					out.close();
				} catch (Exception e2) {
					e2.printStackTrace();
				}
			}
			if(socket != null){
				try {
					socket.close();
				} catch (Exception e3) {
					e3.printStackTrace();
				}
			}
			socket = null;			
		}
	}
}

NIO

public class Server implements Runnable{
	//1 多路复用器（管理所有的通道）
	private Selector seletor;
	//2 建立缓冲区
	private ByteBuffer readBuf = ByteBuffer.allocate(1024);
	//3 
	private ByteBuffer writeBuf = ByteBuffer.allocate(1024);

	public Server(int port){
		try {
			//1 打开路复用器
			this.seletor = Selector.open();
			//2 打开服务器通道
			ServerSocketChannel ssc = ServerSocketChannel.open();
			//3 设置服务器通道为非阻塞模式
			ssc.configureBlocking(false);
			//4 绑定地址
			ssc.bind(new InetSocketAddress(port));
			//5 把服务器通道注册到多路复用器上，并且监听阻塞事件
			ssc.register(this.seletor, SelectionKey.OP_ACCEPT);
			
			System.out.println("Server start, port :" + port);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void run() {
		while(true){
			try {
				//1 必须要让多路复用器开始监听
				this.seletor.select();
				//2 返回多路复用器已经选择的结果集
				Iterator<SelectionKey> keys = this.seletor.selectedKeys().iterator();
				//3 进行遍历
				while(keys.hasNext()){
					//4 获取一个选择的元素
					SelectionKey key = keys.next();
					//5 直接从容器中移除就可以了
					keys.remove();
					//6 如果是有效的
					if(key.isValid()){
						//7 如果为阻塞状态
						if(key.isAcceptable()){
							this.accept(key);
						}
						//8 如果为可读状态
						if(key.isReadable()){
							this.read(key);
						}
						//9 写数据
						if(key.isWritable()){
							//this.write(key); //ssc
						}
					}
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	private void write(SelectionKey key){
		//ServerSocketChannel ssc =  (ServerSocketChannel) key.channel();
		//ssc.register(this.seletor, SelectionKey.OP_WRITE);
	}

	private void read(SelectionKey key) {
		try {
			//1 清空缓冲区旧的数据
			this.readBuf.clear();
			//2 获取之前注册的socket通道对象
			SocketChannel sc = (SocketChannel) key.channel();
			//3 读取数据
			int count = sc.read(this.readBuf);
			//4 如果没有数据
			if(count == -1){
				key.channel().close();
				key.cancel();
				return;
			}
			//5 有数据则进行读取 读取之前需要进行复位方法(把position 和limit进行复位)
			this.readBuf.flip();
			//6 根据缓冲区的数据长度创建相应大小的byte数组，接收缓冲区的数据
			byte[] bytes = new byte[this.readBuf.remaining()];
			//7 接收缓冲区数据
			this.readBuf.get(bytes);
			//8 打印结果
			String body = new String(bytes).trim();
			System.out.println("Server : " + body);
			// 9..可以写回给客户端数据
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}

	private void accept(SelectionKey key) {
		try {
			//1 获取服务通道
			ServerSocketChannel ssc =  (ServerSocketChannel) key.channel();
			//2 执行阻塞方法
			SocketChannel sc = ssc.accept();
			//3 设置阻塞模式
			sc.configureBlocking(false);
			//4 注册到多路复用器上，并设置读取标识
			sc.register(this.seletor, SelectionKey.OP_READ);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		new Thread(new Server(8765)).start();
	}
}
public class Client {

	//需要一个Selector 
	public static void main(String[] args) {
		
		//创建连接的地址
		InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8765);
		//声明连接通道
		SocketChannel sc = null;
		//建立缓冲区
		ByteBuffer buf = ByteBuffer.allocate(1024);
		
		try {
			//打开通道
			sc = SocketChannel.open();
			//进行连接
			sc.connect(address);
			while(true){
				//定义一个字节数组，然后使用系统录入功能：
				byte[] bytes = new byte[1024];
				System.in.read(bytes);
				
				//把数据放到缓冲区中
				buf.put(bytes);
				//对缓冲区进行复位
				buf.flip();
				//写出数据
				sc.write(buf);
				//清空缓冲区数据
				buf.clear();
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(sc != null){
				try {
					sc.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
	}
	
}

JAVA 中jdk Buffer使用

	public static void main(String[] args) {
		// 1 基本操作
		//创建指定长度的缓冲区
		IntBuffer buf = IntBuffer.allocate(10);
		buf.put(13);// position位置：0 - > 1
		buf.put(21);// position位置：1 - > 2
		buf.put(35);// position位置：2 - > 3
		//把位置复位为0，也就是position位置：3 - > 0
		buf.flip();
		System.out.println("使用flip复位：" + buf);
		System.out.println("容量为: " + buf.capacity());	//容量一旦初始化后不允许改变（warp方法包裹数组除外）
		System.out.println("限制为: " + buf.limit());		//由于只装载了三个元素,所以可读取或者操作的元素为3 则limit=3
		
		
		System.out.println("获取下标为1的元素：" + buf.get(1));
		System.out.println("get(index)方法，position位置不改变：" + buf);
		buf.put(1, 4);
		System.out.println("put(index, change)方法，position位置不变：" + buf);;
		
		for (int i = 0; i < buf.limit(); i++) {
			//调用get方法会使其缓冲区位置（position）向后递增一位
			System.out.print(buf.get() + "\t");
		}
		System.out.println("buf对象遍历之后为: " + buf);
		
		
		// 2 wrap方法使用
		/**
		//  wrap方法会包裹一个数组: 一般这种用法不会先初始化缓存对象的长度，因为没有意义，最后还会被wrap所包裹的数组覆盖掉。 
		//  并且wrap方法修改缓冲区对象的时候，数组本身也会跟着发生变化。                     
		int[] arr = new int[]{1,2,5};
		IntBuffer buf1 = IntBuffer.wrap(arr);
		System.out.println(buf1);
		
		IntBuffer buf2 = IntBuffer.wrap(arr, 0 , 2);
		//这样使用表示容量为数组arr的长度，但是可操作的元素只有实际进入缓存区的元素长度
		System.out.println(buf2);
		*/
		
		
		// 3 其他方法
		/**
		IntBuffer buf1 = IntBuffer.allocate(10);
		int[] arr = new int[]{1,2,5};
		buf1.put(arr);
		System.out.println(buf1);
		//一种复制方法
		IntBuffer buf3 = buf1.duplicate();
		System.out.println(buf3);
		
		//设置buf1的位置属性
		//buf1.position(0);
		buf1.flip();
		System.out.println(buf1);
		
		System.out.println("可读数据为：" + buf1.remaining());
		
		int[] arr2 = new int[buf1.remaining()];
		//将缓冲区数据放入arr2数组中去
		buf1.get(arr2);
		for(int i : arr2){
			System.out.print(Integer.toString(i) + ",");
		}
		*/
	}

AIO

public class Server {
	//线程池
	private ExecutorService executorService;
	//线程组
	private AsynchronousChannelGroup threadGroup;
	//服务器通道
	public AsynchronousServerSocketChannel assc;
	
	public Server(int port){
		try {
			//创建一个缓存池
			executorService = Executors.newCachedThreadPool();
			//创建线程组
			threadGroup = AsynchronousChannelGroup.withCachedThreadPool(executorService, 1);
			//创建服务器通道
			assc = AsynchronousServerSocketChannel.open(threadGroup);
			//进行绑定socket连接信息
			assc.bind(new InetSocketAddress(port));
			
			System.out.println("server start , port : " + port);
			//进行阻塞
			assc.accept(this, new ServerCompletionHandler());
			//一直阻塞 不让服务器停止
			Thread.sleep(Integer.MAX_VALUE);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		Server server = new Server(8765);
	}
	
}
public class Client implements Runnable{

	private AsynchronousSocketChannel asc ;
	
	public Client() throws Exception {
		asc = AsynchronousSocketChannel.open();
	}
	
	public void connect(){
		asc.connect(new InetSocketAddress("127.0.0.1", 8765));
	}
	
	public void write(String request){
		try {
			asc.write(ByteBuffer.wrap(request.getBytes())).get();
			read();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void read() {
		ByteBuffer buf = ByteBuffer.allocate(1024);
		try {
			asc.read(buf).get();
			buf.flip();
			byte[] respByte = new byte[buf.remaining()];
			buf.get(respByte);
			System.out.println(new String(respByte,"utf-8").trim());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	public void run() {
		while(true){
		}
	}
	
	public static void main(String[] args) throws Exception {
		Client c1 = new Client();
		c1.connect();
		
		Client c2 = new Client();
		c2.connect();
		
		Client c3 = new Client();
		c3.connect();
		
		new Thread(c1, "c1").start();
		new Thread(c2, "c2").start();
		new Thread(c3, "c3").start();
		
		Thread.sleep(1000);
		
		c1.write("c1 aaa");
		c2.write("c2 bbbb");
		c3.write("c3 ccccc");
	}
	
}
public class ServerCompletionHandler implements CompletionHandler<AsynchronousSocketChannel, Server> {

	@Override
	public void completed(AsynchronousSocketChannel asc, Server attachment) {
		//当有下一个客户端接入的时候 直接调用Server的accept方法，这样反复执行下去，保证多个客户端都可以阻塞
		attachment.assc.accept(attachment, this);
		read(asc);
	}

	private void read(final AsynchronousSocketChannel asc) {
		//读取数据
		ByteBuffer buf = ByteBuffer.allocate(1024);
		asc.read(buf, buf, new CompletionHandler<Integer, ByteBuffer>() {
			@Override
			public void completed(Integer resultSize, ByteBuffer attachment) {
				//进行读取之后,重置标识位
				attachment.flip();
				//获得读取的字节数
				System.out.println("Server -> " + "收到客户端的数据长度为:" + resultSize);
				//获取读取的数据
				String resultData = new String(attachment.array()).trim();
				System.out.println("Server -> " + "收到客户端的数据信息为:" + resultData);
				String response = "服务器响应, 收到了客户端发来的数据: " + resultData;
				write(asc, response);
			}
			@Override
			public void failed(Throwable exc, ByteBuffer attachment) {
				exc.printStackTrace();
			}
		});
	}
	
	private void write(AsynchronousSocketChannel asc, String response) {
		try {
			ByteBuffer buf = ByteBuffer.allocate(1024);
			buf.put(response.getBytes());
			buf.flip();
			asc.write(buf).get();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	public void failed(Throwable exc, Server attachment) {
		exc.printStackTrace();
	}

}

 

JAVA BIO、NIO、AIO详解（附代码实现）以及Netty的简介
诺浅的专栏
05-08 2123
这几天在看面试的东西，可能是自己比较笨，花了快两天的时间才理清楚。特此记录一下。 首先我们要理解的一个很重要概念是，客户端连接和传送数据是分开的，连接不代表立马会传输数据。 说说BIO,NIO,AIO到底是什么东西 BIO：同步堵塞 NIO：异步堵塞 AIO：异步非堵塞 看到这里你肯定一脸懵逼，这到底是什么意思，别急，慢慢看。 在JAVA里面IO分两块，一块是操作文件的，一块是操作网...
Java Netty 分布式开发 框架
09-24
做Java开发，现在很多场合需要分布式应用，很多通信框架的底层实现都包含Netty技术，为了更好了解，值得有兴趣的人研究一下
ews java api netty_JavaNetty - osc_u95efnwn的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_33418394的博客
02-13 159
Netty的简单使用： import io.netty.bootstrap.Bootstrap;import io.netty.buffer.Unpooled;import io.netty.channel.ChannelFuture;import io.netty.channel.ChannelInitializer;import io.netty.channel.EventLoopG...
Java-Netty(入门)
weixin_45203607的博客
12-01 4761
i/o 种类Netty是什么？Netty是一个基于Java NIO的网络编程框架，提供了一套高效的、事件驱动的异步网络通信机制。简化了网络应用程序的开发过程，提供了可靠的、高性能的网络传输。Netty的特点是什么？异步和事件驱动：Netty使用异步的、非阻塞的I/O模型，通过事件驱动的方式处理网络操作。Netty能够高效地处理并发连接和大量的并发请求。高性能：Netty采用了一系列优化策略，如零拷贝技术、内存池和可定制的线程模型等，以提供出色的性能和吞吐量。能处理高负载和大规模并发。
java - （一）netty
saienenen的博客
12-23 669
1.Netty 简介 Netty 是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。 JDK 原生 NIO 程序的问题 JDK 原生也有一套网络应用程序 API，但是存在一系列问题，主要如下： NIO 的类库和 API 繁杂，使用麻烦。你需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、ByteBuffer 等。 需要具备其他的额外技能做铺垫。例如熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor 模
java netty
sdmanooo的专栏
12-23 389
netty基于NIO对其进行了一系列的封装改造。 这里主要介绍基于服务端的netty开发，客户端其实跟服务端差不多，当然客户端也可以直接使用socket与netty服务端通讯。 在netty开发中，我觉得比较关键的对象有： 1、EventLoopGroup 对于NIO来讲，其实现类就是NioEventLoopGroup。这个就相当于线程池，用来处理事件。 对于服务端，需要有两个NioEventLoopGroup对象，一个是parentGroup，用来处理accept，称之为acceptor；另一.
【Netty系列】Netty/BIO/NIO/AIO
Love Peace
04-19 1240
Netty是一个开源的异步的事件驱动的网络应用框架，用于快速开发高性能的网络服务器和客户端。它主要用于构建可伸缩的网络应用程序，如协议服务器和客户端。Netty的设计目标是提供一个简单、快速、稳定的网络应用程序框架，同时保持灵活性和可扩展性。Netty基于NIO（非阻塞I/O）的事件驱动模型，使用了高效的线程池和优化的内存分配机制，使得它在处理大量并发连接时表现出色。Netty广泛用于构建各种类型的网络应用，包括Web服务器、游戏服务器、即时通讯系统等。
BIO、NIO、AIO、Netty 、TCP全网最全解析！Netty中提供了哪些线程模型？
10-07
本文将深入探讨BIO（ Blocking I/O）、NIO（Non-blocking I/O）、AIO（Asynchronous I/O）以及Netty框架中的线程模型，并与TCP网络协议相结合，为您提供全网最全面的解析。 首先，让我们从基础开始，了解这些I/O...
Netty学习基础：BIO、NIO、AIO
04-17 716
其实我的重点呢，是来和大家一起学习接下来的Netty篇 然而嘞，这个Netty又不太合适直接讲，为啥呢，我们学习一门技术必须知道这门技术的由来的初衷是啥，对吧 先来给大家简单的介绍一下Netty是什么 Netty是一个提供异步事件驱动的网络应用程序框架，用以快速开发高性能、高可靠的网络服务器和客户端程序 Netty简化了网络程序的开发，属于BIO、NIO、AIO的演变中的产物，属于一种NIO框架 在我们平时使用的很多中间件中，很多底层通信都是采用的Netty，比如rocketmq、dubbo，这些我们最常见
2024年Java常见的-BIO,NIO,AIO,Netty面试题
04-20
### 2024年Java常见BIO、NIO、AIO、Netty面试题解析 #### 一、基础知识概述 1. **IO概念**： - Java中的I/O（Input/Output）指的是输入输出操作，它以流为基础进行数据的输入输出。所有的数据在Java中都是以流的...
Java网络编程 -- Netty入门
baijiyuan9594的博客
09-10 303
Netty简介 Netty是一个高性能，高可扩展性的异步事件驱动的网络应用程序框架，它极大的简化了TCP和UDP客户端和服务器端网络开发。它是一个NIO框架，对Java NIO进行了良好的封装。作为一个异步NIO框架，Netty的所有IO操作都是异步非阻塞的，通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。 Netty的特性 ...
java用netty
最新发布
weixin_41000016的博客
07-15 150
如何实现Java使用Netty 概述 在本文中，我将向您介绍如何使用Java中的Netty框架。Netty是一个用于快速开发高性能、高可靠性的网络通信程序的框架，它提供了简单易用的API，使得网络编程变得更加容易。 流程 下面是实现Java使用Netty的整体流程： 步骤 描述 1 引入Netty依赖 2...
BIO NIO AIO实例
This is bill的专属博客
07-21 1406
本文介绍java网络IO方面的知识，包含BIO、NIO和AIO的使用例子。 1.IO 术语 BIO 同步阻塞IO，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器就需要启动一个线程进行处理。 NIO 同步非阻塞IO，服务器实现模式为一个请求一个线程，即客户端发送的连接请求会注册到多路复用器上，多路复用器轮询到连接有IO请求时才启动一个线程进行处理。 AIO 异步
Java--网络编程之Netty
liuyanan的博客
02-05 953
一、什么是Netty Netty是一个JAVA开源框架，提供异步、事件驱动的网络应用程序框架和工具。 二、Netty组件 1、Bootstrap 启动辅助器，Netty客户端和服务器的入口，Bootstrap是创建客户端连接的启动器，ServerBootstrap是监听服务端端口的启动器。 2、EventLoop （1）类似线程，一个EventLoopGroup包含一个或者多个EventLoop。...
Netty是一个基于Java的网络应用框架，它提供了一种高性能、可扩展的网络编程模型
BLOG域名:programb.blog.youkuaiyun.com
02-29 963
直接内存缓冲区是在堆外分配的，可以直接与操作系统进行交互，避免了数据在内核空间和用户空间之间的拷贝，提高了数据传输的效率。它可以使用较少的线程处理大量的连接请求，提高了系统的吞吐量和响应速度。通道可以是单向的，只能在一个方向上传输数据，也可以是双向的，可以在两个方向上传输数据。NIO（New Input/Output）是Java中的一种高效的I/O处理方式，它提供了一种非阻塞的、事件驱动的I/O模型。在数据传输过程中，避免了数据的多次拷贝，减少了CPU和内存的开销，提高了数据传输的效率。
Java基础之《netty（16）—netty核心模块》
csj50的专栏
12-20 572
1、Bootstrap意思是引导，一个netty应用通常由一个Bootstrap开始，主要作用是配置整个netty程序，串联各个组件，netty中Bootstrap类是客户端程序的启动引导类，ServerBootstrap是服务端启动引导类。该方法用于服务器端，用来设置两个EventLoop。该方法用于客户端，用来设置一个EventLoop。该方法用来设置一个服务器端、客户端的通道实现。该方法用于服务器端，用来设置占用的端口号。该方法用于客户端，用来连接服务器。用来给接收到的通道添加配置。
Java Netty 教程
wwwcomcn123的专栏
06-14 482
Netty是用于Java的高性能IO工具包。 Netty是开源的，因此可以自由使用它，甚至可以为它做出贡献。该Netty教程将解释Netty的工作方式以及如何开始使用Netty。但本教程不会涵盖Netty的每一个细节。 Netty官网 Netty网站地址为：https://netty.io/ Netty优势 通常，与使用标准Java实现的应用程序相比，Netty使构建可扩展，强大的网络应用程序变得容易得多。 Netty还包含一些特定于操作系统的优化，例如在Linux上使用EPOLL等。...
java netty_Java网络编程 -- Netty入门
weixin_42416398的博客
02-12 218
Netty简介Netty是一个高性能，高可扩展性的异步事件驱动的网络应用程序框架，它极大的简化了TCP和UDP客户端和服务器端网络开发。它是一个NIO框架，对Java NIO进行了良好的封装。作为一个异步NIO框架，Netty的所有IO操作都是异步非阻塞的，通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。Netty的特性统一的API，适用于不同的协议...
Java Netty 框架
sanmansan的博客
06-07 1133
Java Netty 框架
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值