socket數據傳輸

目錄

• subprocess模塊
  • 可以通過代碼執行操作系統的終端命令
  • 返回終端命令后的結果
• struct模塊：
  • 將一個長的數據，壓縮成固定的長度的一個標記（數據報頭）
  • 客服端struct壓縮包頭，服務端解壓縮，獲取數據正式長度
• 粘包問題：
  • -粘包問題 ： -無法判斷傳輸包的長度大小
  • -tcp 協議特性（流式協議）： 多次發送數據量小，時間間隔時間短。
  • 解決問題：
    • struct 模塊 ： 創建頭部和內容
• QQ聊天的實現:
• 文件的傳輸:
• 大文件的傳輸:
• 傳輸層協議：
  • TCP :
    • -是一種流式協議，一段段數據流的形式傳輸數據
    • -會將多次連續發送數據量小，並且時間隔斷的數據一次性打包發送
    • -數據安全，但是占網絡資源大
  • UDP:
    • -傳輸協議
    • -不需要建立雙向管道
    • -不會粘包
    • -客服端發數據給服務端，不需要等待服務器返回接收成功
    • -數據容易丟失，數據不安全
    • --UDP : 好比在發消息
    • --TCP : 好比在打電話
  • FTP:
    • 包括兩個組成部分，其一為FTP服務器，
    • 其二為FTP客戶端。其中FTP服務器用來存儲文件，用戶可以使用FTP客戶端通過FTP協議訪問位於FTP服務器上的資源。在開發網站的時候，通常利用FTP協議把網頁或程序傳到Web服務器上
• socketServer模塊：
  • 簡化socket,服務端的代碼
  • 定義類，實現

subprocess模塊

• 可以通過代碼執行操作系統的終端命令

• 返回終端命令后的結果

import subprocess

cmd = inpuy('>>>:  ').strip()
obj = subprocess.Popen(
cmd,
shell=True,
stdout = subprocess.PIPE,
stderr = subprocess.PIPE,
#stdin = input())
#ipconfig --> 網絡設置    
# taskliet --> 進程列表   
result = obj.stuout.read() + obj.stuerr.read()

# windows操作系統 --》 gbk編碼
    
print(result.decode('gbk'))

struct模塊：

• 將一個長的數據，壓縮成固定的長度的一個標記（數據報頭）

• 客服端struct壓縮包頭，服務端解壓縮，獲取數據正式長度

import struct

#打包 ，解包
salt = '一i個字符串'
#客服端壓縮包，先壓縮頭部，在發送內容
header = struct.pack('i',len(salt))
print(header)
print(len(header))

#服務端解包， 
data = struct.unpack('i',header)
print(data)
print(data[0]) # --->返回一個元組格式

#server
import socket
import subprocess
import struct

server = socket.socket()

server.bind(
    ('127.0.0.1', 9527)
)

server.listen(5)

while True:
    conn, addr = server.accept()

    while True:
        try:
            # recv的數據是從內存中獲取
            cmd = conn.recv(1024).decode('utf-8')

            if cmd == 'q':
                break

            if len(cmd) == 0:
                continue

            print(cmd)

            # 執行cmd命令
            obj = subprocess.Popen(
                cmd,
                shell=True,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
            )

            # 接收終端返回的數據
            result = obj.stdout.read() + obj.stderr.read()

            # 打包壓縮，獲取報頭
            headers = struct.pack('i', len(result))

            # 先發送頭部
            conn.send(headers)

            # 再發送真實數據
            conn.send(result)

        except Exception as e:
            print(e)
            break
    conn.close()
            
            

# client
import socket
import struct

client = socket.socket()

client.connect(
    ('127.0.0.1', 9527)
)

while True:

    cmd = input('》》》:')  # dir

    client.send(cmd.encode('utf-8'))

    if cmd == 'q':
        break

    # 先獲取數據報頭
    headers = client.recv(4)

    # 解包，或者真實數據長度
    data_len = struct.unpack('i', headers)[0]  # (len， )

    # 接收真實數據長度
    data = client.recv(data_len)

    print(data.decode('gbk'))

client.close()

粘包問題：

-粘包問題 ： -無法判斷傳輸包的長度大小

-tcp 協議特性（流式協議）： 多次發送數據量小，時間間隔時間短。

​ 一次性接收數據.內存浪費

• 解決問題：

  • struct 模塊 ： 創建頭部和內容

QQ聊天的實現:

#UDP 實現
import socket
server = socket.socket(type= socket.SOCK_DGRAM)

server.bind(('127.0.0.1',9527))

while True:
    #接收多個用戶，但是必須要有幾個聯建
    msg,addr = server.recvfrom(1024)
    msg1,addr1 = server.recvfrom(1024)
    print(msg)
    print(msg1)
    
    send_msg = input('>>: ').strip()
    server.sendto(send_msg,addr)
    server.sendto(send_msg,addr1)

#client
import socket

client = socket.socket(type=socket.SOCK_DGRAM)
server_ip_port = ('127.0.0.1',9527)

while True:
    send_msg = input('>>>').strip()
    
    client.sendto(send_msg,server_ip_port)
    #接受任何人的消息
    msg = client.recv(1024)
    print(msg.decode('utf-8'))

文件的傳輸:

#server
# json --> 編碼  --- 》bytes
import socket
import json
import struct

server= socket.socket()
server.bind(('127.0.0.1',9527))

server.listen(5)

while True:
    conn,addr = server.accept()
    while True:
        try:
            #接受頭部
            header = conn.recv(4)
            data_len = struct.unpack('i',header)[0]
            
            bytes_data = conn.recv(data_len)
            back_dic = json.loads(bytes_data.decode('utf-8'))
            print(back_dic)
        except Exception as e:
            print(e)
            break
conn.close()

#client
import socket
import json
import struct
import time

client = socket.socket()
client.connect(('127.0.0.1',9527))

while True:
    send_sic ={
        'file_name ': 'python視頻',
        'file_size ': '55000',
    }
    json_data = json.dumps(send_dic)
    bytes_data = json_data.encode('utf-8')
    
    header = struct.pack('i',len(bytes_data))
    client.send(header)
    client.send(bytes_data)
    time.sleep(2)
client.close()

大文件的傳輸:

import socket
import json
import struct
server = socket.socket()
server.bind(
    ('127.0.0.1', 9527)
)
server.listen(5)

while True:
    conn, addr = server.accept()
    try:
        # 先接收字典報頭
        headers = conn.recv(4)

        # 解包獲取字典真實數據長度
        data_len = struct.unpack('i', headers)[0]

        # 獲取字典真實數據
        bytes_data = conn.recv(data_len)

        # 反序列得到字典
        back_dic = json.loads(bytes_data.decode('utf-8'))

        print(back_dic)

        # 拿到字典的文件名，文件大小
        file_name = back_dic.get('file_name')
        file_size = back_dic.get('file_size')

        init_data = 0
        # 1.以文件名打開文件，准備寫入
        with open(file_name, 'wb') as f:

            # 一點一點接收文件，並寫入
            while init_data < file_size:
                data = conn.recv(1024)
                # 2.開始寫入視頻文件
                f.write(data)
                init_data += len(data)

            print(f'{file_name}接收完畢!')

    except Exception as e:
        print(e)
        break

conn.close()

import socket
import struct
import json

client = socket.socket()

client.connect(
    ('127.0.0.1', 9527)
)


# 1.打開一個視頻文件，獲取視頻數據大小
with open(r'D:\jason真實寫真集.mp4', 'rb') as f:
    movie_bytes = f.read()
    # 關閉文件

# 2.為視頻文件組織一個字典，字典內有視頻的名稱，視頻大小
send_dic = {
    'file_name': 'jason真實寫真集.mp4',
    'file_size': len(movie_bytes)  # 10G
}

# 3.先打包字典，發送headers報頭，再發送真實字典數據
json_data = json.dumps(send_dic)
bytes_data = json_data.encode('utf-8')
headers = struct.pack('i', len(bytes_data))
# 發送報頭
client.send(headers)
# 發送真實字典數據
client.send(bytes_data)

# 4.接着發送真實視頻文件數據
init_data = 0
num = 1
with open(r'D:\jason真實寫真集.mp4', 'rb') as f:
    while init_data < len(movie_bytes):
        # 最后一次獲取，有多少拿多少
        send_data = f.read(1024)
        print(send_data, num)
        num += 1
        # 每次發送1024數據
        client.send(send_data)
        # 為初始發送數據 + 已發送數據的長度
        init_data += len(send_data)


client.close()

傳輸層協議：

TCP :

-是一種流式協議，一段段數據流的形式傳輸數據

-會將多次連續發送數據量小，並且時間隔斷的數據一次性打包發送

-數據安全，但是占網絡資源大

UDP:

-傳輸協議

-不需要建立雙向管道

-不會粘包

-客服端發數據給服務端，不需要等待服務器返回接收成功

-數據容易丟失，數據不安全

--UDP : 好比在發消息

--TCP : 好比在打電話

#UDP 的使用
import socket
server = socket.socket(type = socket.SOCK_DGRAM)
server.bind(('127.0.0.1',9527))

#TCP:
#conn,addr = server.accept()
#conn.recv()

#UDP
msg,addr = server.recvfrom(1024)
print(msg)

#client

import socket
client = socket.socket(type = socket.SOCK_DGRAM)
SERVER_IP_PORT = ('127.0.0.1',9527)
client.sendto(b'hell0',SERVER_IP_PORT)


client.close()

FTP:

• 包括兩個組成部分，其一為FTP服務器，

  • 其二為FTP客戶端。其中FTP服務器用來存儲文件，用戶可以使用FTP客戶端通過FTP協議訪問位於FTP服務器上的資源。在開發網站的時候，通常利用FTP協議把網頁或程序傳到Web服務器上

socketServer模塊：

• 簡化socket,服務端的代碼

  • 定義類，實現

#client
import socket
client = socket.socket()
client.connent(('127.0.0.1',9527))

while True:
    send_msg = input('>>>: ').striP()
    client.send(send_msg.encode('utf-8'))
    
    back_msg = client.recv(1024)
    print(back_msg.decode('utf-8'))

import socketserver

#定義類，繼承BaseRequestHeadler類
class MyTcpServer(socketserver.BaseRequestHeadler):
    #重寫父類，子類覆蓋
    def headle(self):
        print(self.client_address)
        while True:
            try:
                #request.recv(1024) == > conn.recv(1024)
                data = self.request.recv(1024).decode('utf-8')
                #對接收數據處理
                send_msg = data.upper()
                self.request.send(send_msg.encode('utf-8'))
            exxept Exception as e:
                print(e)
                break
if __name__ == '__main__':
        # socketserver.TCPServer只能有一個技師服務
    # server = socketserver.TCPServer(
    #     ('127.0.0.1', 8888), MyTcpServer
    # )

    # ThreadingTCPServer: 有多個技師可服務
    server = socketserver.ThreadingTCPServer(
        ('127.0.0.1', 8888), MyTcpServer
    )

    # 永久執行服務
    server.serve_forever()