一、服務端和客戶端
BS架構 （騰訊通軟件：server+client）
CS架構 （web網站）
?
C/S架構與socket的關系：
我們學習socket就是為了完成C/S架構的開發
?
二、OSI七層模型
互聯網協議按照功能不同分為osi七層或tcp/ip五層或tcp/ip四層
?
每層運行常見物理設備
?
詳細參考：
http://www.cnblogs.com/linhaifeng/articles/5937962.html#_label4
?
學習socket一定要先學習互聯網協議：
1.首先：本節課程的目標就是教會你如何基于socket編程，來開發一款自己的C/S架構軟件
2.其次：C/S架構的軟件（軟件屬于應用層）是基于網絡進行通信的
3.然后：網絡的核心即一堆協議，協議即標準，你想開發一款基于網絡通信的軟件，就必須遵循這些標準。
4.最后：就讓我們從這些標準開始研究，開啟我們的socket編程之旅
TCP/IP協議族包括運輸層、網絡層、鏈路層。
?
三、socket層，不懂看圖就明白了。
Socket是介于應用層和傳輸層之間。
四、socket是什么
Socket是應用層與TCP/IP協議族通信的中間軟件抽象層，它是一組接口。在設計模式中，Socket其實就是一個門面模式，它把復雜的TCP/IP協議族隱藏在Socket接口后面，對用戶來說，一組簡單的接口就是全部，讓Socket去組織數據，以符合指定的協議。
所以，我們無需深入理解tcp/udp協議，socket已經為我們封裝好了，我們只需要遵循socket的規定去編程，寫出的程序自然就是遵循tcp/udp標準的。
?掃盲篇：
1 將socket說成ip+port，ip是用來標識互聯網中的一臺主機的位置，而port是用來標識這臺機器上的一個應用程序，ip地址是配置到網卡上的，而port是應用程序開啟的，ip與port的綁定就標識了互聯網中獨一無二的一個應用程序 2 3 而程序的pid是同一臺機器上不同進程或者線程的標識（Google Chrome會有多個PID）
?
五、套接字發展史及分類
套接字起源于 20 世紀 70 年代加利福尼亞大學伯克利分校版本的 Unix,即人們所說的 BSD Unix。 因此,有時人們也把套接字稱為“伯克利套接字”或“BSD 套接字”。一開始,套接字被設計用在同 一臺主機上多個應用程序之間的通訊。這也被稱進程間通訊,或 IPC。套接字有兩種（或者稱為有兩個種族）,分別是基于文件型的和基于網絡型的。?
?
1、基于文件類型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字調用的就是底層的文件系統來取數據，兩個套接字進程運行在同一機器，可以通過訪問同一個文件系統間接完成通信
?
2、基于網絡類型的套接字家族
套接字家族的名字：AF_INET
(還有AF_INET6被用于ipv6，還有一些其他的地址家族，不過，他們要么是只用于某個平臺，要么就是已經被廢棄，或者是很少被使用，或者是根本沒有實現，所有地址家族中，AF_INET是使用最廣泛的一個，python支持很多種地址家族，但是由于我們只關心網絡編程，所以大部分時候我么只使用AF_INET)
?
六、套接字工作流程
? ? ? 生活中的場景，你要打電話給一個朋友，先撥號，朋友聽到電話鈴聲后提起電話，這時你和你的朋友就建立起了連接，就可以講話了。等交流結束，掛斷電話結束此次交談。????
生活中的場景就解釋了這工作原理，也許TCP/IP協議族就是誕生于生活中，這也不一定。
?
先從服務器端說起。服務器端先初始化Socket，然后與端口綁定(bind)，對端口進行監聽(listen)，調用accept阻塞，等待客戶端連接。在這時如果有個客戶端初始化一個Socket，然后連接服務器(connect)，如果連接成功，這時客戶端與服務器端的連接就建立了。客戶端發送數據請求，服務器端接收請求并處理請求，然后把回應數據發送給客戶端，客戶端讀取數據，最后關閉連接，一次交互結束。
?
1、socket模塊發送和接收消息
示例：模擬發送消息和接收消息的過程
tcp服務端（server）
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligeimport socketphone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #買手機 phone.bind(('127.0.0.1',8000)) #綁定手機卡 #改成服務端網卡IP地址和端口 phone.listen(5) #開機 5的作用是最大掛起連接數 #backlog連接池（也叫半鏈接） print('------------->') conn,addr=phone.accept() #等電話 msg=conn.recv(1024) #收消息 print('客戶端發來的消息是：',msg) conn.send(msg.upper()) #發消息 conn.close() phone.close()
?
執行結果：
------------->
tcp客戶端(client)
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligeimport socketphone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)phone.connect(('127.0.0.1',8000)) #拔通電話 #改成服務端網卡IP地址和端口 phone.send('hello'.encode('utf-8')) #發消息 data=phone.recv(1024) print('收到服務端的發來的消息: ',data)phone.close()
?
?
執行結果：
收到服務端的發來的消息: b'HELLO'
2、tcp三次握手和四次揮手
主動斷開連接 ：FIN_WAIT_1
被動斷開連接： FIN_WAIT_2
馬上斷開連接： TIME_WAIT
?
socket中TCP的三次握手建立連接詳解
流程如下：
- 客戶端向服務器發送一個SYN J
- 服務器向客戶端響應一個SYN K，并對SYN J進行確認ACK J+1
- 客戶端再向服務器發一個確認ACK K+1
只有就完了三次握手，但是這個三次握手發生在socket的那幾個函數中呢？請看下圖：
? ? ? ? ? ? ? ? ? ? 圖1、socket中發送的TCP三次握手
從圖中可以看出，當客戶端調用connect時，觸發了連接請求，向服務器發送了SYN J包，這時connect進入阻塞狀態；服務器監聽到連接請求，即收到SYN J包，調用accept函數接收請求向客戶端發送SYN K ，ACK J+1，這時accept進入阻塞狀態；客戶端收到服務器的SYN K ，ACK J+1之后，這時connect返回，并對SYN K進行確認；服務器收到ACK K+1時，accept返回，至此三次握手完畢，連接建立。
總結：客戶端的connect在三次握手的第二個次返回，而服務器端的accept在三次握手的第三次返回。
?
socket中TCP的四次握手釋放連接詳解
上面介紹了socket中TCP的三次握手建立過程，及其涉及的socket函數。現在我們介紹socket中的四次握手釋放連接的過程，請看下圖：
? ? ? ? ? ? ? ? ?圖2、socket中發送的TCP四次握手
圖示過程如下：
- 某個應用進程首先調用close主動關閉連接，這時TCP發送一個FIN M；
- 另一端接收到FIN M之后，執行被動關閉，對這個FIN進行確認。它的接收也作為文件結束符傳遞給應用進程，因為FIN的接收意味著應用進程在相應的連接上再也接收不到額外數據；
- 一段時間之后，接收到文件結束符的應用進程調用close關閉它的socket。這導致它的TCP也發送一個FIN N；
- 接收到這個FIN的源發送端TCP對它進行確認。
這樣每個方向上都有一個FIN和ACK。
?
總結：
四次揮手斷開連接原則：
記住一條原則：誰先發起客戶端請求，誰先斷開連接
但是在大并發情況下，大部分都是服務端先斷開連接，不會保留連接。因為每一分鐘都有很多人在訪問網站。
?
3、socket()模塊函數用法
import socket socket.socket(socket_family,socket_type,protocal=0) socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默認值為 0。獲取tcp/ip套接字 tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)獲取udp/ip套接字 udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)由于 socket 模塊中有太多的屬性。我們在這里破例使用了'from module import *'語句。使用 'from socket import *',我們就把 socket 模塊里的所有屬性都帶到我們的命名空間里了,這樣能 大幅減短我們的代碼。 例如tcpSock = socket(AF_INET, SOCK_STREAM)
?
服務端套接字函數
s.bind() ? ? 綁定(主機,端口號)到套接字
s.listen() ? ?開始TCP監聽
s.accept() 被動接受TCP客戶的連接,(阻塞式)等待連接的到來
客戶端套接字函數
s.connect() ? ? ? ? ? ? ? ? ? ? ? 主動初始化TCP服務器連接
s.connect_ex() connect() ?函數的擴展版本,出錯時返回出錯碼,而不是拋出異常
公共用途的套接字函數
s.recv() ? ? ? ? 接收TCP數據
s.send() ? ? ? ?發送TCP數據(send在待發送數據量大于己端緩存區剩余空間時,數據丟失,不會發完)
s.sendall() ? ? 發送完整的TCP數據(本質就是循環調用send,sendall在待發送數據量大于己端緩存區剩余空間時,數據不丟失,循環調用send直到發完)
s.recvfrom() ?接收UDP數據
s.sendto() ? ? 發送UDP數據
s.getpeername() ? 連接到當前套接字的遠端的地址
s.getsockname() ? 當前套接字的地址
s.getsockopt() ? ? ?返回指定套接字的參數
s.setsockopt() ? ? ? 設置指定套接字的參數
s.close() ? ? ? ? ? ? ? 關閉套接字
面向鎖的套接字方法
s.setblocking() ? 設置套接字的阻塞與非阻塞模式
s.settimeout() ? ?設置阻塞套接字操作的超時時間
s.gettimeout() ? ?得到阻塞套接字操作的超時時間
面向文件的套接字的函數
s.fileno() ? ? ? ?套接字的文件描述符
s.makefile() ? 創建一個與該套接字相關的文件
?
七、基于TCP的套接字
tcp語法格式：
tcp服務端
ss = socket() #創建服務器套接字 ss.bind() #把地址綁定到套接字 ss.listen() #監聽鏈接 inf_loop: #服務器無限循環cs = ss.accept() #接受客戶端鏈接comm_loop: #通訊循環cs.recv()/cs.send() #對話(接收與發送)cs.close() #關閉客戶端套接字 ss.close() #關閉服務器套接字(可選)
?
tcp客戶端
cs = socket() #創建客戶套接字 cs.connect() #嘗試連接服務器 comm_loop: #通訊循環cs.send()/cs.recv() #對話(發送/接收) cs.close() #關閉客戶套接字
?
?
1、基于tcp實現：客戶端發送空格，服務端也會接收
示例：
tcp_server端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import *ip_port = ('127.0.0.1', 8080) back_log = 5 buffer_size = 1024tcp_server = socket(AF_INET, SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)print('服務端開始運行了') conn, addr = tcp_server.accept() #服務器阻塞 print('雙向鏈接是', conn) print('客戶端地址', addr)while True:data = conn.recv(buffer_size) #收緩存為空，則阻塞print('客戶端發來的消息是', data.decode('utf-8'))conn.send(data.upper()) conn.close()tcp_server.close()
?
tcp_client端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import *ip_port = ('127.0.0.1', 8080) back_log = 5 buffer_size = 1024tcp_client = socket(AF_INET, SOCK_STREAM) tcp_client.connect(ip_port)while True:msg = input('>>:') #發送空格到自己的發送緩存中# msg=input('>>:').strip() #去掉空格tcp_client.send(msg.encode('utf-8'))print('客戶端已經發送消息')data = tcp_client.recv(buffer_size) #收緩存為空則阻塞print('收到服務端發來的消息是', data.decode('utf-8'))tcp_client.close()
?
執行結果：
?View Code?
實驗過程中遇到的問題：
在重啟服務端時可能會遇到如下報錯：
這個是由于你的服務端仍然存在四次揮手的time_wait狀態在占用地址（如果不懂，請深入研究1.tcp三次握手，四次揮手 2.syn洪水攻擊 3.服務器高并發情況下會有大量的time_wait狀態的優化方法）。
解決方法：
法一：在程序中處理
1 #加入一條socket配置，重用ip和端口
2
3 phone=socket(AF_INET,SOCK_STREAM)
4 phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
5 phone.bind(('127.0.0.1',8080)) ?
法二：在linux系統中，通過調整系統內核參數的方式來解決
發現系統存在大量TIME_WAIT狀態的連接，通過調整linux內核參數解決，系統優化的一個優化點）vi /etc/sysctl.conf編輯文件，加入以下內容： net.ipv4.tcp_syncookies = 1 net.ipv4.tcp_tw_reuse = 1 net.ipv4.tcp_tw_recycle = 1 net.ipv4.tcp_fin_timeout = 30然后執行 /sbin/sysctl -p 讓參數生效。net.ipv4.tcp_syncookies = 1 表示開啟SYN Cookies。當出現SYN等待隊列溢出時，啟用cookies來處理，可防范少量SYN攻擊，默認為0，表示關閉；net.ipv4.tcp_tw_reuse = 1 表示開啟重用。允許將TIME-WAIT sockets重新用于新的TCP連接，默認為0，表示關閉；net.ipv4.tcp_tw_recycle = 1 表示開啟TCP連接中TIME-WAIT sockets的快速回收，默認為0，表示關閉。net.ipv4.tcp_fin_timeout = 30 修改系統默認的 TIMEOUT 時間
?
八、基于UDP的套接字
udp語法格式：
udp服務端
1 ss = socket() #創建一個服務器的套接字 2 ss.bind() #綁定服務器套接字 3 inf_loop: #服務器無限循環 4 cs = ss.recvfrom()/ss.sendto() # 對話(接收與發送) 5 ss.close()
udp客戶端
1 cs = socket() # 創建客戶套接字 2 comm_loop: # 通訊循環 3 cs.sendto()/cs.recvfrom() # 對話(發送/接收) 4 cs.close() # 關閉客戶套接字
?
1、基于upd實現方法
示例：
udp_server端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * ip_port=('127.0.0.1',8080) buffer_size = 1024udp_server = socket(AF_INET,SOCK_DGRAM) #數據報套接字 udp_server.bind(ip_port)while True:data,addr=udp_server.recvfrom(buffer_size)print(data)udp_server.sendto(data.upper(),addr) #upper() 小寫變大寫
?
udp_client端：
from socket import * ip_port=('127.0.0.1',8080) #服務端IP+端口 buffer_size = 1024udp_client=socket(AF_INET,SOCK_DGRAM) #udp數據報套接字while True:msg=input('>>:').strip()udp_client.sendto(msg.encode('utf-8'),ip_port)#數據，ip地址+端口data,addr=udp_client.recvfrom(buffer_size)print(data.decode('utf-8'))
?
執行結果：
先運行udp_server，再運行udp_client。
服務端返回結果：
1 b'sfdsfds' #bytes類型 2 b'fdsfds' 3 b'fsdfds' 4 b'sdfdsf'
在客戶端輸入：
1 >>:sfdsfds #在客戶端輸入 2 SFDSFDS #服務端返回的結果，把客戶端輸入的字符變大寫 3 4 >>:fdsfds 5 FDSFDS 6 7 >>:fsdfds 8 FSDFDS
?
2、實現ntp時間服務器
示例：
tup_server端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nulige#實現ntp時間服務器 import time from socket import * ip_port=('127.0.0.1',8080) buffer_size = 1024udp_server = socket(AF_INET,SOCK_DGRAM) #數據報套接字 udp_server.bind(ip_port)while True:data,addr=udp_server.recvfrom(buffer_size)print(data)if not data:fmt='%Y-%m-%d %X' #如果用戶沒有輸入時間，就返回默認格式else:fmt=data.decode('utf-8')back_time=time.strftime(fmt)udp_server.sendto(back_time.encode('utf-8'),addr)
?
udp_client端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * ip_port=('127.0.0.1',8080) #服務端IP+端口 buffer_size = 1024udp_client=socket(AF_INET,SOCK_DGRAM) #數據報套接字while True:msg=input('>>:').strip()udp_client.sendto(msg.encode('utf-8'),ip_port)data,addr=udp_client.recvfrom(buffer_size)print('ntp服務器的標準時間是',data.decode('utf-8'))
?
執行結果：
運行udp_server,再運行udp_client,然后在udp_client里輸入：
1 >>:%Y #在客戶端輸入%Y 2 ntp服務器的標準時間是 2017 #就會返回服務端的時間 3 >>:%m-%d-%Y 4 ntp服務器的標準時間是 01-03-2017 5 >>:
?
3、基于tcp實現遠程執行命令
備注：因系統差異，請盡量把程序放在linux服務器上面運行，windows上面可能會報錯。
socket_server_tcp服務端 (在linux上面運行）
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import subprocessip_port = ('192.168.1.135', 8000) back_log = 5 buffer_size = 1024tcp_server = socket(AF_INET, SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)while True:conn,addr=tcp_server.accept()print('新的客戶端鏈接',addr)while True:#收try:cmd=conn.recv(buffer_size)#if not cmd:break MAC筆記本處理方法print('收到客戶端的命令',cmd)#執行命令，得到命令的運行結果cmd_resres=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE,stdin=subprocess.PIPE)err=res.stderr.read()if err:cmd_res=errelse:cmd_res=res.stdout.read()#發 conn.send(cmd_res)except Exception as e:print(e)break conn.close()
?
socket_client_tcp客戶端（windows系統上面運行）
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import *# ip_port = ('127.0.0.1', 8082) ip_port = ('192.168.1.135', 8000) back_log = 5 buffer_size = 1024tcp_client = socket(AF_INET, SOCK_STREAM) tcp_client.connect(ip_port)while True:cmd=input('>>:').strip()if not cmd:continueif cmd == 'quit':breaktcp_client.send(cmd.encode('utf-8'))cmd_res=tcp_client.recv(buffer_size)# print('命令的執行結果是 ',cmd_res.decode('gbk'))print('命令的執行結果是 ',cmd_res.decode('utf-8')) tcp_client.close()
?
執行結果：
在客戶端執行命令：
>>:df -h命令的執行結果是 Filesystem Size Used Avail Use% Mounted on/dev/sda3 9.6G 1.8G 7.3G 20% /tmpfs 931M 0 931M 0% /dev/shm/dev/sda1 190M 32M 149M 18% /boot/dev/sr0 4.4G 4.4G 0 100% /opt>>:dir命令的執行結果是 s3.py server_ssh.py socket_server.py server.py socket_clinet_udp.py socket_server_udp.py服務端返回結果： [root@python3 scripts]# python socket_server.py 新的客戶端鏈接 ('192.168.1.115', 53569) 收到客戶端的命令 b'df -h' 收到客戶端的命令 b'dir'
?
4、基于udp實現遠程執行命令
socket_server_udp服務端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import subprocessip_port = ('192.168.1.135', 8000) back_log = 5 buffer_size = 1024udp_server = socket(AF_INET, SOCK_DGRAM) udp_server.bind(ip_port)while True:cmd,addr=udp_server.recvfrom(buffer_size)print(cmd)#執行命令，得到命令的運行結果cmd_resres = subprocess.Popen(cmd.decode('utf-8'), shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE,stdin=subprocess.PIPE)err = res.stderr.read()if err:cmd_res = errelse:cmd_res = res.stdout.read()if not cmd_res: # 判斷為空的情況cmd_res = '執行成功'.encode('gbk') #linux改成utf-8print(cmd_res)#發udp_server.sendto(cmd_res,addr)
?
socket_clinet_udp客戶端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import *ip_port = ('192.168.1.135', 8000) # ip_port = ('192.168.12.63', 8000) back_log = 5 buffer_size = 10240udp_client = socket(AF_INET, SOCK_DGRAM)while True:cmd=input('>>:').strip()if not cmd:continueif cmd == 'quit':breakudp_client.sendto(cmd.encode('utf-8'),ip_port)cmd_res,addr=udp_client.recvfrom(buffer_size)print('命令的執行結果是 ',cmd_res.decode('gbk')) #如果在linux上面運行，把gbk改成utf-8 udp_client.close()
?
執行結果：
?View Code?
九、recv與recvfrom的區別
1、收發原理詳解：
發消息：都是將數據發送到己端的發送緩沖中
收消息：都是從己端的緩沖區中收
?
2、發消息二者類似，收消息確實有區別的？
tcp協議：send發消息，recv收消息
（1）如果收消息緩沖區里的數據為空，那么recv就會阻塞
（2）tcp基于鏈接通信，如果一端斷開了鏈接，那另外一端的鏈接也跟著完蛋recv將不會阻塞，收到的是空
?
udp協議：sendto發消息，recvfrom收消息
（1）如果如果收消息緩沖區里的數據為“空”，recvfrom不會阻塞
（2）recvfrom收的數據小于sendinto發送的數據時，數據丟失
（3）只有sendinto發送數據沒有recvfrom收數據，數據丟失
?
注意：
1.你單獨運行上面的udp的客戶端，你發現并不會報錯，相反tcp卻會報錯，因為udp協議只負責把包發出去，對方收不收，我根本不管，而tcp是基于鏈接的，必須有一個服務端先運行著，客戶端去跟服務端建立鏈接然后依托于鏈接才能傳遞消息，任何一方試圖把鏈接摧毀都會導致對方程序的崩潰。
2.上面的udp程序，你注釋任何一條客戶端的sendinto，服務端都會卡住，為什么？因為服務端有幾個recvfrom就要對應幾個sendinto，哪怕是sendinto(b'')那也要有。
?
3.總結：
1.udp的sendinto不用管是否有一個正在運行的服務端，可以己端一個勁的發消息
2.udp的recvfrom是阻塞的，一個recvfrom(x)必須對一個一個sendinto(y),收完了x個字節的數據就算完成,若是y>x數據就丟失，這意味著udp根本不會粘包，但是會丟數據，不可靠
3.tcp的協議數據不會丟，己端總是在收到ack時才會清除緩沖區內容。數據是可靠的，但是會粘包。
?
十、粘包
須知：只有TCP有粘包現象，UDP永遠不會粘包。（原因詳見第3點）
1、socket收發消息的原理
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ??? ? ?socket發送原理圖
?
2、為什么會出現所謂的粘包
原因：接收方不知道消息之間的界限，不知道一次性提取多少字節的數據所造成的。
此外，發送方引起的粘包是由TCP協議本身造成的，TCP為提高傳輸效率，發送方往往要收集到足夠多的數據后才發送一個TCP段。若連續幾次需要send的數據都很少，通常TCP會根據優化算法把這些數據合成一個TCP段后一次發送出去，這樣接收方就收到了粘包數據。
- TCP（transport control protocol，傳輸控制協議）是面向連接的，面向流的，提供高可靠性服務。收發兩端（客戶端和服務器端）都要有一一成對的socket，因此，發送端為了將多個發往接收端的包，更有效的發到對方，使用了優化方法（Nagle算法），將多次間隔較小且數據量小的數據，合并成一個大的數據塊，然后進行封包。這樣，接收端，就難于分辨出來了，必須提供科學的拆包機制。 即面向流的通信是無消息保護邊界的。
- UDP（user datagram protocol，用戶數據報協議）是無連接的，面向消息的，提供高效率服務。不會使用塊的合并優化算法，, 由于UDP支持的是一對多的模式，所以接收端的skbuff(套接字緩沖區）采用了鏈式結構來記錄每一個到達的UDP包，在每個UDP包中就有了消息頭（消息來源地址，端口等信息），這樣，對于接收端來說，就容易進行區分處理了。?即面向消息的通信是有消息保護邊界的。
- tcp是基于數據流的，于是收發的消息不能為空，這就需要在客戶端和服務端都添加空消息的處理機制，防止程序卡住，而udp是基于數據報的，即便是你輸入的是空內容（直接回車），那也不是空消息，udp協議會幫你封裝上消息頭。
?
3、tcp會發生粘包的兩種情況如下：
1、發送端多次send間隔較短，并且數據量較小，tcp會通過Nagls算法，封裝成一個包，發送到接收端，接收端不知道這個包由幾部分組成，所以就會產生粘包。
2、數據量發送的大，接收端接收的小，再接一次，還會出現上次沒有接收完成的數據。就會出現粘包。
?
示例1：?發送端多次send間隔較短，并且數據量較小，tcp會通過Nagls算法，封裝成一個包，發送到接收端，接收端不知道這個包由幾部分組成，所以就會產生粘包。
server服務端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * ip_port=('127.0.0.1',8082) back_log=5 buffer_size=1024tcp_server=socket(AF_INET,SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)conn,addr=tcp_server.accept()data1=conn.recv(buffer_size) #指定buffer_size ,得到的結果就是通過Nagle算法，隨機接收次數。 print('第1次數據',data1)data2=conn.recv(buffer_size) print('第2次數據',data2)data3=conn.recv(buffer_size) print('第3次數據',data3)
?
client客戶端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import timeip_port=('127.0.0.1',8082) back_log=5 buffer_size=1024tcp_client=socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port)tcp_client.send('hello'.encode('utf-8')) tcp_client.send('world'.encode('utf-8')) tcp_client.send('egon'.encode('utf-8'))time.sleep(1000)
?
執行結果：
第1次數據 b'helloworldegon' #不確定接收次數。
?
示例2：指定接收字節數，相當于服務端知道接收長度，就不會出現粘包現象
粘包服務端
from socket import * ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_server=socket(AF_INET,SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)conn,addr=tcp_server.accept()data1=conn.recv(5) #指定每次接收字節數，就不會出現粘包現象 print('第一次數據',data1)data2=conn.recv(5) print('第2次數據',data2)data3=conn.recv(5) print('第3次數據',data3)
?
粘包客戶端
from socket import * import time ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_client=socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port)tcp_client.send('hello'.encode('utf-8')) tcp_client.send('world'.encode('utf-8')) tcp_client.send('egon'.encode('utf-8'))time.sleep(1000)
?
執行結果：
1 第1次數據 b'hello' #不會出現粘包現象，發送三次，就接收三次 2 第2次數據 b'world' 3 第3次數據 b'egon'
?
示例3：數據量發送的大，接收端接收的小，再接一次，還會出現上次沒有接收完成的數據。就會出現粘包。
粘包服務端
from socket import * ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_server=socket(AF_INET,SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)conn,addr=tcp_server.accept()data1=conn.recv(1) print('第1次數據',data1)# data2=conn.recv(5) # print('第2次數據',data2) # # data3=conn.recv(1) # print('第3次數據',data3)
?
粘包客戶端
from socket import * import time ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024 #接收的數據只有1024 tcp_client=socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port)tcp_client.send('helloworldegon'.encode('utf-8'))time.sleep(1000)
?
執行結果：?
1 第1次數據 b'h' 2 第2次數據 b'ellow' #發送的數據過大，接收的數據設置的較小，就會出現導致粘包 3 第3次數據 b'o'
?
4、udp永遠不會粘包
示例：
udp不粘包服務端
from socket import * ip_port=('127.0.0.1',8080) buffer_size=1024udp_server=socket(AF_INET,SOCK_DGRAM) #數據報 udp_server.bind(ip_port)data1=udp_server.recvfrom(10) print('第1次',data1)data2=udp_server.recvfrom(10) print('第2次',data2)data3=udp_server.recvfrom(10) print('第3次',data3)data4=udp_server.recvfrom(2) print('第4次',data4)
?
udp不粘包客戶端
from socket import * ip_port=('127.0.0.1',8080) buffer_size=1024udp_client=socket(AF_INET,SOCK_DGRAM) #udp叫數據報 udp_client.sendto(b'hello',ip_port) udp_client.sendto(b'world',ip_port) udp_client.sendto(b'egon',ip_port)
?
?執行結果：
1 第1次 (b'hello', ('127.0.0.1', 57813)) #udp沒有Nagle優化算法
2 第2次 (b'world', ('127.0.0.1', 57813)) #每次都是一次獨立的包，所以不會出現粘包現象
3 第3次 (b'egon', ('127.0.0.1', 57813)) ?
5、qq聊天(由于udp無連接，所以可以同時多個客戶端去跟服務端通信)
udp_socket_server服務端代碼：
#實現類似于QQ聊天功能#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligeimport socket ip_port=('127.0.0.1',8081) udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) udp_server_sock.bind(ip_port)while True:qq_msg,addr=udp_server_sock.recvfrom(1024)print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))back_msg=input('回復消息: ').strip()udp_server_sock.sendto(back_msg.encode('utf-8'),addr)
?
udp_socket_client客戶端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligeimport socket BUFSIZE=1024 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)qq_name_dic={'努力哥':('127.0.0.1',8081),'劉哥':('127.0.0.1',8081),'李哥':('127.0.0.1',8081),'王哥':('127.0.0.1',8081), }while True:qq_name=input('請選擇聊天對象: ').strip() #選擇字典中的聊天對象，再發送消息while True:msg=input('請輸入消息,回車發送: ').strip()if msg == 'quit':breakif not msg or not qq_name or qq_name not in qq_name_dic:continueudp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))udp_client_socket.close()
?
執行結果：
先啟動服務端,再啟動客戶端向服務端發送消息：
#客戶端發送消息請選擇聊天對象: 努力哥 請輸入消息,回車發送: 吃飯沒有 來自[127.0.0.1:8081]的一條消息:還沒吃呢 請輸入消息,回車發送: #服務端接收消息來自[127.0.0.1:62642]的一條消息:吃飯沒有 回復消息: 還沒吃呢
?
補充知識：
1、tcp是可靠傳輸
tcp在數據傳輸時，發送端先把數據發送到自己的緩存中，然后協議控制將緩存中的數據發往對端，對端返回一個ack=1，發送端則清理緩存中的數據，對端返回ack=0，則重新發送數據，所以tcp是可靠的。
?
2、udp是不可靠傳輸
?udp發送數據，對端是不會返回確認信息的，因此不可靠。
?
十一、解決粘包的辦法
法一：比較(LOW)版本
?示例：
low_socket_server服務端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nulige#low版解決粘包版本服務端 from socket import * import subprocess ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_server=socket(AF_INET,SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)while True:conn,addr=tcp_server.accept()print('新的客戶端鏈接',addr)while True:#收消息try:cmd=conn.recv(buffer_size)if not cmd:breakprint('收到客戶端的命令',cmd)#執行命令，得到命令的運行結果cmd_resres=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE,stdin=subprocess.PIPE)err=res.stderr.read()if err:cmd_res=errelse:cmd_res=res.stdout.read()#發送消息if not cmd_res:cmd_res='執行成功'.encode('gbk')length=len(cmd_res) #計算長度conn.send(str(length).encode('utf-8')) #把長度發給客戶端client_ready=conn.recv(buffer_size) #卡著一個recvif client_ready == b'ready': #如果收到客戶端的ready消息，就說明準備好了。conn.send(cmd_res) #就可以send給客戶端發送消息啦！except Exception as e:print(e)break
?
low_socket_client客戶端
執行結果：
?View Code總結：
（為何low): ?程序的運行速度遠快于網絡傳輸速度，所以在發送一段字節前，先用send去發送該字節流長度，這種方式會放大網絡延遲帶來的性能損耗。
?
法二：節省網絡傳輸版本（牛逼版本）
為字節流加上自定義固定長度報頭，報頭中包含字節流長度，然后一次send到對端，對端在接收時，先從緩存中取出定長的報頭，然后再取真實數據。
示例：(沒實現多客戶端并發）
?tcp_socket_server服務端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import subprocess import struct ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_server=socket(AF_INET,SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)while True:conn,addr=tcp_server.accept()print('新的客戶端鏈接',addr)while True:#收try:cmd=conn.recv(buffer_size)if not cmd:breakprint('收到客戶端的命令',cmd)#執行命令，得到命令的運行結果cmd_resres=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE,stdin=subprocess.PIPE)err=res.stderr.read()if err:cmd_res=errelse:cmd_res=res.stdout.read()#發if not cmd_res:cmd_res='執行成功'.encode('gbk')length=len(cmd_res)data_length=struct.pack('i',length)conn.send(data_length)conn.send(cmd_res)except Exception as e:print(e)break
?
?tcp_socket_client客戶端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import struct from functools import partial ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_client=socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port)while True:cmd=input('>>: ').strip()if not cmd:continueif cmd == 'quit':breaktcp_client.send(cmd.encode('utf-8'))#解決粘包length_data=tcp_client.recv(4)length=struct.unpack('i',length_data)[0]recv_size=0recv_data=b''while recv_size < length:recv_data+=tcp_client.recv(buffer_size)recv_size=len(recv_data)print('命令的執行結果是 ',recv_data.decode('gbk')) tcp_client.close()
?
執行結果：
?View Code?
十二、用到的相關模塊知識講解
?1、subprocess模塊
subprocess 作用：啟動一個新的進程并與之通信
?語法：
subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)
?參數：
Popen類： ? ?用Popen來創建進程，并與進程進行復雜的交互
shell=True: ?指定的命令行會通過shell來執行
stdin : ? 標準輸入
stdout : 標準輸出
stderr : ?標準錯誤的文件句柄
PIPE : ? ?管道 ,默認值 為: None, 表示不做重定向，管道可以用來接收數據。
?
?示例1：執行dir命令，就會交給shell解釋器執行
import subprocess #導入模塊 命令： >>> subprocess.Popen("dir", shell=True) #執行dir命令，交給shell解釋器執行 執行結果： <subprocess.Popen object at 0x00A7B950>Directory of C:\Python3.5 2016/11/21 14:14 <DIR> . 2016/11/21 14:14 <DIR> .. 2016/11/21 14:14 <DIR> DLLs 2016/11/21 14:14 <DIR> Doc 2016/11/21 14:14 <DIR> include 2016/11/21 14:14 <DIR> Lib 2016/11/21 14:14 <DIR> libs 2016/06/25 22:08 30,345 LICENSE.txt 2016/06/25 21:48 340,667 NEWS.txt 2016/06/25 22:02 39,576 python.exe 2016/06/25 22:02 51,864 python3.dll 2016/06/25 22:02 3,127,960 python35.dll 2016/06/25 22:02 39,576 pythonw.exe 2016/06/25 21:48 8,282 README.txt 2016/11/21 14:14 <DIR> Scripts 2016/11/21 14:14 <DIR> tcl 2016/11/21 14:14 <DIR> Tools 2016/03/17 22:48 85,840 vcruntime140.dll8 File(s) 3,724,110 bytes10 Dir(s) 211,565,547,520 bytes free
?
示例2：subprocess 把標準輸出放入管道中，屏幕上就不會輸出內容
示例2：把標準輸出放入管道中，屏幕上就不會輸出內容。 res=subprocess.Popen("dir", shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE) #執行dir命令，交給shell解釋器執行，通過標準類型和subprocess.PIPE放入管道中。>>> res.stdout.read() #讀取管道里面的數據，在程序中，讀取也不會輸出到屏幕上。 執行結果： b' Volume in drive C has no label.\r\n Volume Serial Number is 4C49-9FA8\r\n\r\n Directory of C:\\Python3.5\r\n\r\n2016/11/21 14:14 <DIR> .\r\n2016/11/21 14:14 <DIR> ..\r\n2016/11/21 14:14 <DIR> DLLs\r\n2016/11/21 14:14 <DIR> Doc\r\n2016/11/21 14:14 <DIR> include\r\n2016/11/21 14:14 <DIR> Lib\r\n2016/11/21 14:14 <DIR> libs\r\n2016/06/25 22:08 30,345 LICENSE.txt\r\n2016/06/25 21:48 340,667 NEWS.txt\r\n2016/06/25 22:02 39,576 python.exe\r\n2016/06/25 22:02 51,864 python3.dll\r\n2016/06/25 22:02 3,127,960 python35.dll\r\n2016/06/25 22:02 39,576 pythonw.exe\r\n2016/06/25 21:48 8,282 README.txt\r\n2016/11/21 14:14 <DIR> Scripts\r\n2016/11/21 14:14 <DIR> tcl\r\n2016/11/21 14:14 <DIR> Tools\r\n2016/03/17 22:48 85,840 vcruntime140.dll\r\n 8 File(s) 3,724,110 bytes\r\n 10 Dir(s) 211,560,914,944 bytes free\r\n'>>> res.stdout.read() #再read一次，內容就為空，說明讀取完成啦！ b'' #顯示為：bytes類型
?
?示例3：subprocess 執行一個系統沒有的命令，就會產生正常的輸出
#執行一個系統沒有的命令，就會產生正常的輸出>>> res=subprocess.Popen("sfsfdsfdsfs", shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)>>> res.stdout.read() #讀取沒有內容 b''>>> res.stderr.read() #有正常的輸出 b"'sfsfdsfdsfs' is not recognized as an internal or external command,\r\noperable program or batch file.\r\n"
?
?
2、struct模塊
struct模塊作用：解決bytes和其他二進制數據類型的轉換
示例用法：
struct.pack('i',12)
參數說明：
pack函數作用：把任意數據類型變成bytes
i 表示4字節無符號整數。
示例1：
>>> import struct >>> struct.pack('i',12) #把后面的整形數據，封裝成一個bytes類型 b'\x0c\x00\x00\x00' #長度就是4>>> l=struct.pack('i',12313123) >>> len(l) 4 #長度就是4
?
?示例2：
>>> struct.pack('i',1) b'\x01\x00\x00\x00'#反解 >>> struct.unpack('i',l) (12313123,)#查看類型 >>> l=struct.pack('i',1) >>> type(l) <class 'bytes'> #bytes類型
?
?
Format Characters(格式化字符)：
| Format | C Type | Python type | Standard size | Notes |
|---|---|---|---|---|
x | pad byte | no value | ? | ? |
c | char | bytes of length 1 | 1 | ? |
b | signed?char | integer | 1 | (1),(3) |
B | unsigned?char | integer | 1 | (3) |
? | _Bool | bool | 1 | (1) |
h | short | integer | 2 | (3) |
H | unsigned?short | integer | 2 | (3) |
i | int | integer | 4 | (3) |
I | unsigned?int | integer | 4 | (3) |
l | long | integer | 4 | (3) |
L | unsigned?long | integer | 4 | (3) |
q | long?long | integer | 8 | (2), (3) |
Q | unsigned?long?long | integer | 8 | (2), (3) |
n | ssize_t | integer | ? | (4) |
N | size_t | integer | ? | (4) |
e | (7) | float | 2 | (5) |
f | float | float | 4 | (5) |
d | double | float | 8 | (5) |
s | char[] | bytes | ? | ? |
p | char[] | bytes | ? | ? |
P | void?* | integer | ? | (6) |
?
詳細用法參考：
http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431955007656a66f831e208e4c189b8a9e9f3f25ba53000
官方文檔參考：(英文文檔）
https://docs.python.org/3/library/struct.html#format-characters
?
3、urandom模塊
作用：產生隨機數
>>> import os
>>> os.urandom(32) #產生32位字節隨機數
b'=\xbcC\xa3\xe0\xd5\x12\xe4CZ?\xd9Q{\x97\x89g7lvD\xd4\xed\xd8\xeau\xc1\x9c\xb6\xd8fR' ?
示例：使用md5 + os.urandom(n) 產生隨機字符串
import os from hashlib import md5for i in range(5): #循環幾次就產生幾次隨機數print(md5(os.urandom(32)).hexdigest())
執行結果：
1fc70d335903283e1ac8165a28fbdddb 7a1305507f485e4d3c03f4e0c200ab6d 824db1b1076302f46166bbd93c41f0dd a350c246781d5a6139d18df267e50485 f38fb315a24e33d1703df81fe6b7a4e2
?
十三、socket 實現并發
SocketServer是基于socket寫成的一個更強大的模塊。
SocketServer簡化了網絡服務器的編寫。它有4個類：TCPServer，UDPServer，UnixStreamServer，UnixDatagramServer。這4個類是同步進行處理的，另外通過ForkingMixIn和ThreadingMixIn類來支持異步。
?
在python3中該模塊是socketserver
在python2中該模塊是Socketserver
分情況導入導入模塊 try:import socketserver #Python 3 except ImportError:import SocketServer #Python 2
服務器
服務器要使用處理程序，必須將其出入到服務器對象，定義了5個基本的服務器類型(就是“類”)。BaseServer，TCPServer，UnixStreamServer，UDPServer，UnixDatagramServer。注意：BaseServer不直接對外服務。
?
關系如下：
?服務器：
要使用處理程序，必須將其傳入到服務器的對象，定義了四個基本的服務器類。
（1）TCPServer(address,handler)?? 支持使用IPv4的TCP協議的服務器，address是一個（host,port）元組。Handler是BaseRequestHandler或StreamRequestHandler類的子類的實例。
（2）UDPServer(address,handler)?? 支持使用IPv4的UDP協議的服務器，address和handler與TCPServer中類似。
（3）UnixStreamServer(address,handler)?? 使用UNIX域套接字實現面向數據流協議的服務器，繼承自TCPServer。
（4）UnixDatagramServer(address,handler)? 使用UNIX域套接字實現數據報協議的服務器，繼承自UDPServer。
?
這四個類的實例都有以下方法。
1、s.socket?? 用于傳入請求的套接字對象。
2、s.sever_address? 監聽服務器的地址。如元組（"127.0.0.1",80）
3、s.RequestHandlerClass ? 傳遞給服務器構造函數并由用戶提供的請求處理程序類。
4、s.serve_forever() ?處理無限的請求 ?#無限處理client連接請求
5、s.shutdown() ? 停止serve_forever()循環
?
SocketServer模塊中主要的有以下幾個類：
1、BaseServer??? 包含服務器的核心功能與混合類（mix-in）的鉤子功能。這個類主要用于派生，不要直接生成這個類的類對象，可以考慮使用TCPServer和UDPServer類。
2、TCPServer ? ? 基本的網絡同步TCP服務器
3、UDPServer ? ? 基本的網絡同步UDP服務器
4、ForkingTCPServer?? ?是ForkingMixIn與TCPServer的組合
5、ForkingUDPServer 是ForkingMixIn與UDPServer的組合
6、ThreadingUDPServer 是ThreadingMixIn和UDPserver的組合
7、ThreadingTCPServer 是ThreadingMixIn和TCPserver的組合
8、BaseRequestHandler 必須創建一個請求處理類，它是BaseRequestHandler的子類并重載其handle()方法。
9、StreamRequestHandler ? ? ?實現TCP請求處理類的
10、DatagramRequestHandler 實現UDP請求處理類的
11、ThreadingMixIn 實現了核心的線程化功能，用于與服務器類進行混合(mix-in)，以提供一些異步特性。不要直接生成這個類的對象。
12、ForkingMixIn ? 實現了核心的進程化功能，用于與服務器類進行混合(mix-in)，以提供一些異步特性。不要直接生成這個類的對象。
?
關系圖如下：
創建服務器的步驟：
1：首先必須創建一個請求處理類
2：它是BaseRequestHandler的子類
3：該請求處理類是BaseRequestHandler的子類并重新寫其handle()方法
?
實例化 ?請求處理類傳入服務器地址和請求處理程序類
最后實例化調用serve_forever() ?#無限處理client請求
?
記住一個原則：對tcp來說：self.request=conn
示例：
1、tcp_socket_server服務端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nulige#服務端已經實現并發，處理客戶端請求import socketserverclass MyServer(socketserver.BaseRequestHandler): #基本的通信循環def handle(self):print('conn is: ',self.request) #與client的鏈接請求信息print('addr is: ',self.client_address) #獲取client的地址和端口號#通信循環while True:#收消息data=self.request.recv(1024)print('收到客戶端的消息是',data)#發消息 self.request.sendall(data.upper())if __name__ == '__main__':s=socketserver.ThreadingTCPServer(('127.0.0.1',8000),MyServer) #開啟多線程，綁定地址，和處理通信的類s.serve_forever() #連接循環
?
tcp_socket_client客戶端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * ip_port=('127.0.0.1',8000) back_log=5 buffer_size=1024tcp_client=socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port)while True:msg=input('>>: ').strip()if not msg:continueif msg == 'quit':breaktcp_client.send(msg.encode('utf-8'))data=tcp_client.recv(buffer_size)print('收到服務端發來的消息: ',data.decode('utf-8'))tcp_client.close()
?
執行結果：
開啟一個服務端程序，再開多個客戶端，向服務器發送命令：
#客戶端1 >>: hello #輸入要發送的消息 收到服務端發來的消息: HELLO#客戶端2 >>: word 收到服務端發來的消息: WORD#服務端 conn is: <socket.socket fd=412, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8000), raddr=('127.0.0.1', 62813)> addr is: ('127.0.0.1', 62813) 收到客戶端的消息是 b'hello' #客戶端收到的消息 conn is: <socket.socket fd=256, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8000), raddr=('127.0.0.1', 62816)> addr is: ('127.0.0.1', 62816) 收到客戶端的消息是 b'word'
?
?
2、udp實現并發
記住一個原則：對udp來說：self.request=(client_data_bytes,udp的套接字對象)
實例：
?udp_socket_server服務端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligeimport socketserverclass MyServer(socketserver.BaseRequestHandler):def handle(self):print(self.request)print('收到客戶端的消息是',self.request[0])self.request[1].sendto(self.request[0].upper(),self.client_address) #發送的是第1個消息，第2個地址if __name__ == '__main__':s=socketserver.ThreadingUDPServer(('127.0.0.1',8080),MyServer) #多線程s.serve_forever()
?
udp_socket_client客戶端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * ip_port=('127.0.0.1',8080) buffer_size=1024udp_client=socket(AF_INET,SOCK_DGRAM) #數據報while True:msg=input('>>: ').strip()udp_client.sendto(msg.encode('utf-8'),ip_port)data,addr=udp_client.recvfrom(buffer_size)# print(data.decode('utf-8'))print(data)
?
執行結果：
先啟動服務端，再開多個客戶端，向服務端發送消息。
#客戶端 >>: welcome #輸入要發送的消息 b'WELCOME'>>: hello b'HELLO' >>: #服務端 (b'welcome', <socket.socket fd=388, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>) 收到客戶端的消息是 b'welcome' #服務端接收到的消息 (b'hello', <socket.socket fd=388, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>) 收到客戶端的消息是 b'hello'
?
?
十四、認證客戶端的鏈接合法性
如果你想在分布式系統中實現一個簡單的客戶端鏈接認證功能，又不像SSL那么復雜，那么利用hmac+加鹽的方式來實現
tcp_socket_server服務端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import hmac,ossecret_key=b'linhaifeng bang bang bang' #加段代碼（加鹽） def conn_auth(conn):'''認證客戶端鏈接:param conn::return:'''print('開始驗證新鏈接的合法性')msg=os.urandom(32)conn.sendall(msg)h=hmac.new(secret_key,msg)digest=h.digest()respone=conn.recv(len(digest))return hmac.compare_digest(respone,digest)def data_handler(conn,bufsize=1024):if not conn_auth(conn):print('該鏈接不合法,關閉')conn.close()returnprint('鏈接合法,開始通信')while True:data=conn.recv(bufsize)if not data:breakconn.sendall(data.upper())def server_handler(ip_port,bufsize,backlog=5):'''只處理鏈接:param ip_port::return:'''tcp_socket_server=socket(AF_INET,SOCK_STREAM)tcp_socket_server.bind(ip_port)tcp_socket_server.listen(backlog)while True:conn,addr=tcp_socket_server.accept()print('新連接[%s:%s]' %(addr[0],addr[1]))data_handler(conn,bufsize)if __name__ == '__main__':ip_port=('127.0.0.1',9999)bufsize=1024server_handler(ip_port,bufsize)
?
tcp_socket_client客戶端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import hmac,ossecret_key=b'linhaifeng bang bang bang' #加鹽 def conn_auth(conn):'''驗證客戶端到服務器的鏈接:param conn::return:'''msg=conn.recv(32)h=hmac.new(secret_key,msg)digest=h.digest()conn.sendall(digest)def client_handler(ip_port,bufsize=1024):tcp_socket_client=socket(AF_INET,SOCK_STREAM)tcp_socket_client.connect(ip_port)conn_auth(tcp_socket_client)while True:data=input('>>: ').strip()if not data:continueif data == 'quit':breaktcp_socket_client.sendall(data.encode('utf-8'))respone=tcp_socket_client.recv(bufsize)print(respone.decode('utf-8'))tcp_socket_client.close()if __name__ == '__main__':ip_port=('127.0.0.1',9999)bufsize=1024client_handler(ip_port,bufsize)
?
