WIN网络编程-重叠I/0服务器设计

最新推荐文章于 2024-08-17 15:58:24 发布
最新推荐文章于 2024-08-17 15:58:24 发布
阅读量275 收藏
点赞数
分类专栏： 网络通讯服务器设计 文章标签： 服务器 编程 网络 socket buffer events
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chshji666666/article/details/5050837
版权

///
// OverlappedServer.cpp文件

//基于重叠I/0模型的简单的回显TCP服务器，它接受客户端连接之后，将从客

//户端接收到的数据再发送给客户端。本例采用了单线程。

//使用重叠I/O模型必须使用WSASocket函数创建套接字,传送数据使用

//WSASend、WSARecv、WSARecvFrom

//WSASocket函数创建套接字，这个套接字允许多个I/O同时占用。并使用pBuff

//er->pSocket->nOutstandingOps来统计其上的I/O数量。

//其中SOCKET_OBJ结构用来记录与套接字相关的信息，BUFFER_OBJ记录I/O信息。

//程序每投递一个I/O请求，都要申请一个BUFFER_OBJ对象，使用嵌在对象中

//的OVERLAPPED结构。所有未完成的I/O请求对应的BUFFER_OBJ对象组成了一个

//表，表头指针为全局变量g_pBufferHead。

//提交重叠I/O是重叠模型的关键，通过调用AcceptEx、WSARecv和WSASend函

//数实现。提交这些I/O后，线程便在重叠结构中的事件对象上等等，一旦I/O完成

//事件受信，等待函数返回。

//WSAGetLastError函数报告了WSA_IO_PENDING出错状态，表示I/O操作正在进行。

//AccepEx函数将几个套接字函数的功能集合成在了一起。如果它投递的请求成功完成，则执行了3个操作：

//1、接受了新的连接

//2、新连接的本地地址和远程地址都会返回

//3、接收到了远程主机发来的第一块数据

//

#include "../common/initsock.h"

#include<Mswsock.h>
#include <stdio.h>
#include <windows.h>

CInitSock theSock;

#define BUFFER_SIZE 1024

typedef struct _SOCKET_OBJ
{
 SOCKETs;      //套节字句柄
 intnOutstandingOps;   //记录此套节字上的重叠I/O数量
 
 LPFN_ACCEPTEXlpfnAcceptEx;  //扩展函数AcceptEx的指针（仅对监听套节字而言）
} SOCKET_OBJ, *PSOCKET_OBJ;

//重叠I/O都要提交到特定套节字上。在这些I/O完成之前，对方关闭了连接，

//或者连接发生错误，释放对应的SOCEKET_OBJ对象。

typedef struct _BUFFER_OBJ
{
 OVERLAPPEDol;   //重叠结构
 char*buff;    //send/recv/AcceptEx所使用的缓冲区
 intnLen;    //buff的长度
 PSOCKET_OBJ pSocket; //此I/O所属的套节字对象

 intnOperation;   //提交的操作类型
#define OP_ACCEPT 1
#define OP_READ  2
#define OP_WRITE 3

 SOCKETsAccept;   //用来保存AcceptEx接受的客户套节字（仅对监听套节字而言）
 _BUFFER_OBJ *pNext;
} BUFFER_OBJ, *PBUFFER_OBJ;

HANDLEg_events[WSA_MAXIMUM_WAIT_EVENTS]; //I/O事件句柄数组
intg_nBufferCount;       //上数组中有效句柄数量
PBUFFER_OBJ g_pBufferHead, g_pBufferTail; //记录缓冲区对象组成的表的地址

// 申请套节字对象和释放套节字对象的函数
PSOCKET_OBJ GetSocketObj(SOCKET s)
{
 PSOCKET_OBJ pSocket =(PSOCKET_OBJ)::GlobalAlloc(GPTR, sizeof(SOCKET_OBJ));
 if(pSocket != NULL)
 {
  pSocket->s =s;
 }
 return pSocket;
}
void FreeSocketObj(PSOCKET_OBJ pSocket)
{
 if(pSocket->s !=INVALID_SOCKET)
  ::closesocket(pSocket->s);
 ::GlobalFree(pSocket);
}

PBUFFER_OBJ GetBufferObj(PSOCKET_OBJ pSocket,ULONG nLen)
{
 if(g_nBufferCount >WSA_MAXIMUM_WAIT_EVENTS - 1)
  return NULL;

 PBUFFER_OBJ pBuffer =(PBUFFER_OBJ)::GlobalAlloc(GPTR, sizeof(BUFFER_OBJ));
 if(pBuffer != NULL)
 {
  pBuffer->buff =(char*)::GlobalAlloc(GPTR, nLen);
  pBuffer->ol.hEvent= ::WSACreateEvent();
  pBuffer->pSocket= pSocket;
  pBuffer->sAccept= INVALID_SOCKET;

  //将新的BUFFER_OBJ添加到列表中
  if(g_pBufferHead == NULL)
  {
   g_pBufferHead= g_pBufferTail = pBuffer;
  }
  else
  {
   g_pBufferTail->pNext= pBuffer;
   g_pBufferTail= pBuffer;
  }
  g_events[++ g_nBufferCount] =pBuffer->ol.hEvent;
 }
 return pBuffer;
}

void FreeBufferObj(PBUFFER_OBJ pBuffer)
{
 // 从列表中移除BUFFER_OBJ对象
 PBUFFER_OBJ pTest = g_pBufferHead;
 BOOL bFind = FALSE;
 if(pTest == pBuffer)
 {
  g_pBufferHead = g_pBufferTail =NULL;
  bFind = TRUE;
 }
 else
 {
  while(pTest != NULL&& pTest->pNext !=pBuffer)
   pTest =pTest->pNext;
  if(pTest != NULL)
  {
   pTest->pNext= pBuffer->pNext;
   if(pTest->pNext== NULL)
    g_pBufferTail= pTest;
   bFind =TRUE;
  }
 }
 // 释放它占用的内存空间
 if(bFind)
 {
  g_nBufferCount --;
  ::CloseHandle(pBuffer->ol.hEvent);
  ::GlobalFree(pBuffer->buff);
  ::GlobalFree(pBuffer);
 }
}

PBUFFER_OBJ FindBufferObj(HANDLE hEvent)
{
 PBUFFER_OBJ pBuffer = g_pBufferHead;
 while(pBuffer != NULL)
 {
  if(pBuffer->ol.hEvent== hEvent)
   break;
  pBuffer =pBuffer->pNext;
 }
 return pBuffer;
}

void RebuildArray()
{
 PBUFFER_OBJ pBuffer = g_pBufferHead;
 int i =  1;
 while(pBuffer != NULL)
 {
  g_events[i++] =pBuffer->ol.hEvent;
  pBuffer =pBuffer->pNext;
 }
}

BOOL PostAccept(PBUFFER_OBJ pBuffer)
{
 PSOCKET_OBJ pSocket =pBuffer->pSocket;
 if(pSocket->lpfnAcceptEx !=NULL)
 {
  // 设置I/O类型，增加套节字上的重叠I/O计数
  pBuffer->nOperation= OP_ACCEPT;
  pSocket->nOutstandingOps++;

  //投递此重叠I/O
  DWORD dwBytes;
  pBuffer->sAccept=
   ::WSASocket(AF_INET,SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
  BOOL b =pSocket->lpfnAcceptEx(pSocket->s,
   pBuffer->sAccept,
   pBuffer->buff,
   BUFFER_SIZE -((sizeof(sockaddr_in) + 16) * 2),
   sizeof(sockaddr_in)+ 16,
   sizeof(sockaddr_in)+ 16,
   &dwBytes,
   &pBuffer->ol);
  if(!b)
  {
   if(::WSAGetLastError()!= WSA_IO_PENDING)
    returnFALSE;
  }
  return TRUE;
 }
 return FALSE;
};

BOOL PostRecv(PBUFFER_OBJ pBuffer)
{
 // 设置I/O类型，增加套节字上的重叠I/O计数
 pBuffer->nOperation =OP_READ;
 pBuffer->pSocket->nOutstandingOps++;

 // 投递此重叠I/O
 DWORD dwBytes;
 DWORD dwFlags = 0;
 WSABUF buf;
 buf.buf = pBuffer->buff;
 buf.len = pBuffer->nLen;
 if(::WSARecv(pBuffer->pSocket->s,&buf, 1, &dwBytes,&dwFlags,&pBuffer->ol, NULL) !=NO_ERROR)
 {
  if(::WSAGetLastError() !=WSA_IO_PENDING)
   returnFALSE;
 }
 return TRUE;
}

BOOL PostSend(PBUFFER_OBJ pBuffer)
{
 // 设置I/O类型，增加套节字上的重叠I/O计数
 pBuffer->nOperation =OP_WRITE;
 pBuffer->pSocket->nOutstandingOps++;

 // 投递此重叠I/O
 DWORD dwBytes;
 DWORD dwFlags = 0;
 WSABUF buf;
 buf.buf = pBuffer->buff;
 buf.len = pBuffer->nLen;
 if(::WSASend(pBuffer->pSocket->s,
   &buf,1, &dwBytes, dwFlags,&pBuffer->ol, NULL) !=NO_ERROR)
 {
  if(::WSAGetLastError() !=WSA_IO_PENDING)
   returnFALSE;
 }
 return TRUE;
}

BOOL HandleIO(PBUFFER_OBJ pBuffer)
{
 PSOCKET_OBJ pSocket =pBuffer->pSocket; //从BUFFER_OBJ对象中提取SOCKET_OBJ对象指针，为的是方便引用
 pSocket->nOutstandingOps--;

 // 获取重叠操作结果
 DWORD dwTrans;
 DWORD dwFlags;
 BOOL bRet =::WSAGetOverlappedResult(pSocket->s,&pBuffer->ol,&dwTrans, FALSE, &dwFlags);
 if(!bRet)
 {
  //在此套节字上有错误发生，因此，关闭套节字，移除此缓冲区对象。
  //如果没有其它抛出的I/O请求了，释放此缓冲区对象，否则，等待此套节字上的其它I/O也完成
  if(pSocket->s !=INVALID_SOCKET)
  {
   ::closesocket(pSocket->s);
   pSocket->s= INVALID_SOCKET;
  }

  if(pSocket->nOutstandingOps== 0)
   FreeSocketObj(pSocket);
 
  FreeBufferObj(pBuffer);
  return FALSE;
 }

 // 没有错误发生，处理已完成的I/O
 switch(pBuffer->nOperation)
 {
 case OP_ACCEPT: //接收到一个新的连接，并接收到了对方发来的第一个封包
  {
   //为新客户创建一个SOCKET_OBJ对象
   PSOCKET_OBJpClient = GetSocketObj(pBuffer->sAccept);

   //为发送数据创建一个BUFFER_OBJ对象，这个对象会在套节字出错或者关闭时释放
   PBUFFER_OBJpSend = GetBufferObj(pClient, BUFFER_SIZE);
   if(pSend ==NULL)
   {
    printf("Too much connections! /n");
    FreeSocketObj(pClient);
    returnFALSE;
   }
   RebuildArray();
  
   //将数据复制到发送缓冲区
   pSend->nLen= dwTrans;
   memcpy(pSend->buff,pBuffer->buff, dwTrans);

   //投递此发送I/O（将数据回显给客户）
   if(!PostSend(pSend))
   {
    //万一出错的话，释放上面刚申请的两个对象
    FreeSocketObj(pSocket);
    FreeBufferObj(pSend);
    returnFALSE;
   }
   //继续投递接受I/O
   PostAccept(pBuffer);
  }
  break;
 case OP_READ: // 接收数据完成
  {
   if(dwTrans> 0)
   {
    //创建一个缓冲区，以发送数据。这里就使用原来的缓冲区
    PBUFFER_OBJpSend = pBuffer;
    pSend->nLen= dwTrans;
   
    //投递发送I/O（将数据回显给客户）
    PostSend(pSend);
   }
   else //套节字关闭
   {
 
    //必须先关闭套节字，以便在此套节字上投递的其它I/O也返回
    if(pSocket->s!= INVALID_SOCKET)
    {
     ::closesocket(pSocket->s);
     pSocket->s= INVALID_SOCKET;
    }

    if(pSocket->nOutstandingOps== 0)
     FreeSocketObj(pSocket); 
   
    FreeBufferObj(pBuffer);
    returnFALSE;
   }
  }
  break;
 caseOP_WRITE:  // 发送数据完成
  {
   if(dwTrans> 0)
   {
    //继续使用这个缓冲区投递接收数据的请求
    pBuffer->nLen= BUFFER_SIZE;
    PostRecv(pBuffer);
   }
   else //套节字关闭
   {
    //同样，要先关闭套节字
    if(pSocket->s!= INVALID_SOCKET)
    {
     ::closesocket(pSocket->s);
     pSocket->s= INVALID_SOCKET;
    }

    if(pSocket->nOutstandingOps== 0)
     FreeSocketObj(pSocket);

    FreeBufferObj(pBuffer);
    returnFALSE;
   }
  }
  break;
 }
 return TRUE;
}


void main()
{
 // 创建监听套节字，绑定到本地端口，进入监听模式
 int nPort = 4567;
 SOCKET sListen =
  ::WSASocket(AF_INET,SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);

//plisten可被多个重叠I/O占用
 SOCKADDR_INsi;
 si.sin_family = AF_INET;
 si.sin_port = ::ntohs(nPort);
 si.sin_addr.S_un.S_addr = INADDR_ANY;
 ::bind(sListen, (sockaddr*)&si,sizeof(si));
 ::listen(sListen, 200);

 // 为监听套节字创建一个SOCKET_OBJ对象
 PSOCKET_OBJ pListen = GetSocketObj(sListen);

 // 加载扩展函数AcceptEx
 GUID GuidAcceptEx = WSAID_ACCEPTEX;
 DWORD dwBytes;
 WSAIoctl(pListen->s,
  SIO_GET_EXTENSION_FUNCTION_POINTER,
  &GuidAcceptEx,
  sizeof(GuidAcceptEx),
  &pListen->lpfnAcceptEx,
  sizeof(pListen->lpfnAcceptEx),
  &dwBytes,
  NULL,
  NULL);

 // 创建用来重新建立g_events数组的事件对象
 g_events[0] = ::WSACreateEvent();

 // 在此可以投递多个接受I/O请求
 for(int i=0; i<5; i++)
 {
  PostAccept(GetBufferObj(pListen,BUFFER_SIZE));
 }
 ::WSASetEvent(g_events[0]);
 
 while(TRUE)
 {
  int nIndex =
   ::WSAWaitForMultipleEvents(g_nBufferCount+ 1, g_events, FALSE, WSA_INFINITE, FALSE);
  if(nIndex ==WSA_WAIT_FAILED)
  {
   printf("WSAWaitForMultipleEvents()failed /n");
   break;
  }
  nIndex = nIndex -WSA_WAIT_EVENT_0;
  for(int i=0;i<=nIndex; i++)
  {
   int nRet =::WSAWaitForMultipleEvents(1, &g_events[i], TRUE,0, FALSE);
   if(nRet ==WSA_WAIT_TIMEOUT)
    continue;
   else
   {
    ::WSAResetEvent(g_events[i]);
    //重新建立g_events数组
    if(i== 0)
    {
     RebuildArray();
     continue;
    }

    //处理这个I/O
    PBUFFER_OBJpBuffer = FindBufferObj(g_events[i]);
    if(pBuffer!= NULL)
    {
     if(!HandleIO(pBuffer))
      RebuildArray();
    }
   }
  }
 }
}

 

chshji666666
关注
专栏目录
socket通信之六：Overlapped I/O 事件通知模型实现的客户/服务器模型
09-02 3360
1.基于事件通知模型的Overlapped I/O(重叠IO模型) 概括一点说，重叠模型是让应用程序使用重叠数据结构(WSAOVERLAPPED)，一次投递一个或多个Winsock I/O请求。针对这些提交的请求，在它们完成之后，应用程序会收到通知，于是就可以通过自己另外的代码来处理这些数据了。       需要注意的是，有两个方法可以用来管理重叠IO请求的完成情况（就是说接到
Windows网络编程-I/O模式
zhenpeanut的博客
03-03 416
首先说明什么是Windows套接字模式. 其分为两类:阻塞模式/非阻塞模式. 阻塞模式:I/O操作完成前执行操作的WinSock调用会一直等候下去,不会立即返回到程序中. 非阻塞模式:WinSock函数无论如何都会立即返回. 对阻塞套接字 他的一个缺点在于,应用程序很难同时通过多个建好连接的套接字通信,使用前述的方案,可对应用程序进行修改,令其为连接好的每个套接字都分配一个读线程,以及一个数据处理...
基于重叠I/O模型的服务器实践(以事件驱动)
Datura_Metel的博客
04-18 398
服务器端#include "winsock2.h"#pragma comment(lib, "ws2_32.lib")#include &lt;iostream&gt;using namespace std;#define MAXDATASIZE 200int main(){    WSABUF DataBuf;    char buffer[MAXDATASIZE];    DWORD Even...
windows套接字I/0模型-重叠IO(overlapped)模型
人饭子的博客
05-08 795
BOOL WSAGetOverlappedResult( SOCKET s,//套接字 LPWSAOVERLAPPED lpOverlapped,//重叠结构 LPDWORD lpcbTransfer,//对应一个DWORD（双字节）变量，一次重叠实际传输(接收或者发送)的字节数 BOOL fWait,//参数用于决定函数是否应该等待一次重叠操作完成。// 记录缓冲区对象组成的表的地址。// 如果没有其它抛出的I/O请求了，释放此缓冲区对象，否则，等待此套节字上的其它I/O也完成。
WinSock 异步I/O模型[4]---重叠 I/O - Overlapped I/O
小米的修行之路
02-17 911
在 Winsock 中，重叠 I/O（Overlapped I/O）模型能达到更佳的系统性能，高于之前讲过的三种。因为它和这3种模型不同的是，使用重叠模型的应用程序通知缓冲区收发系统直接使用数据。也就是说，如果应用程序投递了一个10KB大小的缓冲区来接收数据，且数据已经到达套接字，则该数据将直接被拷贝到投递的缓冲区。而这3种模型中，数据到达并拷贝到单套接字接收缓冲区（Per Socket Buff
Windows下重叠I/O模型
汽车电子软件领域知识分享
12-28 473
目录一.Windows下重叠I/O模型二．重叠模型的优点三．重叠模型的基本原理五、实现重叠模型的步骤六. 客户端情况的注意事项七．已知问题 原文链接：https://blog.csdn.net/zhongguoren666/article/details/1827928 在此感谢原作者。 一.Windows下重叠I/O模型 重叠模型的优点 重叠模型的基本原理 关于重叠模型的基础知识 重叠模型的实现步骤 多客户端情况的注意事项 二．重叠模型的优点 可以运行在支持Winsock2的所有Window
windows网络编程------，重叠io，完成端口
qq_40140790的博客
05-05 1254
在了解完成端口之前，我们先要了解重叠io（完成端口是基于重叠io上实现的） 重叠io，即执行I/O请求的时间与线程执行其他任务的时间是重叠(overlapped)的。我们正常的的socket是socket到达后，系统通知我们socket到了，然后我们用recv把socket缓存里面的信息复制到内存上来，这个io的步骤就花了可观的时间，但cpu的占用却很少，就不能想个办法在我们读写的时候还能做其他...
网络编程——其他套接字I/O模型编程
LSYZWF的博客
04-26 600
文章目录目的内容源代码及结果 目的 (1) 掌握Windows下异步通知I/O模型编程方法； (2) 掌握Windows下重叠I/O模型编程方法； (3) 掌握Windows下完成端口模型编程方法； 内容 (1) 使用异步通知I/O模型实现回声服务器端(及客户端)； (2) 使用异步通知I/O模型编写聊天服务器端(及客户端)； (3) 使用重叠I/O模型实现回声服务器端(及客户端)； (4) 使用重叠I/O模型编写聊天服务器端(及客户端)； (5) 使用完成端口模型实现回声服务器端(及客户端)； (6
TCP/IP网络编程 - 读书笔记
最新发布
喜欢就关注吧
08-17 476
TCP/IP读书笔记
网络编程实用教程(第三版).zip
06-10
1.1　网络编程相关的基本概念　1 1.1.1　网络编程与进程通信　1 1.1.2　Internet中网间进程的标识　3 1.1.3　网络协议的特征　7 1.2　三类网络编程　10 1.2.1　基于TCP/IP协议栈的网络编程　10 1.2.2　基于WWW应用的...
Windows Socket编程：五种I/O模型详解
"Windows操作系统为开发网络应用程序的程序员提供了五种不同的I/O模型，包括选择(Select)、异步选择(WSAAsyncSelect)、事件选择(WSAEventSelect)、重叠I/O(Overlapped I/O)以及完成端口(Completion Port)。...
PostQueuedCompletionStatus函数与GetQueuedCompletionStatus函数
05-10 2189
<br />PostQueuedCompletionStatus函数，向每个工作者线程都发送—个特殊的完成数据包。该函数会指示每个线程都“立即结束并退出”.下面是PostQueuedCompletionStatus函数的定义：<br />BOOL PostQueuedCompletionStatus(<br />    HANDLE CompletlonPort,<br />    DW0RD dwNumberOfBytesTrlansferred,<br />    DWORD dwCompletlonK
WSAEnumProtocols的用法
09-07 860
#include #include #pragma comment(lib, "ws2_32.lib") void main(void) { WSADATA wsaData; WSAStartup( MAKEWORD( 2, 2 ), &w
泡泡堂、QQ堂游戏通信架构分析
04-08 690
之前，我分析过QQ游戏（特指QQ休闲平台，并非QQ堂，下同）的通信架构（http://blog.csdn.net/sodme/archive/2005/06/12/393165.aspx），分析过魔兽世界的通信架构（http://blog.csdn.net/sodme/archive/2005/06/18/397371.aspx），似乎网络游戏的通信架构也就是这些了，其实不然，在网络游戏大家庭中，还有一种类型的游戏我认为有必要把它的通信架构专门作个介绍，这便是如泡泡堂、QQ堂类的休闲类竞技游戏。曾经很多次，
封包和拆包
10-19 463
对于基于TCP开发的通讯程序,有个很重要的问题需要解决,就是封包和拆包.自从我从事网络通讯编程工作以来(大概有三年的时间了),我一直在思索和改进封包和拆包的方法.下面就针对这个问题谈谈我的想法,抛砖引玉.若有不对,不妥之处,恳求大家指正.在此先谢过大家了.一.为什么基于TCP的通讯程序需要进行封包和拆包.TCP是个"流"协议,所谓流,就是没有界限的一串数据.大家可以想想河里的流水,是连成一片的,其间是没有分界线的.但一般通讯程序开发是需要定义一个个相互独立的数据包的,比如用于登陆的数据包,用于注销的数据包.
accept不阻塞的原因
04-14 440
在用这段代码的时候发现accept总是在没有连接就直接返回了：int clientAddrLen = 0;cSocket = accept(lSocket,(SOCKADDR*)&clientAddr,&clientAddrLen);弄了N久后才发现是这个问题，之前看MSDN还以为第三个参数只是对外传的呢，汗这段代码就OK了int clientAddrLen = sizeof(SOCKADDR);cSocket = accept(lSocket,(SOCKADDR*)&clientAddr,&clientA
飞鸽传书系列 一 “无法解析外部符号 __security_cookie”问题解决
08-10 405
编译VC工程时出现了标题所示问题，资料搜索一下，在微软网站找到答案了，解决方法如下： 1）选择“项目”-》“属性”-》“C/C++”-》“代码生成”-》“缓冲区安全检查”，设为“否” 2）选择“项目”-》“属性”-》“链接器”-》“输入”-》“附加依赖项”，增加”buffer
内存管理（AWE）——完成端口通讯服务器（IOCP Socket Server）设计（二）
04-16 403
有牛人曾经说过，服务器玩的就是内存。仔细想想，确实是如此。服务器对内存的需求是巨大的，对内存的要求也是苛刻的。如何在内存管理上下功夫使服务器性能达到一个质的飞跃，是服务器设计中的首要解决的问题。说到内存，我想刚开始设计服务器的人会说，不就申请释放吗，有什么难呢。从操作步骤来说，确实就这么两个，没有再多了的工作了。当我们采用虚拟内存分配或堆分配从操作系统获取内存的时候，总以为我们获得了足够的内存就可以让服务器安心工作了。但事情并未就这么简单，操作系统在一定条件下，还可以征用已经分配给你的物理内存，它会将你的物
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值