Windows Sockets

最新推荐文章于 2022-08-09 19:51:50 发布
最新推荐文章于 2022-08-09 19:51:50 发布
阅读量567 收藏
点赞数
分类专栏： Windows 文章标签： sockets windows socket asynchronous winapi null

       Sockets有两种模式，同步模式和异步模式。创建一个Socket后默认是同步的，可以通过ioctlsocket的FIONBIO命令设置异步模式。单独使用同步模式，效率会提高，但是不易控制连接的断开；单独使用异步模式，只有轮询，以控制但是效率自然低下。Windows Sockets提供了五种I/O模型，有效地提高了效率。当然，这五种模型主要是针对服务器的，因为服务器需要维护多个客户端的链路。

      1，Select模型

      Select模型使用select函数检测Socket集合中的若干个Socket是否有关心的事件(可读、可写、发生异常)，根据检测结果执行相关操作。这种模式使得可以用select函数同步检测事件，然后就可确保相关的I/O操作可以立即完成，提高了效率。代码框架如下：

int g_iTotalConn = 0;
SOCKET g_CliSocketArr[FD_SETSIZE];

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 ...

 bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));
 listen(sListen, 3);
  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
 while (TRUE)
 {
  sClient = accept(sListen, (sockaddr*)&client, &iAddrSize);

  //新连接，状态回调函数
  g_CliSocketArr[g_iTotalConn++] = sClient;
 }

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
 int i;
 fd_set fdread;
 int ret;
 struct timeval tv = {1, 0};
 char szMessage[MSGSIZE];

 while (TRUE)
 {
  FD_ZERO(&fdread);
  for (i = 0; i < g_iTotalConn; i++)
  {
   FD_SET(g_CliSocketArr[i], &fdread);
  }
  // We only care read event
  ret = select(0, &fdread, NULL, NULL, &tv);
  if (ret == 0)
  {
   // Time expired
   continue;
  }
  for (i = 0; i < g_iTotalConn; i++)
  {
   if (FD_ISSET(g_CliSocketArr[i], &fdread))
   {
    // A read event happened on g_CliSocketArr
    ret = recv(g_CliSocketArr[i], szMessage, MSGSIZE, 0);
    if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
    {
     // Client socket closed
     //连接断开，状态回调函数

     closesocket(g_CliSocketArr[i]);
     if (i < g_iTotalConn-1)
     {
      g_CliSocketArr[i--] = g_CliSocketArr[--g_iTotalConn];
     }
    }
    else
    {
     // We reveived a message from client
　// 新数据，数据回调函数     

    }
   }
  }
 }
}

 

      2：AsyncSelect模型

      这种模型通过Windows的消息传递方式通知客户关心的事件发生。因而必须创建一个窗口，在窗口的消息回调函数中处理自定义消息。具体可以在窗口的Create消息中创建Socket，并绑定Socket关心的事件与此窗口的处理消息。然后再此处理消息中进行相关操作。代码框架如下：

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
 WSADATA wsaData;
 static SOCKET sListen;
 SOCKET sClient;
 SOCKADDR_IN local, client;
 int ret, iAddrSize = sizeof(client);
 char szMessage[MSGSIZE];
 switch (message)
 {
 case WM_CREATE:
   WSAStartup(0x0202, &wsaData);
   sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 ...

  bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));
  listen(sListen, 3);
  WSAAsyncSelect(sListen, hwnd, WM_SOCKET, FD_ACCEPT);
  return 0;

  case WM_SOCKET:
  if (WSAGETSELECTERROR(lParam))
  {

  //连接断开，状态回调函数
   closesocket(wParam);
   break;
  }
  switch (WSAGETSELECTEVENT(lParam))
  {
  case FD_ACCEPT:
   // Accept a connection from client
   sClient = accept(wParam, (sockaddr*)&client, &iAddrSize);

   //新连接，状态回调函数
   // Associate client socket with FD_READ and FD_CLOSE event
   WSAAsyncSelect(sClient, hwnd, WM_SOCKET, FD_READ | FD_CLOSE);
   break;

  case FD_READ:
   ret = recv(wParam, szMessage, MSGSIZE, 0);
   if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
   {

    //连接断开，状态回调函数
    closesocket(wParam);
   }
   else
   {
   //新数据，数据回调函数 

   }
   break;

  case FD_CLOSE:

   //连接关闭，状态回调函数
   closesocket(wParam);
   break;
  }
  return 0;
 }

 return DefWindowProc(hwnd, message, wParam, lParam);
}

 

      3：EventSelect模型

      这种模型将用户关心的事件和某个内核事件对象关联起来。当事件到达是自动向事件发送信号。因而不用创建窗口，代码框架如下：

int g_iTotalConn = 0;
SOCKET g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];
WSAEVENT g_CliEventArr[MAXIMUM_WAIT_OBJECTS];

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 ...
 bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));
 listen(sListen, 3);
 CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
 while (TRUE)
 {
  sClient = accept(sListen, (sockaddr*)&client, &iAddrSize);
   //新连接，状态回调函数

  g_CliSocketArr[g_iTotalConn] = sClient;
  g_CliEventArr[g_iTotalConn] = WSACreateEvent();
  WSAEventSelect(g_CliSocketArr[g_iTotalConn], g_CliEventArr[g_iTotalConn], FD_READ|FD_CLOSE);
  g_iTotalConn++;
 }

 

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
 int ret, index;
 WSANETWORKEVENTS NetworkEvents;
 char szMessage[MSGSIZE];
 while (TRUE)
 {
  ret = WSAWaitForMultipleEvents(g_iTotalConn, g_CliEventArr, FALSE, 1000, FALSE);
  if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
  {
   continue;
  }
  index = ret - WSA_WAIT_EVENT_0;
  WSAEnumNetworkEvents(g_CliSocketArr[index], g_CliEventArr[index], &NetworkEvents);
  if (NetworkEvents.lNetworkEvents & FD_READ)
  {
   // Receive message from client
   ret = recv(g_CliSocketArr[index], szMessage, MSGSIZE, 0);
   if (ret == 0 || (ret == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET))
   {

   //连接关闭，状态回调函数
    Cleanup(index);
   }
   else
   {
   //收到数据，数据回调函数 

   }
  }
  if (NetworkEvents.lNetworkEvents & FD_CLOSE)
  {

   //连接关闭，状态回调函数
   Cleanup(index);
  }
 }

 return 0;
}

 

void Cleanup(int index)
{
 closesocket(g_CliSocketArr[index]);
 WSACloseEvent(g_CliEventArr[index]);
 if (index < g_iTotalConn-1)
 {
  g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn-1];
  g_CliEventArr[index] = g_CliEventArr[g_iTotalConn-1];
 }

 g_iTotalConn--;
}

 

      4：重叠模式

      重叠模式类似重叠I/O，内部使用异步Socket模式操作，可以通过事件或回调函数通知客户操作完成。

      通过事件通知的代码框架如下：

typedef struct
{
 WSAOVERLAPPED overlap;
 WSABUF        Buffer;
 char          szMessage[MSGSIZE];
 DWORD         NumberOfBytesRecvd;
 DWORD         Flags;
} PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

int                     g_iTotalConn = 0;
SOCKET                  g_CliSocketArr[MAXIMUM_WAIT_OBJECTS];
WSAEVENT                g_CliEventArr[MAXIMUM_WAIT_OBJECTS];
LPPER_IO_OPERATION_DATA g_pPerIoDataArr[MAXIMUM_WAIT_OBJECTS];

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 ...

 bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));
 listen(sListen, 3);
  CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
 while (TRUE)
 {
  // Accept a connection
  sClient = accept(sListen, (sockaddr*)&client, &iAddrSize);
  //新连接，状态回调函数

  g_CliSocketArr[g_iTotalConn] = sClient;
   g_pPerIoDataArr[g_iTotalConn] = (LPPER_IO_OPERATION_DATA)HeapAlloc(
   GetProcessHeap(),
   HEAP_ZERO_MEMORY,
   sizeof(PER_IO_OPERATION_DATA));
  g_pPerIoDataArr[g_iTotalConn]->Buffer.len = MSGSIZE;
  g_pPerIoDataArr[g_iTotalConn]->Buffer.buf = g_pPerIoDataArr[g_iTotalConn]->szMessage;
  g_CliEventArr[g_iTotalConn] = g_pPerIoDataArr[g_iTotalConn]->overlap.hEvent = WSACreateEvent();
   WSARecv(g_CliSocketArr[g_iTotalConn],
   &g_pPerIoDataArr[g_iTotalConn]->Buffer,
   1,
   &g_pPerIoDataArr[g_iTotalConn]->NumberOfBytesRecvd,
   &g_pPerIoDataArr[g_iTotalConn]->Flags,
   &g_pPerIoDataArr[g_iTotalConn]->overlap,
   NULL);
  g_iTotalConn++;
 }
 
 closesocket(sListen);
 WSACleanup();
 return 0;
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
 int ret, index;
 DWORD cbTransferred;
 while (TRUE)
 {
  ret = WSAWaitForMultipleEvents(g_iTotalConn, g_CliEventArr, FALSE, 1000, FALSE);
  if (ret == WSA_WAIT_FAILED || ret == WSA_WAIT_TIMEOUT)
  {
   continue;
  }
  index = ret - WSA_WAIT_EVENT_0;
  WSAResetEvent(g_CliEventArr[index]);
  WSAGetOverlappedResult(g_CliSocketArr[index],
   &g_pPerIoDataArr[index]->overlap,
   &cbTransferred,
   TRUE,
   &g_pPerIoDataArr[g_iTotalConn]->Flags);
  if (cbTransferred == 0)
  {
   // 连接断开，状态回调函数
   Cleanup(index);
  }
  else
  {
   // 新数据，数据回调函数

   // Launch another asynchronous operation
   WSARecv(g_CliSocketArr[index],
    &g_pPerIoDataArr[index]->Buffer,
    1,
    &g_pPerIoDataArr[index]->NumberOfBytesRecvd,
    &g_pPerIoDataArr[index]->Flags,
    &g_pPerIoDataArr[index]->overlap,
    NULL);
  }
 }
 
 return 0;
}

void Cleanup(int index)
{
 closesocket(g_CliSocketArr[index]);
 WSACloseEvent(g_CliEventArr[index]);
 HeapFree(GetProcessHeap(), 0, g_pPerIoDataArr[index]);
 if (index < g_iTotalConn-1)
 {
  g_CliSocketArr[index] = g_CliSocketArr[g_iTotalConn-1];
  g_CliEventArr[index] = g_CliEventArr[g_iTotalConn-1];
  g_pPerIoDataArr[index] = g_pPerIoDataArr[g_iTotalConn-1];
 }
 
 g_pPerIoDataArr[--g_iTotalConn] = NULL;
}

 

      回调函数代码框架：

SOCKET g_sNewClientConnection;
BOOL g_bNewConnectionArrived = FALSE;

sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 ...
 bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));
 listen(sListen, 3);
 CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
 while (TRUE)
 {
  // Accept a connection
  g_sNewClientConnection = accept(sListen, (sockaddr*)&client, &iAddrSize);
  g_bNewConnectionArrived = TRUE;
  //新连接，状态回调函数

 }

 return 0;
}

DWORD WINAPI WorkerThread(LPVOID lpParam)
{
 LPPER_IO_OPERATION_DATA lpPerIOData = NULL;
 while (TRUE)
 {
  if (g_bNewConnectionArrived)
  {
   // Launch an asynchronous operation for new arrived connection
   lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
    GetProcessHeap(),
    HEAP_ZERO_MEMORY,
    sizeof(PER_IO_OPERATION_DATA));
   lpPerIOData->Buffer.len = MSGSIZE;
   lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
   lpPerIOData->sClient = g_sNewClientConnection;

   WSARecv(lpPerIOData->sClient,
    &lpPerIOData->Buffer,
    1,
    &lpPerIOData->NumberOfBytesRecvd,
    &lpPerIOData->Flags,
    &lpPerIOData->overlap,
    CompletionRoutine);
   g_bNewConnectionArrived = FALSE;
  }
  SleepEx(1000, TRUE);
 }

 return 0;
}

void CALLBACK CompletionRoutine(DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags)
{
 LPPER_IO_OPERATION_DATA lpPerIOData = (LPPER_IO_OPERATION_DATA)lpOverlapped;
 if (dwError != 0 || cbTransferred == 0)
 {
  // 连接断开，状态回调函数

  closesocket(lpPerIOData->sClient);
  HeapFree(GetProcessHeap(), 0, lpPerIOData);
 }
 else
 {
  //新数据，数据回调函数

  // Launch another asynchronous operation
  memset(&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED));
  lpPerIOData->Buffer.len = MSGSIZE;
  lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
  WSARecv(lpPerIOData->sClient,
   &lpPerIOData->Buffer,
   1,
   &lpPerIOData->NumberOfBytesRecvd,
   &lpPerIOData->Flags,
   &lpPerIOData->overlap,
   CompletionRoutine);
 }
}

 

      5：完成端口模型

      完成端口模型应该是效率最高的I/O模型了，其他模型要么通过内核通知，要么为每个客户创建一个服务线程，通过检测通知。完成端口基于重叠I/O，采用了线程池技术，对于客户数目众多，变化频率高的服务器很实用。代码框架如下：

typedef enum
{
 RECV_POSTED
} OPERATION_TYPE;

typedef struct
{
 WSAOVERLAPPED  overlap;
 WSABUF         Buffer;
 char           szMessage[MSGSIZE];
 DWORD          NumberOfBytesRecvd;
 DWORD          Flags;
 OPERATION_TYPE OperationType;
} PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
 GetSystemInfo(&sysinfo);
 for (i = 0; i < sysinfo.dwNumberOfProcessors; i++)
 {
  CreateThread(NULL, 0, WorkerThread, CompletionPort, 0, &dwThreadId);
 }
  sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 ...
 bind(sListen, (sockaddr*)&local, sizeof(SOCKADDR_IN));
  listen(sListen, 3);
 while (TRUE)
 {
  // Accept a connection
  sClient = accept(sListen, (sockaddr*)&client, &iAddrSize);
  //新连接，状态回调函数

  // Associate the newly arrived client socket with completion port
  CreateIoCompletionPort((HANDLE)sClient, CompletionPort, (DWORD)sClient, 0);
  // Launch an asynchronous operation for new arrived connection
  lpPerIOData = (LPPER_IO_OPERATION_DATA)HeapAlloc(
   GetProcessHeap(),
   HEAP_ZERO_MEMORY,
   sizeof(PER_IO_OPERATION_DATA));
  lpPerIOData->Buffer.len = MSGSIZE;
  lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
  lpPerIOData->OperationType = RECV_POSTED;
  WSARecv(sClient,
   &lpPerIOData->Buffer,
   1,
   &lpPerIOData->NumberOfBytesRecvd,
   &lpPerIOData->Flags,
   &lpPerIOData->overlap,
   NULL);
 }

 PostQueuedCompletionStatus(CompletionPort, 0xFFFFFFFF, 0, NULL);
 CloseHandle(CompletionPort);
 closesocket(sListen);
 WSACleanup();
 return 0;
}

DWORD WINAPI WorkerThread(LPVOID CompletionPortID)
{
 HANDLE CompletionPort = (HANDLE)CompletionPortID;
 DWORD dwBytesTransferred;
 SOCKET sClient;
 LPPER_IO_OPERATION_DATA lpPerIOData = NULL;
 while (TRUE)
 {
  GetQueuedCompletionStatus(
   CompletionPort,
   &dwBytesTransferred,
   (DWORD*)&sClient,
   (LPOVERLAPPED*)&lpPerIOData,
   INFINITE);
  if (dwBytesTransferred == 0xFFFFFFFF)
  {
   return 0;
  }
  if (lpPerIOData->OperationType == RECV_POSTED)
  {
   if (dwBytesTransferred == 0)
   {
    // 连接断开，状态回调函数
    closesocket(sClient);
    HeapFree(GetProcessHeap(), 0, lpPerIOData);
   }
   else
   {
    //新数据，数据回调函数

    // Launch another asynchronous operation for sClient
    memset(lpPerIOData, 0, sizeof(PER_IO_OPERATION_DATA));
    lpPerIOData->Buffer.len = MSGSIZE;
    lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
    lpPerIOData->OperationType = RECV_POSTED;
    WSARecv(sClient,
     &lpPerIOData->Buffer,
     1,
     &lpPerIOData->NumberOfBytesRecvd,
     &lpPerIOData->Flags,
     &lpPerIOData->overlap,
     NULL);
   }
  }
 }

 return 0;
}

Matrix_Designer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WindowsSockets基础—概念
超越
05-22 2362
本章重点讲解WindowsSockets的基本知识。协议特征，IP定址，TCP和UDP Socket应用程序所调用的windows Sockets API,套接字选项。Windows Socket应用程序与WindowsSockets的关系上图为Windows Sockets应用程序A与应用程序B进行通信的过程。从用户进程的角度看，这两个应用程序都是通过调用WindowsSocketsAPI来实现...
WindowsSockets
11-07
WindowsSocketsWindowsSocketsWindowsSocketsWindowsSocketsWindowsSockets
Windows Sockets 规范及应用
07-07 4677
Windows Sockets 规范及应用           －Windows网络编程接口 施 炜    李 铮    秦 颍         编著      ******************************************************************版权信息    本书作者保留所有版权。禁止任何商业性的转载或复
Windows Sockets 2
m0_37357063的博客
10-31 473
目录 Windows Sockets 2 1.简介 2.服务端-客户端 小例子 2.1Winsock Server Source Code 2.2Winsock Server Source Code： 2.3程序运行结果： Windows Sockets 2 官网：https://docs.microsoft.com/en-us/windows/desktop/winsock/wi...
Windows Sockets网络编程
11-07
《Windows Sockets网络编程》分为三部分：第一部分（第1～6章），提供了翔实的背景知识和框架方面的概念，借助于此框架，读者可理解WinSock的具体细节，包括Windows Sockets概述、OSI网络参考模型、TCP/IP协议簇中的...
Windows Sockets 2.pdf
01-25
### Windows Sockets 2 **Windows Sockets 2 (Winsock 2)** 是一个用于实现网络通信的标准 API，它在 Windows 平台上提供了一个统一的编程接口，支持多种网络协议，如 TCP/IP 和 UDP。Winsock 2 相比于早期版本提供...
Windows Sockets.doc
11-27
**Windows Sockets (Winsock)** 是Windows操作系统中的一个应用程序接口(API)，它允许程序员进行网络通信，实现客户端和服务器之间的数据交换。这个接口是基于Berkeley Sockets模型的，因此也常被称为Berkeley ...
Windows Sockets 源码
04-04
Windows Sockets，通常简称为Winsock，是Microsoft Windows操作系统中实现网络通信协议接口的一个API（应用程序编程接口）。这个源码的提供，对于开发者来说，是一个深入理解网络编程、特别是TCP/IP协议栈在Windows...
精通Windows Sockets网络开发 pdf
01-23
《精通Windows Sockets网络开发》是一本专注于使用Windows Sockets API进行网络编程的专业书籍。Windows Sockets，简称Winsock，是Microsoft Windows操作系统中实现Berkeley Sockets接口的标准，它为开发者提供了一...
精通Windows Sockets网络开发：基于Visual C++实现
03-22
《精通Windows Sockets网络开发：基于Visual C++实现》是一本深入探讨网络编程技术的专著，主要聚焦于使用Microsoft的Visual C++编程环境来构建网络应用。Windows Sockets（通常简称为Winsock）是微软为Windows操作...
WindowsSockets规范及应用
08-30
Windows Sockets规范以U.C. Berkeley大学BSD UNIX中流行的Socket接口为范例定义了一套Micosoft Windows下网络编程接口。它不仅包含了人们所熟悉的Berkeley Socket风格的库函数；也包含了一组针对Windows的扩展库函数...
Windows Sockets网络编程-3
06-29
Windows Sockets网络编程 socket 编程
Windows Sockets概述
看星星凋零的博客
03-15 1331
1.Windows Sockets的优势：（1）Windows Sockets是一个开放的标准库；（2）Windows Sockets提供源代码可移植性；（3）Windows Sockets支持动态链接；动态链接库（DLL）是windows的重要特性，动态链接库是带有定义明确的接口的可执行过程的库，就像其名称所提示的那样，应用程序是在运行时动态链接这些库的，而不是在编译时静态链接。这种架构有诸多优...
Sockets是Windows下网络编程的规范，Windows Sockets是Windows下得到广泛应用的、开放的、支持多种协议的网络编程接口。详细用法讲解如下
最新发布
xzs1955的博客
08-09 1041
C#sockets用法详解。
Windows Socket介绍
马大叔的工作日记
08-24 3125
在windows平台上，创建网络应用程序通常会借助于Windows Sockets ，Sockets译为套接字，一个套接字是通信的一端，客户与服务器之间即可通过套接字彼此通信。Windows Sockets是Windows下网络编程的规范，简称Winsock，虽然不同的应用服务和所使用的应用协议均有所不同，但所有的网络程序都能简化为一个简单的Winsock网络编程模型。 要想使用Winsock创
Windows Sockets 规范及应用
xilyu的专栏
06-27 1337
转自http://blog.csdn.net/devillyd/archive/2006/12/05/1430987.aspx Windows   Sockets   规范及应用                           －Windows网络编程接口     *****************************************************************
Windows Sockets规范与应用详解
"WindowsSockets00规范及应用－Windows 网络编程接口" Windows Sockets，简称Winsock，是Microsoft Windows操作系统上的一种应用程序接口（API），用于实现网络通信。这个接口规范允许开发者使用标准的Socket接口...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值