Scalable IO in Java的代码实现

最新推荐文章于 2020-07-03 13:16:11 发布
最新推荐文章于 2020-07-03 13:16:11 发布
阅读量1.5k 收藏 3
点赞数 2
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxdfc/article/details/61210087
版权


        最近在学习NIO相关的知识部分，在学习的时候，发现Doug Lea大神的一个PPT地址，里面的内容写的非常好，

很值得学习，具体内容可以参见PPT和网上的文章，自己根据PPT中的例子和描述，自己将代码补充了一下。下面主要是PPT中的代码和实例。

1.Basic Reactor Design


package basic;

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;
/**
* @ClassName: Reactor
* @Description: 根据 Scalable IO in Java写的实例。
* @date 2017年3月7日
 */
public class Reactor implements Runnable
{
	final Selector selector;
	final ServerSocketChannel serverSocketChannel;
	public Reactor(int port) throws IOException
	{
		selector = Selector.open();
		serverSocketChannel = ServerSocketChannel.open();
		serverSocketChannel.socket().bind(new InetSocketAddress(port));
		serverSocketChannel.configureBlocking(false);
		SelectionKey key = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
		key.attach(new Acceptor());
	}
	public void run()
	{
		try{
			while(!Thread.interrupted()){
				int n = selector.select();//等待事件
				if(n == 0)
					continue;
				Set<SelectionKey> set = selector.selectedKeys();
				Iterator<SelectionKey> iterator = set.iterator();
				while(iterator.hasNext()){
					dispatch(iterator.next());
				}
				set.clear();
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	private void dispatch(SelectionKey k)
	{
		Runnable runnable = (Runnable) k.attachment();
		if(runnable != null)
			runnable.run();
	}
	class Acceptor implements Runnable
	{
		public void run()
		{
			try
			{
				SocketChannel c = serverSocketChannel.accept();//接收请求
				if(c != null){
					System.out.println("New Connection ...");
					new Handler(selector, c);
				}
			} catch (IOException e)
			{
				e.printStackTrace();
			}
		}
	}
	
	final class Handler implements Runnable{
		
		final SocketChannel socket;
		final SelectionKey key;
		ByteBuffer input = ByteBuffer.allocate(1024);
		ByteBuffer output = ByteBuffer.allocate(1024);
		static final int READING = 0,SENDING =1;
		int state = READING;
		
		public Handler(Selector selector, SocketChannel c) throws IOException
		{
			socket = c;
			socket.configureBlocking(false);
			key = socket.register(selector, 0);
			key.attach(this);
			key.interestOps(SelectionKey.OP_READ);//注册可读事件
			selector.wakeup();
		}
		public void run()
		{
			try {
				if(state == READING)
					read();
				else if(state == SENDING)
					send();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		boolean inputIsComplete(){
			return input.hasRemaining();
		}
		boolean outputIsComplete(){
			return output.hasRemaining();
		}
		void process(){
			//读数据
			StringBuilder reader = new StringBuilder();
			input.flip();
			while(input.hasRemaining()){
				reader.append((char)input.get());
			}
			System.out.println("[Client-INFO]");
			System.out.println(reader.toString());
			String str = "HTTP/1.1 200 OK\r\nDate: Fir, 10 March 2017 21:20:01 GMT\r\n"+
					"Content-Type: text/html;charset=UTF-8\r\nContent-Length: 23\r\nConnection:close"+
					"\r\n\r\nHelloWorld"+System.currentTimeMillis();
			output.put(str.getBytes());
			System.out.println("process over.... ");
		}
		void read() throws IOException{
			socket.read(input);
			if(inputIsComplete()){
				process();
				state = SENDING;
				key.interestOps(SelectionKey.OP_WRITE);
			}
		}
		void send() throws IOException {
			output.flip();
			socket.write(output);
			if(outputIsComplete()){
				key.cancel();
			}
			state = READING;
			key.interestOps(SelectionKey.OP_READ);
		}
	} 
	public static void main(String[] args) throws IOException
	{
		new Thread(new Reactor(9001)).start();
		System.out.println("Server start...");
	}
}


2.Per-State Handlers

package state;

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;
/**
* @ClassName: Reactor
* @Description: 根据 Scalable IO in Java写的实例。
* @author Lzyer
* @date 2017年3月7日
 */
public class Reactor implements Runnable
{
	final Selector selector;
	final ServerSocketChannel serverSocketChannel;
	public Reactor(int port) throws IOException
	{
		selector = Selector.open();
		serverSocketChannel = ServerSocketChannel.open();
		serverSocketChannel.socket().bind(new InetSocketAddress(port));
		serverSocketChannel.configureBlocking(false);
		SelectionKey key = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
		key.attach(new Acceptor());
	}
	public void run()
	{
		try{
			while(!Thread.interrupted()){
				int n = selector.select();//等待事件
				if(n == 0)
					continue;
				Set<SelectionKey> set = selector.selectedKeys();
				Iterator<SelectionKey> iterator = set.iterator();
				while(iterator.hasNext()){
					dispatch(iterator.next());
				}
				set.clear();
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	private void dispatch(SelectionKey k)
	{
		Runnable runnable = (Runnable) k.attachment();
		if(runnable != null)
			runnable.run();
	}
	class Acceptor implements Runnable
	{
		public void run()
		{
			try
			{
				SocketChannel c = serverSocketChannel.accept();
				if(c != null){
					System.out.println("New Connection ...");
					new Handler2(selector, c);
				}
			} catch (IOException e)
			{
				e.printStackTrace();
			}
		}
	}
	
	/***
	* @ClassName: Handler2
	* @Description: State-Object pattern
	* @author lzyer 
	* @date 2017年3月8日
	*
	 */
	class Handler2 implements Runnable{
		
		final SocketChannel socket;
		final SelectionKey key;
		ByteBuffer input = ByteBuffer.allocate(1024);
		ByteBuffer output = ByteBuffer.allocate(1024);
		static final int READING = 0,SENDING =1;
		int state = READING;
		
		public Handler2(Selector selector, SocketChannel c) throws IOException
		{
			this.socket = c;
			this.socket.configureBlocking(false);
			key  = socket.register(selector, SelectionKey.OP_READ);
			key.attach(this);
			selector.wakeup();
		}
		
		public void run()
		{
			try
			{
				socket.read(input);
				if(inputIsComplete()){
					process();
					key.attach(new Sender());//send thread
					key.interestOps(SelectionKey.OP_WRITE);
					key.selector().wakeup();
				}
			} catch (IOException e)
			{
				e.printStackTrace();
			}
		}
		boolean inputIsComplete(){
			return input.hasRemaining();
		}
		boolean outputIsComplete(){
			return output.hasRemaining();
		}
		void process(){
			//读数据
			StringBuilder reader = new StringBuilder();
			input.flip();
			while(input.hasRemaining()){
				reader.append((char)input.get());
			}
			System.out.println("[Client-INFO]");
			System.out.println(reader.toString());
			String str = "HTTP/1.1 200 OK\r\nDate: Sat, 31 Dec 2005 23:59:59 GMT\r\n"+
					"Content-Type: text/html;charset=UTF-8\r\nContent-Length: 23\r\nConnection:close"+
					"\r\n\r\nWelcome NIO "+System.currentTimeMillis();
			output.put(str.getBytes());
			System.out.println("process over.... ");
		}
		class Sender implements Runnable{
			
			public void run()
			{
				try
				{
					output.flip();
					socket.write(output);
					if(outputIsComplete())
						key.cancel();
					socket.close();//记住要关闭
				} catch (IOException e)
				{
					e.printStackTrace();
				}
				
			}
		}
	}
	public static void main(String[] args) throws IOException
	{
		new Thread(new Reactor(9001)).start();
		System.out.println("Server start...");
	}
}


3.Handler with Thread Pool


package pool;

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;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @ClassName: Reactor
* @Description: 根据 Scalable IO in Java写的实例。
* @author Lzyer 
* @date 2017年3月7日
 */
public class Reactor implements Runnable
{
	final Selector selector;
	final ServerSocketChannel serverSocketChannel;
	public Reactor(int port) throws IOException
	{
		selector = Selector.open();
		serverSocketChannel = ServerSocketChannel.open();
		serverSocketChannel.socket().bind(new InetSocketAddress(port));
		serverSocketChannel.configureBlocking(false);
		SelectionKey key = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
		key.attach(new Acceptor());
	}
	public void run()
	{
		try{
			while(!Thread.interrupted()){
				int n = selector.select();
				if(n == 0)
					continue;
				Set<SelectionKey> set = selector.selectedKeys();
				Iterator<SelectionKey> iterator = set.iterator();
				while(iterator.hasNext()){
					dispatch(iterator.next());
				}
				set.clear();
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	private void dispatch(SelectionKey k)
	{
		Runnable runnable = (Runnable) k.attachment();
		if(runnable != null)
			runnable.run();
	}
	class Acceptor implements Runnable
	{
		public void run()
		{
			try
			{
				SocketChannel c = serverSocketChannel.accept();
				if(c != null){
					System.out.println("New Connection ...");
					new Handler3(selector, c);
				}
			} catch (IOException e)
			{
				e.printStackTrace();
			}
		}
	}
	
	/**
	* @ClassName: Handler3
	* @Description: 使用线程池
	* @author Lzyer 
	* @date 2017年3月8日
	*
	 */
	class Handler3 implements Runnable
	{
		final SocketChannel socket;
		final SelectionKey key;
		ByteBuffer input = ByteBuffer.allocate(1024);
		ByteBuffer output = ByteBuffer.allocate(1024);
		static final int READING = 0,SENDING =1, PROCESSING =3;
		int state = READING;
		ExecutorService pool = Executors.newCachedThreadPool();
		public Handler3(Selector selector, SocketChannel c) throws IOException
		{
			this.socket = c;
			this.socket.configureBlocking(false);
			key = socket.register(selector, SelectionKey.OP_READ);
			key.attach(this);
			selector.wakeup();
		}
		public void run()
		{
			try
			{
				if(state == READING)
					read();
				else if(state == SENDING)
					send();
			} catch (IOException e)
			{
				e.printStackTrace();
			}
		}
		synchronized void read() throws IOException { 
			socket.read(input);
			if (inputIsComplete()) {
				state = PROCESSING;
				pool.execute(new Processer());
			}
		}
		void send() throws IOException {
			output.flip();
			socket.write(output);
			if(outputIsComplete()){
				key.cancel();
			}
			state = READING;
			key.interestOps(SelectionKey.OP_READ);
		}
		void process(){
			//读数据
			StringBuilder reader = new StringBuilder();
			input.flip();
			while(input.hasRemaining()){
				reader.append((char)input.get());
			}
			System.out.println("[Client-INFO]");
			System.out.println(reader.toString());
			String str = "HTTP/1.1 200 OK\r\nDate: Fir, 10 March 2017 21:20:01 GMT\r\n"+
					"Content-Type: text/html;charset=UTF-8\r\nContent-Length: 32\r\nConnection:close"+
					"\r\n\r\nWelcome JAVA World "+System.currentTimeMillis();
			output.put(str.getBytes());
			System.out.println("process .... ");
		}
		boolean inputIsComplete(){
			return input.hasRemaining();
		}
		boolean outputIsComplete(){
			return output.hasRemaining();
		}
		synchronized void processAndHandOff() {
			process();
			state = SENDING; // or rebind attachment
			key.interestOps(SelectionKey.OP_WRITE);
			System.out.println("processer over....");
		}
		class Processer implements Runnable
		{
			public void run()
			{
				processAndHandOff();
			}
		}
	}
	public static void main(String[] args) throws IOException
	{
		new Thread(new Reactor(9001)).start();
		System.out.println("Server start...");
	}
}


4Using Multiple Reactors


package multiple;

import java.io.IOException;
import java.util.concurrent.atomic.AtomicInteger;

public class Server
{
	private static Reactor mainReactor;//主要负责接收请求
	private static Reactor[] subReactors;//负责处理IO
	private static final int SUB_SIZE = 3;
	private static final int port = 1234;
	
	private static AtomicInteger nextIndex = new AtomicInteger();
	
	public static Reactor nextSubReactor(){
		long nextIndexValue = nextIndex.getAndIncrement();
		if(nextIndexValue < 0){
			nextIndex.set(0);
			nextIndexValue = 0;
		}
		return subReactors[(int) (nextIndexValue%subReactors.length)];
	}
	
	public static void main(String[] args)
	{
		try
		{
			mainReactor = new Reactor(port, true);
			subReactors = new Reactor[SUB_SIZE];
			for(int i=0; i< subReactors.length; i++){
				subReactors[i] = new Reactor(port, false);
			}
			mainReactor.start();
			for(int i=0; i< subReactors.length; i++){
				subReactors[i].start();
			}
		} catch (IOException e)
		{
			e.printStackTrace();
		}
	}
}



package multiple;

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

/**
* @ClassName: Reactor
* @Description: 根据 Scalable IO in Java写的实例。
* @author Lzyer 
* @date 2017年3月10日
 */
public class Reactor extends Thread
{
	final Selector selector;
	final boolean isMain;//主从的标志
	
	public Reactor(int port, boolean isMain) throws IOException
	{
		this.isMain = isMain;
		selector = Selector.open();
		System.out.println(selector +" isMainReactor = "+isMain);
		if(isMain){
			ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
			serverSocketChannel.socket().bind(new InetSocketAddress(port));
			serverSocketChannel.configureBlocking(false);
			SelectionKey key = serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
			key.attach(new Acceptor(selector, serverSocketChannel));
			selector.wakeup();
			System.out.println(getClass().getSimpleName()+" start on "+port+" ...\n");
		}
	}
	public void run()
	{
		try
		{
			while(!Thread.interrupted()){
				int n = selector.select(10);//会阻塞导致不能register，设置阻塞时间
				if(n == 0)
					continue;
				Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
				while(iterator.hasNext()){
					dispatch(iterator.next());
					iterator.remove();
				}
			}
		} catch (IOException e)
		{
			e.printStackTrace();
		}
	}
	private void dispatch(SelectionKey k)
	{
		Runnable runnable = (Runnable) k.attachment();
		if(runnable != null)
			runnable.run();
	}

}



package multiple;

import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

/**
* @ClassName: Acceptor
* @Description: 接收请求
* @author Lzyer 
* @date 2017年3月9日
*
 */
public class Acceptor implements Runnable
{
	private ServerSocketChannel serverSocketChannel;
	
	private Selector selector;
	
	public Acceptor(Selector selector,ServerSocketChannel ser)
	{
		this.selector = selector;
		this.serverSocketChannel = ser;
	}
	public void run()
	{
		try{
			System.out.println(selector+"  accept ....");
			
			SocketChannel socketChannel = serverSocketChannel.accept();
			if(socketChannel != null){
				/**
				 *  开启了多个reactor池,一个selector负责接收和处理IO
				 * new Handler(selector, socketChannel);
				 */
				//使用的主从结构,一个主selector负责接收,其他的负责处理IO
				Selector selector2 = Server.nextSubReactor().selector;
				System.out.println(selector2+" clientChannel not null..."+socketChannel);
				new Handler(selector2, socketChannel);
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
}



package multiple;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
/**
* @ClassName: Handler
* @Description: 处理IO操作
* @author Lzyer 
* @date 2017年3月9日
*
 */
public class Handler implements Runnable
{
	final SocketChannel socket;
	final SelectionKey key;
	ByteBuffer input = ByteBuffer.allocate(1024);
	ByteBuffer output = ByteBuffer.allocate(1024);
	static final int READING = 0,SENDING =1;
	int state = READING;
	
	public Handler(Selector selector, SocketChannel c) throws IOException
	{
		socket = c;
		socket.configureBlocking(false);
		key = socket.register(selector,SelectionKey.OP_READ);
		key.attach(this);
		selector.wakeup();
		System.out.println(selector+" connect success...");
	}
	public void run()
	{
		try {
			if(state == READING)
				read();
			else if(state == SENDING)
				send();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	boolean inputIsComplete(){
		return input.hasRemaining();
	}
	boolean outputIsComplete(){
		return output.hasRemaining();
	}
	void process(){
		//读数据
		StringBuilder reader = new StringBuilder();
		input.flip();
		while(input.hasRemaining()){
			reader.append((char)input.get());
		}
		System.out.println("[Client-INFO]");
		System.out.println(reader.toString());
		String str = "HTTP/1.1 200 OK\r\nDate: Fir, 10 March 2017 21:20:01 GMT\r\n"+
				"Content-Type: text/html;charset=UTF-8\r\nContent-Length: 24\r\nConnection:close"+
				"\r\n\r\nHelloRector"+System.currentTimeMillis();
		output.put(str.getBytes());
		System.out.println("process .... ");
	}
	void read() throws IOException{
		socket.read(input);
		if(inputIsComplete()){
			process();
			state = SENDING;
			key.interestOps(SelectionKey.OP_WRITE);
		}
	}
	void send() throws IOException {
		output.flip();
		socket.write(output);
		if(outputIsComplete()){
			key.cancel();
		}
		state = READING;
		key.interestOps(SelectionKey.OP_READ);
	}

}


代码地址：链接

参考:http://blog.csdn.net/jjzhk/article/details/39553613

       http://www.iclojure.com/blog/articles/2015/12/05/Scalable-IO-in-Java


在风雨中奔跑
关注
专栏目录
Scalable IO in Java 译文
ljcgit的博客
11-07 659
1.概要 可伸缩的网络服务 事件驱动程序 Reactor模式（基本版本，多线程版本，其他变型） 参考了解java.nio中有关非阻塞的API 2.网络服务 web服务，分布式对象等等 大都具有相同的基本结构：读请求 ——》 解码请求 ——》 处理请求 ——》 编码响应 ——》 发送响应 但是，每一步都有不同的性质和成本 3.经典服务设计 每一个hanlder...
Scalable IO in Java
09-09
在Java编程语言中，Scalable IO（可扩展输入/输出）是指设计和实现能够高效处理大量数据并能适应不断增长的数据量的系统。本文将深入探讨Java中的Scalable IO概念，包括基础的IO流、NIO（New IO）、NIO.2以及相关的...
《Scalable IO in Java》笔记
weixin_34362991的博客
03-11 127
Scalable IO in Java http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf 基本上所有的网络处理程序都有以下基本的处理过程:Read requestDecode requestProcess serviceEncode replySend reply Classic Service Designs 简单的代码实现： class ...
《Scalable IO in Java》译文
dianyuzhi7625的博客
07-28 360
《Scalable IO in Java》 是java.util.concurrent包的作者，大师Doug Lea关于分析与构建可伸缩的高性能IO服务的一篇经典文章，在文章中Doug Lea通过各个角度，循序渐进的梳理了服务开发中的相关问题，以及在解决问题的过程中服务模型的演变与进化，文章中基于Reactor反应器模式的几种服务模型架构，也被Netty、Mina等大多数高性能IO服务框...
Scalable IO in Java -Doug Lea.rar
09-29
从提供的文件列表来看，"Scalable IO in Java -Doug Lea.pdf"可能是该主题的详细论述，而"1.pptx"可能是相关的演示文稿或课程幻灯片，它们将更深入地阐述这些概念并提供实例分析。阅读这些材料，开发者可以学习如何...
Scalable IO in Java.pdf
07-04
综上所述，文档《Scalable IO in Java》深入探讨了如何在Java中设计和实现可伸缩的网络服务，涉及了反应器模式、NIO API的使用、网络服务的结构、以及可伸缩性目标的实现方法。这是一份宝贵的资料，对于那些需要在...
Doug Lea Scalable IO in Java
11-01
《Doug Lea Scalable IO in Java》是一本深入探讨Java NIO（非阻塞I/O）和反应器设计模式的经典著作。作者Doug Lea是Java并发领域的权威，他对Java性能优化和系统设计有着深刻的洞察力。这本书对于理解如何在Java...
doug lea《Scalable IO in Java》
09-25
doug lea 大神 Reactor 说明 Scalable IO in Java 原文必读 原文必读 原文必读
Scalable IO in Java -Doug Lea
07-10
Scalable IO in Java -Doug Lea 描述java nio 和reactor 设计模式之间的关系
Scalable io in java.doc
03-21
nio.pdf 博文链接：https://shenkun-918.iteye.com/blog/965654
Scalable IO in Java（Java可伸缩IO）
猫小妖的专栏
03-28 886
翻译一下Doug Lea所写的Scalable IO in Java（Java可伸缩IO） 大多数的网络服务有着同样的处理流程： Read request 请求数据读取 Decode request 请求数据解码 Process service 业务处理 Encode reply 响应编码 Send reply 响应发送 但是每一步的本质和代价是不一样的。 经典的服务...
Scalable io in java
New World
07-06 2318
本文可看成是对Doug Lea Scalable IO in Java一文的翻译。当前分布式计算　Web Services盛行天下，这些网络服务的底层都离不开对socket的操作。他们都有一个共同的结构：1. Read request2. Decode request3. Process service4. Encode reply5. Send reply经典的网络服
【解读】《Scalable IO in Java》阅读思考与笔记
crxk_的博客
07-03 4151
《Scalable IO in Java》阅读笔记网络处理流程一个线程对应一个网络连接高性能的奥义：分而治之 事件驱动Reactor模式单线程单reactor多worker线程模式多reactor多worker线程模式 《Scalable IO in Java》 出自于java大神Doug Lea，这是一篇关于高性能IO服务的经典文章，文章中梳理了网络服务架构的演化，提出了Reactor反应器模式，这种设计模式是netty等高性能网络框架的基础。 网络处理流程 服务器对于一次网络请求的处理大概流程如下
Java NIO英文版：提升IO效率与Netty应用
这本书对于理解和实现Scalable IO技术，如Netty框架，具有重要意义，因为它详细地探讨了Java程序员在处理I/O操作时所面临的挑战，并展示了如何利用这些新特性来提升代码的效率。 书中的核心内容包括： 1. **介绍**...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值