iocp 文件服务器,C++ IOCP windows服务器

最新推荐文章于 2024-09-24 14:49:00 发布
最新推荐文章于 2024-09-24 14:49:00 发布
阅读量529 收藏
点赞数 1
文章标签： iocp 文件服务器

首先，启动主线程，接收来自客户端的请求。并启动4个子线程接收已经建连的客户端发来的消息。此时主线不阻塞，继续接收新的注册请求。4个子线程处理发来的消息，并解析消息，将要做的任务交给线程池处理。自己继续处理发来的消息。

IOCP服务器实现#pragma once

#include 

#include 

#include 

#include 

#include 

#include "CThreadPool.h"

#include "WorkA.h"

#include "WorkB.h"

using namespace std;

#pragma comment(lib, "Ws2_32.lib")      // Socket编程需用的动态链接库

//#pragma comment(lib, "Kernel32.lib")

#define DefaultIP  "127.0.0.1"

#define DefaultPort 9999

#define DefaultClientNum 6000

#define MessMaxLen   1024

#define DataBuffSize   2 * 1024

/**

* 结构体名称：PER_IO_DATA

* 结构体功能：重叠I/O需要用到的结构体，临时记录IO数据

**/

typedef struct

{

OVERLAPPED overlapped;

WSABUF databuff;

char buffer[ DataBuffSize ];

int BufferLen;

int operationType;

SOCKET socket;

}PER_IO_OPERATEION_DATA, *LPPER_IO_OPERATION_DATA, *LPPER_IO_DATA, PER_IO_DATA;

/**

* 结构体名称：PER_HANDLE_DATA

* 结构体存储：记录单个套接字的数据，包括了套接字的变量及套接字的对应的客户端的地址。

* 结构体作用：当服务器连接上客户端时，信息存储到该结构体中，知道客户端的地址以便于回访。

**/

typedef struct

{

SOCKET socket;

SOCKADDR_STORAGE ClientAddr;

}PER_HANDLE_DATA, *LPPER_HANDLE_DATA;

//单例类

class CMYIOCPServer

{

public:

~CMYIOCPServer(void);

bool ServerSetUp();

void SetServerIp(const string & sIP=DefaultIP);

void SetPort(const int &iPort=DefaultPort);

void SetMaxClientNum(const int &iMaxNum = DefaultClientNum);

static DWORD WINAPI  ServerWorkThread(LPVOID CompletionPortID);

static void SendMessage(SOCKET &tSOCKET,char MessAge[MessMaxLen]);

static CMYIOCPServer* GetInstance();

private:

//私有方法

CMYIOCPServer(void);

bool  LoadWindowsSocket();

bool InitServerSocket();

bool CreateServerSocker();

static void HandleMessage();

//私有数据

string m_sServerIP;

int m_iLisenPoint;

string m_sError;

int m_iMaxClientNum;

vector m_vclientGroup;//保持客户端的连接信息

static HANDLE m_hMutex;//多线程访问互斥变量

static HANDLE m_completionPort;

SOCKET m_srvSocket;

static CMYIOCPServer *m_pInstance;

static char m_byteMsg[MessMaxLen];

static CWorkQueue m_CWorkQueue;//线程池

};

#include "StdAfx.h"

#include "MYIOCPServer.h"

HANDLE  CMYIOCPServer::m_completionPort = NULL;

HANDLE CMYIOCPServer:: m_hMutex = NULL;

CMYIOCPServer* CMYIOCPServer::  m_pInstance = NULL;

char CMYIOCPServer::m_byteMsg[MessMaxLen] = {0} ;

CWorkQueue CMYIOCPServer:: m_CWorkQueue;

/**************************

获得单例对象

***************************/

CMYIOCPServer* CMYIOCPServer::GetInstance()

{

if(NULL == m_pInstance)

{

m_pInstance = new CMYIOCPServer();

}

m_CWorkQueue.Create(10);

return m_pInstance;

}

/**************************

类的构造函数

**************************/

CMYIOCPServer::CMYIOCPServer(void)

{

m_iLisenPoint = DefaultPort;

}

/**************************

类的析构函数

**************************/

CMYIOCPServer::~CMYIOCPServer(void)

{

m_CWorkQueue.Destroy(5);

}

/**************************

设置服务器IP

**************************/

void CMYIOCPServer::SetServerIp(const string & sIP)

{

m_sServerIP = sIP;

}

/**************************

设置服务器端口

**************************/

void  CMYIOCPServer::SetPort(const int &iPort)

{

m_iLisenPoint = iPort;

}

/**************************

设置最大的客户端连接数目

**************************/

void  CMYIOCPServer::SetMaxClientNum(const int &iMaxNum)

{

m_iMaxClientNum = iMaxNum;

}

/**************************

服务器接收客户端消息，

工作线程

**************************/

DWORD WINAPI   CMYIOCPServer::ServerWorkThread(LPVOID CompletionPortID)

{

HANDLE CompletionPort = (HANDLE)CompletionPortID;

DWORD BytesTransferred;

LPOVERLAPPED IpOverlapped;

LPPER_HANDLE_DATA PerHandleData = NULL;

LPPER_IO_DATA PerIoData = NULL;

DWORD RecvBytes;

DWORD Flags = 0;

BOOL bRet = false;

while(true){

bRet = GetQueuedCompletionStatus(m_completionPort, &BytesTransferred, (PULONG_PTR)&PerHandleData, (LPOVERLAPPED*)&IpOverlapped, INFINITE);

if(bRet == 0){

cerr <

continue;

//这里不能返回，返回子线程就结束了

//return -1;

}

PerIoData = (LPPER_IO_DATA)CONTAINING_RECORD(IpOverlapped, PER_IO_DATA, overlapped);

// 检查在套接字上是否有错误发生

if(0 == BytesTransferred){

closesocket(PerHandleData->socket);

GlobalFree(PerHandleData);

GlobalFree(PerIoData);

continue;

}

//得到消息码流

memset(m_byteMsg,0,MessMaxLen);

memcpy(m_byteMsg,PerIoData->databuff.buf,MessMaxLen);

//得到客户端SOCKET信息

SOCKET sClientSocket = PerHandleData->socket;

printf("message is %s \n",m_byteMsg);

HandleMessage();

//SendMessage(sClientSocket,m_byteMsg);

// 为下一个重叠调用建立单I/O操作数据

ZeroMemory(&(PerIoData->overlapped), sizeof(OVERLAPPED)); // 清空内存

PerIoData->databuff.len = 1024;

PerIoData->databuff.buf = PerIoData->buffer;

PerIoData->operationType = 0;    // read

WSARecv(PerHandleData->socket, &(PerIoData->databuff), 1, &RecvBytes, &Flags, &(PerIoData->overlapped), NULL);

}

return  0;

}

/*******************

处理消息类

*******************/

void CMYIOCPServer::HandleMessage()

{

printf("thread is %d\n",GetCurrentThreadId());

WorkItemBase *pCworkItem = NULL;

byte iCommand = m_byteMsg[0];

switch(iCommand)

{

case  '0':

pCworkItem = new CWorkA();

break;

case '1':

pCworkItem = new CWorkB();

break;

case '2':

break;

default:

break;

}

//将任务交给线程池处理

if(NULL != pCworkItem)

{

m_CWorkQueue.InsertWorkItem(pCworkItem);

}

printf("Finish Handle Message\n");

}

/**************************

发送消息给制定客户端

**************************/

void CMYIOCPServer::SendMessage(SOCKET &tSOCKET,char MessAge[MessMaxLen])

{

// 开始数据处理，接收来自客户端的数据

WaitForSingleObject(m_hMutex,INFINITE);

send(tSOCKET, MessAge, MessMaxLen, 0);  // 发送信息

ReleaseMutex(m_hMutex);

}

/**************************

初始化SOCKET对象，创建端口

和线程数组

**************************/

bool  CMYIOCPServer::LoadWindowsSocket()

{

// 加载socket动态链接库

WORD wVersionRequested = MAKEWORD(2, 2); // 请求2.2版本的WinSock库

WSADATA wsaData;    // 接收Windows Socket的结构信息

DWORD err = WSAStartup(wVersionRequested, &wsaData);

if (0 != err){  // 检查套接字库是否申请成功

m_sError = "Request Windows Socket Library Error!\n";

return false;

}

if(LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2){// 检查是否申请了所需版本的套接字库

WSACleanup();

m_sError ="Request Windows Socket Version 2.2 Error!\n";

system("pause");

return false;

}

// 创建IOCP的内核对象

/**

* 需要用到的函数的原型：

* HANDLE WINAPI CreateIoCompletionPort(

*    __in   HANDLE FileHandle,     // 已经打开的文件句柄或者空句柄，一般是客户端的句柄

*    __in   HANDLE ExistingCompletionPort, // 已经存在的IOCP句柄

*    __in   ULONG_PTR CompletionKey,   // 完成键，包含了指定I/O完成包的指定文件

*    __in   DWORD NumberOfConcurrentThreads // 真正并发同时执行最大线程数，一般推介是CPU核心数*2

* );

**/

m_completionPort = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0);

if (NULL == m_completionPort){    // 创建IO内核对象失败

m_sError ="CreateIoCompletionPort failed. Error:\n";

return false;

}

// 创建IOCP线程--线程里面创建线程池

// 确定处理器的核心数量

SYSTEM_INFO mySysInfo;

GetSystemInfo(&mySysInfo);

// 基于处理器的核心数量创建线程

for(DWORD i = 0; i 

// 创建服务器工作器线程，并将完成端口传递到该线程

HANDLE ThreadHandle = CreateThread(NULL, 0,  &CMYIOCPServer::ServerWorkThread, m_completionPort, 0, NULL);

if(NULL == ThreadHandle){

m_sError ="Create Thread Handle failed. Error::\n";

}

CloseHandle(ThreadHandle);

}

return true;

}

/*************************

初始化服务器SOCKET信息

*************************/

bool CMYIOCPServer::InitServerSocket()

{

// 建立流式套接字

m_srvSocket = socket(AF_INET, SOCK_STREAM, 0);

// 绑定SOCKET到本机

SOCKADDR_IN srvAddr;

srvAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

srvAddr.sin_family = AF_INET;

srvAddr.sin_port = htons(m_iLisenPoint);

int bindResult = bind(m_srvSocket, (SOCKADDR*)&srvAddr, sizeof(SOCKADDR));

if(SOCKET_ERROR == bindResult){

m_sError = "Bind failed. Error:";

return false;

}

return true;

}

/**************************

创建服务器端的监听信息

**************************/

bool CMYIOCPServer::CreateServerSocker()

{

// 将SOCKET设置为监听模式

int listenResult = listen(m_srvSocket, 10);

if(SOCKET_ERROR == listenResult){

m_sError = "Listen failed. Error: " ;

return false;

}

// 开始处理IO数据

cout <

int icount = 0;

while(true){

PER_HANDLE_DATA * PerHandleData = NULL;

SOCKADDR_IN saRemote;

int RemoteLen;

SOCKET acceptSocket;

// 接收连接，并分配完成端，这儿可以用AcceptEx()

RemoteLen = sizeof(saRemote);

acceptSocket = accept(m_srvSocket, (SOCKADDR*)&saRemote, &RemoteLen);

if(SOCKET_ERROR == acceptSocket){   // 接收客户端失败

cerr <

m_sError = "Accept Socket Error: " ;

icount++;

if(icount > 50)

{

return false;

}

continue;

}

icount = 0;

// 创建用来和套接字关联的单句柄数据信息结构

PerHandleData = (LPPER_HANDLE_DATA)GlobalAlloc(GPTR, sizeof(PER_HANDLE_DATA));  // 在堆中为这个PerHandleData申请指定大小的内存

PerHandleData -> socket = acceptSocket;

memcpy (&PerHandleData -> ClientAddr, &saRemote, RemoteLen);

m_vclientGroup.push_back(PerHandleData);       // 将单个客户端数据指针放到客户端组中

// 将接受套接字和完成端口关联

CreateIoCompletionPort((HANDLE)(PerHandleData -> socket), m_completionPort, (DWORD)PerHandleData, 0);

// 开始在接受套接字上处理I/O使用重叠I/O机制

// 在新建的套接字上投递一个或多个异步

// WSARecv或WSASend请求，这些I/O请求完成后，工作者线程会为I/O请求提供服务

// 单I/O操作数据(I/O重叠)

LPPER_IO_OPERATION_DATA PerIoData = NULL;

PerIoData = (LPPER_IO_OPERATION_DATA)GlobalAlloc(GPTR, sizeof(PER_IO_OPERATEION_DATA));

ZeroMemory(&(PerIoData -> overlapped), sizeof(OVERLAPPED));

PerIoData->databuff.len = 1024;

PerIoData->databuff.buf = PerIoData->buffer;

PerIoData->operationType = 0;    // read

DWORD RecvBytes;

DWORD Flags = 0;

WSARecv(PerHandleData->socket, &(PerIoData->databuff), 1, &RecvBytes, &Flags, &(PerIoData->overlapped), NULL);

}

//销毁资源

DWORD dwByteTrans;

PostQueuedCompletionStatus(m_completionPort, dwByteTrans, 0, 0);

closesocket(listenResult);

return true;

}

/*********************

启动服务器

*********************/

bool CMYIOCPServer::ServerSetUp()

{

if(false == LoadWindowsSocket())

{

return false;

}

if(false == InitServerSocket())

{

return false;

}

if(false == CreateServerSocker())

{

return false;

}

return true;

}

SOCKET客户端实现

// IOCPClient.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include 

#include 

#include 

#include 

#include 

#include 

using namespace std;

#pragma comment(lib, "Ws2_32.lib")      // Socket编程需用的动态链接库

SOCKET sockClient;      // 连接成功后的套接字

HANDLE bufferMutex;     // 令其能互斥成功正常通信的信号量句柄

const int DefaultPort = 9999;

int _tmain(int argc, _TCHAR* argv[])

{

// 加载socket动态链接库(dll)

WORD wVersionRequested;

WSADATA wsaData;    // 这结构是用于接收Wjndows Socket的结构信息的

wVersionRequested = MAKEWORD( 2, 2 );   // 请求2.2版本的WinSock库

int err = WSAStartup( wVersionRequested, &wsaData );

if ( err != 0 ) {   // 返回值为零的时候是表示成功申请WSAStartup

return -1;

}

if ( LOBYTE( wsaData.wVersion ) != 2 || HIBYTE( wsaData.wVersion ) != 2 ) { // 检查版本号是否正确

WSACleanup( );

return -1;

}

// 创建socket操作，建立流式套接字，返回套接字号sockClient

sockClient = socket(AF_INET, SOCK_STREAM, 0);

if(sockClient == INVALID_SOCKET) {

printf("Error at socket():%ld\n", WSAGetLastError());

WSACleanup();

return -1;

}

// 将套接字sockClient与远程主机相连

// int connect( SOCKET s,  const struct sockaddr* name,  int namelen);

// 第一个参数：需要进行连接操作的套接字

// 第二个参数：设定所需要连接的地址信息

// 第三个参数：地址的长度

SOCKADDR_IN addrSrv;

addrSrv.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");      // 本地回路地址是127.0.0.1;

addrSrv.sin_family = AF_INET;

addrSrv.sin_port = htons(DefaultPort);

while(SOCKET_ERROR == connect(sockClient, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR))){

// 如果还没连接上服务器则要求重连

cout <

char choice;

while(cin >> choice && (!((choice != 'Y' && choice == 'N') || (choice == 'Y' && choice != 'N')))){

cout <

cin.sync();

cin.clear();

}

if (choice == 'Y'){

continue;

}

else{

cout <

system("pause");

return 0;

}

}

cin.sync();

cout <

send(sockClient, "\nAttention: A Client has enter...\n", 200, 0);

bufferMutex = CreateSemaphore(NULL, 1, 1, NULL);

DWORD WINAPI SendMessageThread(LPVOID IpParameter);

DWORD WINAPI ReceiveMessageThread(LPVOID IpParameter);

HANDLE sendThread = CreateThread(NULL, 0, SendMessageThread, NULL, 0, NULL);

HANDLE receiveThread = CreateThread(NULL, 0, ReceiveMessageThread, NULL, 0, NULL);

WaitForSingleObject(sendThread, INFINITE);  // 等待线程结束

closesocket(sockClient);

CloseHandle(sendThread);

CloseHandle(receiveThread);

CloseHandle(bufferMutex);

WSACleanup();   // 终止对套接字库的使用

printf("End linking...\n");

printf("\n");

system("pause");

return 0;

}

DWORD WINAPI SendMessageThread(LPVOID IpParameter)

{

while(1){

string talk;

char talkbuffer[200];

//gets(talkbuffer);

int iRand = rand()%3;

Sleep(iRand * 1000);

if(1 == iRand)

{

talkbuffer[0]='0';

}

else

{

talkbuffer[0]='1';

}

talkbuffer[1] = '\0';

int len;

for (len = 0; talkbuffer[len] != '\0'; ++len){

// 找出这个字符组的长度

}

talkbuffer[len] = '\n';

talkbuffer[++len] = '\0';

talk = talkbuffer;

WaitForSingleObject(bufferMutex, INFINITE);     // P(资源未被占用)

if("quit" == talk){

talk.push_back('\0');

send(sockClient, talk.c_str(), 200, 0);

break;

}

else{

talk.append("\n");

}

printf("\nI Say:(\"quit\"to exit):");

//  cout <

//talk = talk + "\n\0";

//  string talka = "1234\n";

string talkb  = "aaaaaaaaaaaaaaaaaaaaaaa";

string talka  = "123\n";

talk = talk + "\0";

// talk =  talk + "\n";

send(sockClient, talkbuffer, 200, 0); // 发送信息

send(sockClient, talka.c_str(), 200, 0); // 发送信息

// send(sockClient, "\nAttention: A Client has enter...\n", 200, 0);

ReleaseSemaphore(bufferMutex, 1, NULL);     // V(资源占用完毕)

}

return 0;

}

DWORD WINAPI ReceiveMessageThread(LPVOID IpParameter)

{

while(1){

char recvBuf[300];

recv(sockClient, recvBuf, 200, 0);

WaitForSingleObject(bufferMutex, INFINITE);     // P(资源未被占用)

printf("%s Says: %s", "Server", recvBuf);       // 接收信息

ReleaseSemaphore(bufferMutex, 1, NULL);     // V(资源占用完毕)

}

return 0;

}

白白前
关注
c++ IOCP模型服务端
10-27
研究中的C++IOCP模型，大家可研究，正在研究 send群发效应
C++ IOCP windows服务器
01-20
首先，启动主线程，接收来自客户端的请求。并启动4个子线程接收已经建连的客户端发来的消息。此时主线不阻塞，继续接收新的注册请求。4个子线程处理发来的消息，并解析消息，将要做的任务交给线程池处理。自己继续处理发来的消息。 　　IOCP服务器实现 #pragma once #include #include #include #include #include #include CThreadPool.h #include WorkA.h #include Wor
iopc源码
桃之夭夭的博客
03-30 550
#include    #include    #include    #include       using namespace std;      #pragma comment(lib, "Ws2_32.lib")      // Socket编程需用的动态链接库   #pragma comment(lib, "Kernel32.lib")    // IOCP需要用到的动
深入掌握Windows IOCP高性能编程
最新发布
weixin_35370061的博客
09-24 773
本文还有配套的精品资源，点击获取 简介：完成端口（IOCP）是Windows中的高效I/O模型，用于高效处理并发I/O操作。本压缩包包含的源码和示例文件旨在帮助开发者深入理解并实践完成端口的使用，涵盖线程池使用、异步I/O操作、完成队列管理、I/O状态获取和自定义完成信息处理。通过这些实践，开发者能够掌握如何提升网络服务器性能，实现高效多路复用，并增强应用程序处理并发连接的...
IOCP模型C++入门级服务端搭建-接收客户端数据并处理
田螺姑娘的博客
07-08 828
WSARecv函数是从面向连接socket或面向无连接的socket接收数据。
IocpServer协议服务器
iidhdfji123的博客
11-15 385
using System; using System.Collections.Generic; using System.Text; using System.Net.Sockets; using System.Threading; using System.Net; namespace IocpServer { /// <summary> /// 基于SocketAsyncEventArgs 实现 IOCP 服务器 /// </summary> internal sealed cl
IOCP_Server_Client.rar_IOCP_IOCP C++_c++ iocp_iocp C++
07-15
IOCP（Input/Output Completion Port，输入/输出完成端口）是Windows操作系统提供的一种高度优化的多线程I/O模型，常用于高并发网络服务，如服务器应用。在这个"IOCP_Server_Client.rar"压缩包中，包含了一个用C++...
完成端口（IOCP) 服务器源码
06-09
Windows下IOCP模型 socket服务器端实例 1. 创建服务器socket， 并将socket设置为非阻塞模式 2. bind()绑定IP地此与端口 3. listen() 4. 创建IO完成端口，将socket绑定到IO完成端口上 5. 根据当前机器CPU个数创建工作...
C/C++ IOCP服务器
11-06
使用wsaaccpetex，支持2000个客户端同时连接，可根据需要扩展
IOCP.rar_IOCP_IOCP C++类_IOCP类 c++
09-14
IOCP（Input/Output Completion Port，完成端口）是Windows操作系统中的一种高效I/O模型，尤其适用于高并发的网络编程场景。完成端口通过集中处理多个I/O操作的完成状态，提高了系统资源的利用率和程序的并发能力。 ...
.iocpserver
wuqinxiang的专栏
08-14 313
//////////////////////////////////////////////////////////////////////       #include "stdafx.h"    #include "ChatServer.h"       #ifdef _DEBUG    #undef THIS_FILE    static char THIS_FILE[]=__FILE__
iocp服务器
07-25
iocp服务器框架，自己可以增加逻辑处理
IOCP在服务器开发中的应用[转自掰掰开发]
weixin_30802273的博客
05-08 139
引言 基于Socket的网络通信服务已经使用得相当普遍，然而一个服务器应用程序，假如不能够同时为多个客户端提供服务，那它就没有什么意义可言。针对一个服务器应用程序底层通信模块的设计，要使其在给定的时间内同时控制几个套接字，采用重叠的I/O机制是比较好的，但是要求服务器在任何给定时间内都会为海量I/O请求提供服务，Winsock 2.0中引入的内核级完成端口(Input/Output ...
完成端口(CompletionPort)详解 - 手把手教你玩转网络编程系列之三
热门推荐
小猪的网络编程
11-01 21万+
手把手叫你玩转网络编程系列之三    完成端口(Completion Port)详解                                                              ----- By PiggyXP(小猪) 前 言         本系列里完成端口的代码在两年前就已经写好了，但是由于许久没有写东西了，不知该如何提笔，所以这篇文档总是在酝酿
一个简单的IOCP服务器实例
木棉花开时，凤凰涅槃日！
11-20 1040
////////////////////////////////////////////////////////// // initsock.h文件 #include #pragma comment(lib, "WS2_32") // 链接到WS2_32.lib class CInitSock { public: CInitSock(BYTE minorVer = 2, BYTE ma
IOCP服务器
03-24
本代码为一个高并发量IOCP服务端模型，IOCP(I/O Completion Port),常称I/O完成端口。 IOCP模型属于一种通讯模型，适用于能控制并发执行的高负载服务器的一个技术。 通俗一点说，就是用于高效处理很多很多的客户端进行数据交换的一个模型。或者可以说，就是能异步I/O操作的模型。
iocp_c++11.rar_C++ iocp_IOCP 封装_c++ 异步框架_c++iocp封装_spentp2t
07-13
iocp异步通信封装，适合中小型并发服务器框架，性能经测试还可以
《A Simple IOCP Server/Client Class》整改
曾梦想仗剑走天涯
01-14 6647
CodeProject - 《A Simple IOCP Server/Client Class》 - 整改
c++——iocp模型
www_dong的博客
07-07 5092
IOCP有一个队列，当你要发数据时，收数据和连接时，都交由IOCP队列处理，不会与操作系统底层交互。 　该函数实际用于两个明显有别的目的： 5.4.3 向IOCP队列投递接受连接的请求 5.4.4 检测队列，从队列中取出完成的请求 5.4.5 投递一个队列完成状态 6. 示例 服务端 客户端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值