• 编写HTTP协议代理的一些知识（源码）

    初级代码游戏的专栏介绍与文章目录-CSDN博客

            早期上网经常需要使用代理服务器，现在用的比较少了，大家更耳熟能详的反而是“反向代理”如Nginx。

            代理服务器一般用作局域网上网，而反向代理则是把来自互联网的连接转发到局域网上，作用刚好相反。

            HTTP协议自身就带有对代理服务器的支持。HTTP协议目前主要有多个版本，0.9太简单，基本不见了，1.0只支持一个连接一个请求，1.1则支持长连接，2.0极大复杂化了传输过程，支持多路复用。协议版本这么多，但是代理服务器作为中间商，可以选择一个较低的版本，用户的客户端和服务器一般都有能力适应多个版本。

            代理服务器可以选择比较简单的HTTP1.0版本，一个连接就是一个请求，只需要在连接建立之后做处理，处理完请求就是简单的数据转发了。

    目录

            HTTP1.0协议对代理服务器的支持基本就是两点：

            代理服务器要做的事情是：

            代理服务器认证

            隧道请求CONNECT

            代码示例

            HTTP1.0协议对代理服务器的支持基本就是两点：

    1. 请求行对使用绝对URL
    2. 专用于代理服务器的Proxy-XXXX头标

            代理服务器要做的事情是：

    1. 取出请求行的服务器域名和端口并擦除（擦除后与直接请求的请求行相同）
    2. 将协议版本降低为自己支持的版本
    3. 根据proxy-XXXX头标处理并擦除
    4. 像直接请求一样访问服务器
    5. 转发数据给用户

            前面说的“擦除”是把后面的数据前移而不是设置为空格，设置为空格并不符合HTTP协议，服务器一般不能理解。

            原则上代理服务器可以支持客户端和服务器是不同的协议版本，比如客户端是1.0而服务器是1.1，这将极大地影响程序复杂度。

            虽然HTTP的BODY与代理服务器处理无关，只需要接受完头部就可以处理，但是最好整个请求完整发送，因为有些服务器不能处理请求头和BODY分开的情形。

            代理服务器认证

            代理服务器通过Proxy-XXXX头标进行认证，这个认证是代理服务器的认证而不是用户要访问的服务器的认证。代理服务器认证完后就应该删除这些头标，因为这些头标对目标服务器毫无意义。

            隧道请求CONNECT

            CONNECT是个不常用的头标，专门用于代理。代理服务器取得目标服务器后直接连上去就可以了，然后就是双向转发数据。

            代码示例

            下面的代码就是一个HTTP1.0代理的协议处理部分的代码，没有认证（因为用的是IP地址认证，在进入这个代码之前就已经处理过了）：

    1. //servicethreadhttp.cpp
    2.  
    3. #include "stdafx.h"
    4. #include "mystd.h"
    5. #include "Proxy.h"
    6. #include "httpresp.h"
    7.  
    8. extern CProxyApp theApp;
    9.  
    10. //HTTP协议处理线程
    11. DWORD ServiceThreadHttp(LPDWORD lpdwParam)
    12. {
    13. //--线程参数处理------------------------
    14. 	int cdindex;//连接数据索引
    15. 	struct ServiceData * servicedata;
    16.  
    17. 	cdindex=((struct ThreadUserData *)lpdwParam)->index;
    18. 	servicedata=((struct ThreadUserData *)lpdwParam)->servicedata;
    19. //--------------------------------------
    20. 	struct ConnectionData * cd;
    21. 	struct LogStruct * logs;
    22.  
    23. 	cd=&servicedata->connectiondataarray.pconnectiondata[cdindex];
    24. 	if(-1!=cd->log)
    25. 	{
    26. 		logs=servicedata->memlogfile.logstruct+cd->log;
    27. 	}
    28. 	else
    29. 	{
    30. 		logs=NULL;
    31. 	}
    32. //----------------------------------------
    33. 	struct ConfigInfo * pci;
    34. 	pci=&servicedata->serviceconfigfiledata.configarray[cd->serviceindex];
    35.  
    36. 	int headlen;
    37. 	int port;
    38. 	char host[256];
    39. 	char uri[256];
    40. 	unsigned long addr;
    41. 	SOCKADDR_IN sa;
    42. 	BOOL isTunnel=FALSE;//是否是隧道请求
    43. 	char tunnelresponse[]="HTTP/1.0 200 Connection established\x0d\x0a"
    44. 		"Proxy-agent: FreeProxy 1.0\x0d\x0a\x0d\x0a";
    45.  
    46. 	//退出？
    47. 	if(CONNECTIONDATA_CMD_QUIT==cd->cmd)
    48. 	{
    49. 		closesocket(cd->sdc.s);
    50. 		if(-1!=cd->log)
    51. 		{
    52. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    53. 		}
    54. 		cd->state=CONNECTION_NOUSE;
    55. 		return (DWORD)-1;
    56. 	}
    57.  
    58. 	//接收请求
    59. 	cd->sdc.bufcount=RecvHttpRequest(cd->sdc.s,cd->sdc.buf,BUFFERSIZE,
    60. 		&cd->cmd,&headlen,pci->islimitpost,1000*pci->maxpost);
    61. 	if(0>cd->sdc.bufcount)
    62. 	{
    63. 		//DebugMessage("RecvHttpRequest失败");
    64. 		closesocket(cd->sdc.s);
    65. 		if(-1!=cd->log)
    66. 		{
    67. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    68. 		}
    69. 		cd->state=CONNECTION_NOUSE;
    70. 		return (DWORD)-1;
    71. 	}
    72.  
    73. 	//分析请求
    74. /*	char tracertfile[256];
    75. 	if(-1!=mymemindex(cd->sdc.buf,cd->sdc.bufcount,"says=%2Fnick",strlen("says=%2Fnick")))
    76. 	{
    77. 		strcpy(tracertfile,"tracert_");
    78. 		itoa(cdindex,tracertfile+strlen(tracertfile),10);
    79. 		if(-1!=cd->log)WriteTracertFile(tracertfile,logs->username,strlen(logs->username));
    80. 		WriteTracertFile(tracertfile,cd->sdc.buf,cd->sdc.bufcount);
    81. 	}*/
    82. 	if(0>GetHttpURL(cd->sdc.buf,&cd->sdc.bufcount,headlen+4,host,256,&port,uri,256))
    83. 	{
    84. 		if(pci->isenableconnect && 0<=GetTunnelURL(cd->sdc.buf,&cd->sdc.bufcount,headlen+4,host,256,&port,uri,256))
    85. 		{//是隧道请求
    86. 			isTunnel=TRUE;
    87. 			if(-1!=cd->log)
    88. 			{
    89. 				strcpy(logs->domainname,host);
    90. 			}
    91. 		}
    92. 		else
    93. 		{
    94. 			send(cd->sdc.s,httpresp400,strlen(httpresp400),0);
    95. 			closesocket(cd->sdc.s);
    96. 			if(-1!=cd->log)
    97. 			{
    98. 				logs->state=LOGSTRUCT_STATE_NOUSE;
    99. 			}
    100. 			cd->state=CONNECTION_NOUSE;
    101. 			return (DWORD)-2;
    102. 		}
    103. 	}
    104. 	else
    105. 	{
    106. 		if(-1!=cd->log)
    107. 		{
    108. 			strcpy(logs->domainname,host);
    109. 		}
    110. 	}
    111. 	ClearProxyInfo(cd->sdc.buf,&cd->sdc.bufcount);
    112.  
    113. 	//检查目标许可
    114. 	if(IsForbidden(&theApp.bandata,host,uri))
    115. 	{
    116. 		send(cd->sdc.s,httpresp403,strlen(httpresp403),0);
    117. 		closesocket(cd->sdc.s);
    118. 		if(-1!=cd->log)
    119. 		{
    120. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    121. 		}
    122. 		cd->state=CONNECTION_NOUSE;
    123. 		return (DWORD)-1;
    124. 	}
    125.  
    126. 	//退出？
    127. 	if(CONNECTIONDATA_CMD_QUIT==cd->cmd)
    128. 	{
    129. 		closesocket(cd->sdc.s);
    130. 		if(-1!=cd->log)
    131. 		{
    132. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    133. 		}
    134. 		cd->state=CONNECTION_NOUSE;
    135. 		return (DWORD)-1;
    136. 	}
    137.  
    138. 	//记录日志，计时开始
    139. 	if(-1!=cd->log)
    140. 	{
    141. 		time(&logs->timestart);
    142. 	}
    143.  
    144. 	//域名解析
    145. 	if(1!=GetAddrByHost(addr,host))
    146. 	{
    147. 		send(cd->sdc.s,httpresp600,strlen(httpresp600),0);
    148. 		closesocket(cd->sdc.s);
    149. 		if(-1!=cd->log)
    150. 		{
    151. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    152. 		}
    153. 		cd->state=CONNECTION_NOUSE;
    154. 		return (DWORD)-3;
    155. 	}
    156.  
    157. 	memcpy(&(sa.sin_addr.S_un.S_addr),&addr,4);
    158. 	sa.sin_family=AF_INET;
    159. 	sa.sin_port=htons((unsigned short)port);
    160.  
    161. 	//建立SOCKET
    162. 	if(INVALID_SOCKET==(cd->sdr.s=socket(AF_INET,SOCK_STREAM,0)))
    163. 	{
    164. 		send(cd->sdc.s,httpresp601,strlen(httpresp601),0);
    165. 		closesocket(cd->sdc.s);
    166. 		if(-1!=cd->log)
    167. 		{
    168. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    169. 		}
    170. 		cd->state=CONNECTION_NOUSE;
    171. 		return (DWORD)-4;
    172. 	}
    173.  
    174. 	//退出？
    175. 	if(CONNECTIONDATA_CMD_QUIT==cd->cmd)
    176. 	{
    177. 		closesocket(cd->sdc.s);
    178. 		closesocket(cd->sdr.s);
    179. 		if(-1!=cd->log)
    180. 		{
    181. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    182. 		}
    183. 		cd->state=CONNECTION_NOUSE;
    184. 		return (DWORD)-1;
    185. 	}
    186. 	
    187. 	//连接
    188. 	if(SOCKET_ERROR==connect(cd->sdr.s,(struct sockaddr *)&sa,sizeof(sa)))
    189. 	{
    190. 		send(cd->sdc.s,httpresp602,strlen(httpresp602),0);
    191. 		closesocket(cd->sdc.s);
    192. 		closesocket(cd->sdr.s);
    193. 		if(-1!=cd->log)
    194. 		{
    195. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    196. 		}
    197. 		cd->state=CONNECTION_NOUSE;
    198. 		return (DWORD)-5;
    199. 	}
    200. 	else
    201. 	{
    202. 		if(-1!=cd->log)
    203. 		{
    204. 			strcpy(logs->domainname,uri);
    205. 		}
    206. 	}
    207.  
    208. 	//退出？
    209. 	if(CONNECTIONDATA_CMD_QUIT==cd->cmd)
    210. 	{
    211. 		closesocket(cd->sdc.s);
    212. 		closesocket(cd->sdr.s);
    213. 		if(-1!=cd->log)
    214. 		{
    215. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    216. 		}
    217. 		cd->state=CONNECTION_NOUSE;
    218. 		return (DWORD)-1;
    219. 	}
    220. 	
    221. 	//发送请求
    222. 	if(isTunnel)
    223. 	{
    224. 		if(SOCKET_ERROR==send(cd->sdc.s,tunnelresponse,strlen(tunnelresponse),0))
    225. 		{
    226. 			send(cd->sdc.s,httpresp603,strlen(httpresp603),0);
    227. 			closesocket(cd->sdc.s);
    228. 			closesocket(cd->sdr.s);
    229. 			if(-1!=cd->log)
    230. 			{
    231. 				logs->state=LOGSTRUCT_STATE_NOUSE;
    232. 			}
    233. 			cd->state=CONNECTION_NOUSE;
    234. 			return (DWORD)-6;
    235. 		}
    236. 	}
    237. 	if(SOCKET_ERROR==send(cd->sdr.s,cd->sdc.buf,cd->sdc.bufcount,0))
    238. 	{
    239. 		send(cd->sdc.s,httpresp603,strlen(httpresp603),0);
    240. 		closesocket(cd->sdc.s);
    241. 		closesocket(cd->sdr.s);
    242. 		if(-1!=cd->log)
    243. 		{
    244. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    245. 		}
    246. 		cd->state=CONNECTION_NOUSE;
    247. 		return (DWORD)-6;
    248. 	}
    249. 	//记录字节数
    250. 	if(-1!=cd->log)
    251. 	{
    252. 		logs->bytecount+=cd->sdc.bufcount;
    253. 	}
    254. 	///
    255. 	TraceData(servicedata->isDataTrace,&servicedata->memlogfile.logdatatrace[cd->log].dc,cd->sdc.buf,cd->sdc.bufcount);
    256.  
    257. 	//退出？
    258. 	if(CONNECTIONDATA_CMD_QUIT==cd->cmd)
    259. 	{
    260. 		closesocket(cd->sdc.s);
    261. 		closesocket(cd->sdr.s);
    262. 		if(-1!=cd->log)
    263. 		{
    264. 			logs->state=LOGSTRUCT_STATE_NOUSE;
    265. 		}
    266. 		cd->state=CONNECTION_NOUSE;
    267. 		return (DWORD)-1;
    268. 	}
    269. 	
    270. 	//接收数据并发给客户
    271. 	TransData(cd->sdr.s,cd->sdc.s,cd->sdr.buf,BUFFERSIZE,&cd->cmd,&cd->sdr.bufcount,servicedata,cd);
    272. 	//记录字节数
    273. 	if(-1!=cd->log)
    274. 	{
    275. 		logs->bytecount+=cd->sdr.bufcount;
    276. 	}
    277.  
    278. 	closesocket(cd->sdc.s);
    279. 	closesocket(cd->sdr.s);
    280. 	if(-1!=cd->log)
    281. 	{
    282. 		time(&logs->timeend);
    283. 		logs->state=LOGSTRUCT_STATE_USED;
    284. 	}
    285. 	cd->state=CONNECTION_NOUSE;
    286. 	return 1;
    287. }
    288.  
    289. //接收HTTP请求（如果出错，不执行closesocket()）
    290. int RecvHttpRequest(SOCKET s,char * buf,int buflen,int * cmd,int* headlen,BOOL islimitpost,int maxpost)
    291. {
    292. 	maxpost+=1;
    293.  
    294. 	const char CRLF[]="\x0d\x0a";
    295. 	const char CRLFCRLF[]="\x0d\x0a\x0d\x0a";
    296. 	const char CONTENTLENGTH[]="Content-Length:";
    297. 	
    298. 	int recvcount=0;
    299. 	int temp;
    300. 	int recvall=0;
    301.  
    302. 	BOOL tempbool;
    303. 	struct timeval timeout;
    304. 	timeout.tv_sec=0;
    305. 	timeout.tv_usec=100000;
    306.  
    307.  
    308. 	for(;1;)
    309. 	{
    310. 		//退出？
    311. 		if(CONNECTIONDATA_CMD_QUIT==*cmd)
    312. 		{
    313. 			return -1;
    314. 		}
    315. 		if(1!=IsSocketReadReady(s,timeout,tempbool))
    316. 		{
    317. 			return -2;
    318. 		}
    319. 		if(tempbool)
    320. 		{
    321. 			recvcount=recv(s,buf+recvall,buflen-recvall,0);
    322. 		}
    323. 		else
    324. 		{
    325. 			continue;
    326. 		}
    327. 		if(SOCKET_ERROR==recvcount)
    328. 		{
    329. 			return -3;
    330. 		}
    331. 		else if(0==recvcount)
    332. 		{
    333. 			return -4;
    334. 		}
    335. 		recvall+=recvcount;
    336. 		//在使用后面代码段时使用CRLFCRLF,4，否则使用CRLF,2
    337. 		temp=mymemindex(buf,recvall,(char*)CRLFCRLF,4);
    338. 		if(-1!=temp)
    339. 		{
    340. 			*headlen=temp;
    341. 			break;
    342. 		}
    343. 	}
    344.  
    345. 	if(islimitpost && -1!=(temp=mymemindex(buf,*headlen,(char*)CONTENTLENGTH,15)))
    346. 	{
    347. 		long i;
    348. 		char len[10];
    349. 		
    350. 		if(-1==(i=mymemindex(buf+temp,buflen-temp,(char*)CRLF,2)))
    351. 		{
    352. 			return -5;
    353. 		}
    354. 		i-=strlen(CONTENTLENGTH);
    355. 		if(i>9)
    356. 		{
    357. 			return -6;
    358. 		}
    359. 		memcpy(len,buf+temp+strlen(CONTENTLENGTH),i);
    360. 		len[i]='\0';
    361. 		i=atoi(len);
    362. 		if(i>maxpost)
    363. 		{
    364. 			return -7;
    365. 		}
    366. 	}
    367.  
    368. 	return recvall;
    369. }
    370.  
    371. //取得URL
    372. int GetHttpURL(char* buf,int * buflenall,int buflen,char * host,int hostbuflen,int * port,char * uri,int uribuflen)
    373. {
    374. 	const char CRLF[]="\x0d\x0a";
    375.  
    376. 	int urlstart,urlend;
    377. 	int hoststart,hostend,hostlen;
    378. 	int portstart,portend,portlen;
    379. 	int pos;
    380. 	char str[10];
    381.  
    382. 	urlend=mymemindex(buf,buflen,(char*)CRLF,2);
    383. 	if(-1==(urlstart=mymemindex(buf,urlend,"http://",7)))
    384. 	{
    385. 		return -2;	
    386. 	}
    387. 	if(urlend-urlstart>=uribuflen)
    388. 	{
    389. 		memcpy(uri,buf+urlstart,uribuflen-1);
    390. 		uri[uribuflen-1]='\0';
    391. 	}
    392. 	else
    393. 	{
    394. 		memcpy(uri,buf+urlstart,urlend-urlstart);
    395. 		uri[urlend-urlstart]='\0';
    396. 	}
    397.  
    398. 	//得到主机名起始位置
    399. 	hoststart=urlstart+7;
    400. 	
    401. 	if(-1==(pos=mymemindex(buf+hoststart,urlend-hoststart,"/",1)))
    402. 	{
    403. 		return -3;
    404. 	}
    405. 	portend=pos+hoststart;
    406. 	pos=mymemindex(buf+hoststart,portend-hoststart,":",1);
    407. 	if(-1!=pos)//有端口
    408. 	{
    409. 		portstart=pos+hoststart+1;//得到端口起始位置
    410. 		hostend=pos+hoststart;
    411. 		portlen=portend-portstart;
    412. 		memcpy(str,buf+portstart,portlen);
    413. 		str[portlen]='\0';
    414. 		if(0==portlen) *port=80;//若端口长度为零，实际上无端口
    415. 		{
    416. 			if(0==(*port=atoi(str)))
    417. 				return -4;
    418. 		}
    419. 	}
    420. 	else//无端口
    421. 	{
    422. 		*port=80;
    423. 		hostend=portend;
    424. 	}
    425. 	hostlen=hostend-hoststart;
    426. 	if(hostlen>=hostbuflen)
    427. 		return -5;
    428. 	memcpy(host,buf+hoststart,hostlen);
    429. 	host[hostlen]='\0';
    430. 	
    431. 	//HTTP请求处理
    432. 	long i;
    433.  
    434. 	//降版本1.1为1.0
    435. 	if('1'==buf[urlend-1])
    436. 	{
    437. 		buf[urlend-1]='0';
    438. 	}
    439. 	//擦去URL
    440. 	i=portend-urlstart;
    441. 	memmove(buf+urlstart,buf+portend,*buflenall-portend);
    442. 	*buflenall-=i;
    443.  
    444. 	return hostlen;
    445. }
    446.  
    447. //取得隧道请求
    448. int GetTunnelURL(char* buf,int * buflenall,int buflen,char * host,int hostbuflen,int * port,char * uri,int uribuflen)
    449. {
    450. 	const char CRLF[]="\x0d\x0a";
    451.  
    452. 	int urlstart,urlend;
    453. 	int hoststart,hostend,hostlen;
    454. 	int portstart,portend,portlen;
    455. 	int pos;
    456. 	char str[10];
    457.  
    458. 	urlend=mymemindex(buf,buflen,(char*)CRLF,2);
    459. 	if(buflen<8 || 0!=memcmp(buf,"CONNECT",7))
    460. 		return -2;
    461. 	if(' '!=buf[7])
    462. 		return -2;
    463. 	for(urlstart=8;urlstart
    464. 	{
    465. 		if(' '!=buf[urlstart])
    466. 			break;
    467. 	}
    468.  
    469. 	if(urlend>=uribuflen)
    470. 	{
    471. 		memcpy(uri,buf,uribuflen-1);
    472. 		uri[uribuflen-1]='\0';
    473. 	}
    474. 	else
    475. 	{
    476. 		memcpy(uri,buf,urlend);
    477. 		uri[urlend]='\0';
    478. 	}
    479.  
    480. 	//得到主机名起始位置
    481. 	hoststart=urlstart;
    482. 	
    483. 	if(-1==(pos=mymemindex(buf+hoststart,urlend-hoststart,"/",1)))
    484. 	{
    485. 		return -3;
    486. 	}
    487. 	portend=pos+hoststart;
    488. 	pos=mymemindex(buf+hoststart,portend-hoststart,":",1);
    489. 	if(-1!=pos)//有端口
    490. 	{
    491. 		portstart=pos+hoststart+1;//得到端口起始位置
    492. 		hostend=pos+hoststart;
    493. 		portlen=portend-portstart;
    494. 		memcpy(str,buf+portstart,portlen);
    495. 		str[portlen]='\0';
    496. 		if(0==portlen) *port=80;//若端口长度为零，实际上无端口
    497. 		{
    498. 			if(0==(*port=atoi(str)))
    499. 				return -4;
    500. 		}
    501. 	}
    502. 	else//无端口
    503. 	{
    504. 		*port=80;
    505. 		hostend=portend;
    506. 	}
    507. 	hostlen=hostend-hoststart;
    508. 	if(hostlen>=hostbuflen)
    509. 		return -5;
    510. 	memcpy(host,buf+hoststart,hostlen);
    511. 	host[hostlen]='\0';
    512. 	
    513. 	//HTTP请求处理
    514. 	
    515. 	*buflenall=0;
    516.  
    517. 	return hostlen;
    518. }
    519.  
    520. //清除代理信息
    521. int ClearProxyInfo(char * buf,int * buflenall)
    522. {
    523. 	const char PROXYCONNECTION[]="Proxy-Connection";
    524. 	const char CRLF[]="\x0d\x0a";
    525. 	int i,j;
    526.  
    527. 	if(2>(i=mymemindex(buf,*buflenall,PROXYCONNECTION,strlen(PROXYCONNECTION))))return 1;//前面至少应有一个CRLF
    528. 	if(0!=memcmp(buf+i-2,CRLF,2))return 1;
    529. 	if(-1==(j=mymemindex(buf+i+strlen(PROXYCONNECTION),(*buflenall)-i-strlen(PROXYCONNECTION),CRLF,2)))
    530. 	{
    531. 		j=(*buflenall)-i-strlen(PROXYCONNECTION);
    532. 	}
    533. 	//擦去代理信息
    534. 	memmove(buf+i-2,buf+i+strlen(PROXYCONNECTION)+j,(*buflenall)-(i+strlen(PROXYCONNECTION)+j));
    535. 	*buflenall-=2+strlen(PROXYCONNECTION)+j;
    536. 	return 1;
    537. }

            主要就是这么几件事：取出目标地址和端口，擦除目标信息，降低版本为1.0，擦除Proxy-XXXX头标，连接目标，双向转发数据。

            这个代码是从实际项目中截取出来的。

    （这里是结束）

  • 相关阅读:
    数据结构和算法：分治
    【硬件通讯协议】SIP总线协议以及模拟(软件)SPI
    原神私服搭建服务器配置该如何选择
    美国疾控中心：持续减肥，降低32%患癌风险，降低48%癌死亡风险
    这些傻白甜的Linux命令，不会有人教你！
    计算机四级网络-网络技术-第六章 网络管理与网络安全
    gin框架初识
    SHAP 和 LIME 解释模型
    总结springboot启动jar，指定配置文件
    python排序算法（六）、希尔排序
  • 原文地址：https://blog.csdn.net/2301_77171572/article/details/133803245