python--(socket與粘包解決方案)

python--(socket與粘包解決方案)python

一.socket:
Socket 是任何一種計算機網絡通信中最基礎的內容。例如當你在瀏覽器地址欄中輸入 http://www.cnblogs.com/ 時,你會打開一個套接字,而後鏈接到 http://www.cnblogs.com/ 並讀取響應的頁面而後而後顯示出來。而其餘一些聊天客戶端如 gtalk 和 skype 也是相似。任何網絡通信都是經過 Socket 來完成的
打開 => 讀寫 => 關閉

socket ftp傳輸:
import socket
server = socket.socket()  #建立一個手機#建立了一個socket對象
ip_port = ('192.168.15.113',8001)  #建立了一張電話卡
server.bind(ip_port) #插上電話卡#綁定IP地址和端口

server.listen() #開機#監聽IP地址和端口
conn, addr = server.accept()  #等着別人給我打電話,阻塞住#等待客連接
from_client_msg = conn.recv(1024) #接收消息#1024爲消息大小,單位B,MB = 1024KB,1KB = 1024B
from_client_msg = from_client_msg.decode('utf-8')#接收的消息是bytes類型,須要轉換爲字符串
print(from_client_msg)

conn.send('死鬼,十點'.encode('utf-8'))  #發送消息

conn.close()#關閉連接
server.close()
socket ftp傳輸,服務端
import socket
client = socket.socket()
server_ip_port = ('192.168.15.113',8001)
client.connect(server_ip_port)#連接服務端

client.send('約嗎'.encode('utf-8')) #發消息#send裏面的消息必須是字節類型的

from_server_msg = client.recv(1024) #阻塞住,等待接收消息
from_server_msg = from_server_msg.decode('utf-8')
print(from_server_msg)

client.close()
socket ftp傳輸,客戶端
socket udp傳輸:
import socket
udp_server = socket.socket(type=socket.SOCK_DGRAM)  #建立一個udp協議下的socket,須要使用參數type#DGRAM : datagram  數據報
ip_port = ('192.168.15.113',8001)#拿到一個地址,啓動程序的時候,告訴電腦,你給我這個程序分配8001端口.
udp_server.bind(ip_port) #綁定IP地址和端口


from_client_msg,client_addr = udp_server.recvfrom(1024)#阻塞住了,接收客戶端消息#from_client_msg來自客戶端的消息,client_addr客戶端的地址('192.168.15.113', 8001)

udp_server.sendto(b'gunduzi',client_addr)#發送消息

udp_server.close()#關閉udp的socket對象
socket udp傳輸,服務端
import socket
udp_client = socket.socket(type=socket.SOCK_DGRAM)
server_ip_port = ('192.168.15.113',8001)

udp_client.sendto(b'hello',server_ip_port)

from_server_msg,server_addr = udp_client.recvfrom(1024)
print(from_server_msg)
print(server_addr)

udp_client.close()
socket udp傳輸,客戶端

 

socketserver:算法

  它是在socket的基礎上進行了一層封裝,也就是說底層仍是調用的socket,在py2.7裏面叫作SocketServer也就是大寫了兩個S,在py3裏面就小寫了。須要用它來實現併發,也就是同時能夠和多個客戶端進行通訊,多我的能夠同時進行上傳下載等。shell

 

import socketserver

class MyServer(socketserver.BaseRequestHandler)
#1.定義一個類,2.類裏面繼承socketserve.BaseRequestHandler

    def handle(self):   #類裏面定義一個handle方法,handle名稱不能變
        while 1:
            from_client_data = self.request.recv(1024).decode("utf-8")
        # self.request      #conn連接通道

            print(from_client_data)
            server_input = ("輝哥說>>>>")
            self.request.send(server_input.encode("utf-8"))
        # self.request.send(server_input.encode("utf-8")
        # self.request.close()

if __name__ == "__main__":
    ip_port = ('127.0.0.1',8001)#服務端的ip地址和端口
    socketserver.TCPServer.allow_reuse_address = True

    server = socketserver.ThreadingTCPServer(ip_port, MyServer)# 綁定IP地址和端口,而且啓動我定義的上面這個類

    server.serve_forever()#永久的給我執行下去
服務端代碼解析

 

import socket

tcp_client = socket.socket()
server_ip_port = ('127.0.0.1',8001)
tcp_client.connect(server_ip_port)
while 1:
    client_msg = input('大陽哥>>>')
    tcp_client.send(client_msg.encode('utf-8'))

    from_server_msg = tcp_client.recv(1024).decode('utf-8')
    print(from_server_msg)

tcp_client.close()
客戶端代碼解析

 

socket相關經常使用操做:json

sk.bind(address)
  s.bind(address)
將套接字綁定到地址。address地址的格式取決於地址族。在AF_INET下,以元組(host, port)的形式表示地址。

sk.listen(backlog)

  開始監聽傳入鏈接。backlog指定在拒絕鏈接以前,能夠掛起的最大鏈接數量。
backlog等於5,表示內核已經接到了鏈接請求,但服務器尚未調用accept進行處理的鏈接個數最大爲5
這個值不能無限大,由於要在內核中維護鏈接隊列

sk.setblocking(bool)

  是否阻塞(默認True),若是設置False,那麼accept和recv時一旦無數據,則報錯。

sk.accept()

  接受鏈接並返回(conn, address), 其中conn是新的套接字對象,能夠用來接收和發送數據。address是鏈接客戶端的地址。
  接收TCP
客戶的鏈接(阻塞式)等待鏈接的到來

sk.connect(address)

  鏈接到address處的套接字。通常,address的格式爲元組(hostname, port), 若是鏈接出錯,返回socket.error錯誤。

sk.connect_ex(address)

  同上,只不過會有返回值,鏈接成功時返回
0 ,鏈接失敗時候返回編碼,例如:10061

sk.close()

  關閉套接字

sk.recv(bufsize[, flag])

  接受套接字的數據。數據以字符串形式返回,bufsize指定最多能夠接收的數量。flag提供有關消息的其餘信息,一般能夠忽略。

sk.recvfrom(bufsize[.flag])

  與recv()
相似,但返回值是(data, address)。其中data是包含接收數據的字符串,address是發送數據的套接字地址。

sk.send(string[, flag])

  將string中的數據發送到鏈接的套接字。返回值是要發送的字節數量,該數量可能小於string的字節大小。即:可能未將指定內容所有發送。

sk.sendall(string[, flag])

  將string中的數據發送到鏈接的套接字,但在返回以前會嘗試發送全部數據。成功返回None,失敗則拋出異常。
內部經過遞歸調用send,將全部內容發送出去。

sk.sendto(string[, flag], address)

  將數據發送到套接字,address是形式爲(ipaddr,port)的元組,指定遠程地址。返回值是發送的字節數。該函數主要用於UDP協議。

sk.settimeout(timeout)

  設置套接字操做的超時期,timeout是一個浮點數,單位是秒。值爲None表示沒有超時期。通常,超時期應該在剛建立套接字時設置,由於它們可能用於鏈接的操做(如
client
鏈接最多等待5s )

sk.getpeername()

  返回鏈接套接字的遠程地址。返回值一般是元組(ipaddr, port)。

sk.getsockname()

  返回套接字本身的地址。一般是一個元組(ipaddr, port)

sk.fileno()

  套接字的文件描述符


二.粘包

緩衝區 : 暫時存放傳輸數據的,防止你的程序在發送數據的時候卡住,提升代碼運行效率瀏覽器

輸入緩衝區:recv服務器

輸出緩衝區:send網絡

緩衝區有長度限制併發

MTU:最大傳輸單元,網絡層限制是1500B,每次發送數據的時候最好不要超過這個數socket

 

粘包現象:tcp

1 連續發送小的數據,間隔時間很短,有可能一次就接收到了這幾個連續的拼接在一塊兒的小數據.  #緣由:爲了提升tcp傳輸效率,內部提供了一個叫作Nagel算法,他的意思就是爲了不你連續發送小的數據.

 

2 當你一次接收的數據長度小於你一次發送的數據長度,那麼一次接受完剩下的數據會在下一次接收數據的時候被一塊兒接收.#緣由面向流的傳輸

粘包的根本緣由:

兩端互相不知道對方發送數據的長度

 

解決方案一:
發送消息以前,先計算要發送消息的長度,而後先將消息長度發送過去,對方給你回一個確認收到長度的信息,而後根據接收到的消息長度來修改本身一次接收消息的大小
這個過程多了一次交互.

解決方案二:

struct:
import struct
num = 156
#將int類型的數據打包成4個字節的數據
num_stru = struct.pack('i',num)
print(len(num_stru))
print(num_stru)
print('11111111111111111111111111111111')

#在經過int類型解包,將前面打包的數據解包成打包以前的int數據
num2 = struct.unpack('i',num_stru) #解包出來是個元組
print(num2)#(156,)
print(num2[0])
神奇的打包工具struck


ftp傳輸 案例:
服務端:
import  socketserver
# 服務端

class Myserver(socketserver.BaseRequestHandler):

    def handle(self):

        conn = self.request
        conn.sendall(bytes("你好,我是孔二楞",encoding="utf-8"))
        while True:
            ret_bytes = conn.recv(1024)
            ret_str = str(ret_bytes,encoding="utf-8")
            if ret_str == "q":
                break
            conn.sendall(bytes(ret_str+"你真無聊~",encoding="utf-8"))

if __name__ == "__main__":
    server = socketserver.ThreadingTCPServer(("192.168.15.70",8080),Myserver)
    server.serve_forever()

客戶端:
import socket

obj = socket.socket()

obj.connect(("192.168.15.70",8080))

ret_bytes = obj.recv(1024)
ret_str = str(ret_bytes,encoding="utf-8")
print(ret_str)

while True:
    inp = input("你好請問您有什麼問題? \n >>>")
    if inp == "q":
        obj.sendall(bytes(inp,encoding="utf-8"))
        break
    else:
        obj.sendall(bytes(inp, encoding="utf-8"))
        ret_bytes = obj.recv(1024)
        ret_str = str(ret_bytes,encoding="utf-8")
        print(ret_str)
案例一 自動回覆聊天
 

 

import socket
import struct
import json
import os
tcp_server = socket.socket()
ip_port = ('127.0.0.1',8001)#本機迴環地址,供內部程序之間測試用
tcp_server.bind(ip_port)
tcp_server.listen()
client_file_path = r'F:\pp'

conn,adddr = tcp_server.accept()
file_info_stru = conn.recv(4)#首先接收到文件信息長度轉換出來的4個字節的數據
file_info_len = struct.unpack('i',file_info_stru)[0]#解包文件信息的長度
client_file_info = conn.recv(file_info_len).decode('utf-8')
abc_file_info = json.loads(client_file_info)#將接收到的json字符串反序列化
print('abc_file_info>>>',abc_file_info)
client_file_size = abc_file_info['file_size']

recv_all_size = 0
client_full_path = client_file_path + '\\' + abc_file_info['file_name']
# client_full_path = os.path.join(client_file_path,abc_file_info['file_name'])
with open(client_full_path,'wb') as f:
    while recv_all_size < client_file_size:
        every_recv_data = conn.recv(1024)
        f.write(every_recv_data)
        recv_all_size += len(every_recv_data)


conn.send('小夥牛逼啊,上傳成功!'.encode('utf-8'))
conn.close()
tcp_server.close()
案例二 大於10M文件上傳服務端
import socket
import struct
import json
import os
tcp_client = socket.socket()
server_client = socket.socket()
server_ip_port = ("127.0.0.1",8001)
tcp_client.connect(server_ip_port)
read_size = 1024

file_info = {
    'file_path':r'F:\untitled\10.18\jj\aaa.mp4',
    'file_name':'aaa.mp4',
    'file_size':None,
}
file_size = os.path.getsize(file_info["file_path"])#獲取文件大小
file_info["file_size"] = file_size#將文件大小添加到文件信息的字典中
file_info_json = json.dumps(file_info)#由於咱們要發送的數據是字節類型,那麼必須將字典轉換爲bytes類型,但字典不能直接轉換爲byte,因此用過先轉換成字符串
file_info_len = len(file_info_json) #獲取字符串的長度
file_info_stru = struct.pack("i",file_info_len)#將長度打包爲四個字節
tcp_client.send(file_info_stru)#將打包好的4個本身的數據和個人文件信息數據一塊兒發送給了服務端
tcp_client.send(file_info_json.encode("utf-8"))

all_file_data = b'' #統計文件數據
all_size_len = 0    #統計文件數據長度

with open(file_info['file_path'],'rb') as f:
    while all_size_len < file_size:
        every_read_data = f.read(read_size)
        all_file_data += every_read_data
        all_size_len += len(every_read_data)
        tcp_client.send(every_read_data)#發送每次讀取的數據

print(tcp_client.recv(1024).decode('utf-8'))
tcp_client.close()
案例二 大於10M文件上傳客戶端

 

import socket
import subprocess
import struct
server = socket.socket()
ip_port = ("192.168.15.33",8001)
server.bind(ip_port)
server.listen()
conn,addr = server.accept()

while 1:
    print("等待接收消息...")
    from_client_cmd = conn.recv(1024).decode("utf-8")#接收客戶端消息
    print(from_client_cmd)

    sub_obj = subprocess.Popen(   #經過subprocess模塊執行服務端指令,並拿到指令結果
        from_client_cmd,            #客戶端指令
        shell = True,
        stdout = subprocess.PIPE,   #標準輸出:正確指令的執行結果
        stderr = subprocess.PIPE,   #標準錯誤輸出:錯誤指令的執行結果
    )

    server_cmd_msg = sub_obj.stdout.read()
    #server_cmd_msg = sub_obj.stderr.read() #接收到的返回信息是bytes類型,而且windoes系統的默認編碼爲gbk
    cmd_msg_len = len(server_cmd_msg) #計算你要發送的數據長度
    msg_len_stru = struct.pack("i",cmd_msg_len)#先對數據長度進行打包,打包成4個字節的數據,目的是爲了和你將要發送的數據拼接在一塊兒,就像咱們自制一個消息頭.
    conn.send(msg_len_stru)        #首先發送打包成功後的那4個字節的數據
    conn.sendall(server_cmd_msg)   #循環send數據,直到數據所有發送成功

conn.close()
server.close()
案例三 解決粘包問題服務端
import socket
import struct
client = socket.socket()
server_ip_port = ("192.168.15.33",8001)
client.connect(server_ip_port)

while 1:
    msg = input("請輸入要執行的命令>>>>>")
    client.send(msg.encode("utf-8"))

    from_server_msglen = client.recv(4)#先接受服務端要發送給個人數據長度,前四個字節,固定的
    unpack_len_msg = struct.unpack("i",from_server_msglen)[0]

    recv_msg_len = 0
    all_msg = b""
    while recv_msg_len < unpack_len_msg:
        every_recv_date = client.recv(1024)
        all_msg += every_recv_date  #將每次接收到的數據進行拼接和統計
        recv_msg_len += len(every_recv_date) #對每次接受到的數據進行累加

    print(all_msg.decode("gbk"))
client.close()
案例三 解決粘包問題客戶端
相關文章
相關標籤/搜索