网络编程（2）

目录

• 一、 网络编程（2）
  • 1. subprocess模块
  • 2. 粘包问题
  • 3. UDP 协议
  • 4. SocketServer 模块
  • 5. 上传大文件

一、 网络编程（2）

1. subprocess模块

• subprocess 有什么用

  它是和操作系统交互,实现操作系统的命令执行和结果展示

• 实例：

  
  import subprocess
  
  cmd = input('cmd>>:')  # dir
  
  obj = subprocess.Popen(
      # cmd命令
      cmd,
      # Shell=True
      shell=True,
      # 返回正确结果参数  subprocess.PIPE为 -1
      stdout = subprocess.PIPE,
      # 返回错误结果参数 error
      stderr = subprocess.PIPE
  )
  
  result = obj.stdout.read() + obj.stderr.read()
  
  print(result.decode('gbk'))
  

2. 粘包问题

• 什么是粘包问题

  客户端第一次发送的数据，服务端无法精确一次性接受完毕。
  下一次发送的数据与上一次数据粘在一起了。

      1.无法预测当前要接受的数据的大小（长度）。
      2.多次连续发送数据量小、并且时间间隔短的数据会一次性打包发送。
      3.一次性发生很大的数据，服务端一次没接收完，就会在下一次接收时继续接收。
  

• TCP粘包和UDP为什么不粘包

先说TCP：由于TCP协议本身的机制（面向连接的可靠地协议-三次握手机制）客户端与服务器会维持一个连接（Channel），数据在连接不断开的情况下，可以持续不断地将多个数据包发往服务器，但是如果发送的网络数据包太小，那么他本身会启用Nagle算法（可配置是否启用）对较小的数据包进行合并（基于此，TCP的网络延迟要UDP的高些）然后再发送（超时或者包大小足够）。那么这样的话，服务器在接收到消息（数据流）的时候就无法区分哪些数据包是客户端自己分开发送的，这样产生了粘包；服务器在接收到数据库后，放到缓冲区中，如果消息没有被及时从缓存区取走，下次在取数据的时候可能就会出现一次取出多个数据包的情况，造成粘包现象（确切来讲，对于基于TCP协议的应用，不应用包来描述，而应 用 流来描述），个人认为服务器接收端产生的粘包应该与linux内核处理socket的方式 select轮询机制的线性扫描频度无关。
再说UDP：本身作为无连接的不可靠的传输协议（适合频繁发送较小的数据包），他不会对数据包进行合并发送（也就没有Nagle算法之说了），他直接是一端发送什么数据，直接就发出去了，既然他不会对数据合并，每一个数据包都是完整的（数据+UDP头+IP头等等发一次数据封装一次）也就没有粘包一说了。

UDP不存在粘包问题，是由于UDP发送的时候，没有经过Negal算法优化，不会将多个小包合并一次发送出去。另外，在UDP协议的接收端，采用了链式结构来记录每一个到达的UDP包，这样接收端应用程序一次recv只能从socket接收缓冲区中读出一个数据包。也就是说，发送端send了几次，接收端必须recv几次（无论recv时指定了多大的缓冲区）。

• TCP协议特性:
  tcp协议是一个流式协议，会将多次连续发送数据量小、并且时间间隔短的数据一次性打包发送。

• 解决粘包问题:
  解决粘包问题的方法之一是使用 struct 模块。

  ​ struck模块是一个可以将数据的大小长度，压缩成固定的长度的一个标记（数据报头）。

• struct模块先通过pack 方法根据数据的二进制长度生成一个大小为 4 的报头。通过unpack 方法解包这个报头，得到这个要发送的数据的二进制大小。unpack方法返回的是一个元组。

• 在python中，只有字符串才能直接编码转换成二进制，其他任意数据类型都要先转换成 json 和pickle数据类型，再将这个转换后的json和pickle数据编码成二进制类型。

  	- struct模块
  		必须先定义报头，发送报头，再发送真实数据。
      - 既想发送文件，又想发送文件的描述信息
  # 字典的转化：
          # 客户端发送字典给服务端
              send_dic = {
                  file_name: 文件名
                  file_size: 文件的真实长度 1000000
              }
  
              # 通过json模块序列化成bytes数据
              json_data = json.dumps(send_dic)
              bytes_data = json_data.encode('utf-8')  # bytes
  
              # 先获取字典的报头
              headers = struct.pack('i', len(bytes_data))
  
          # 服务端接收到字典，并接收文件的真实数据
  
  # 实例：    
  import struct
  
  # 打包压缩
  # i:模式，会将数据长度压缩成4个bytes
  str1 = 'watqwer'
  
  # 报头
  # 模拟客户端
  headers = struct.pack('i',len(str1))
  print(headers)
  
  print(len(headers))  # 4
  # client.send(headers)
  
  # 模拟服务端
  # headers = conn.recv(4)
  data_len = struct.unpack('i', headers)  # (7,)
  print(data_len[0])  # 真实数据长度10000
  

3. UDP 协议

• UDP协议是一种传输协议。

• UDP协议的特点：

  1. 不需要先建立连接
  2. 不会粘包
  3. 客户端给服务端发送数据，不需要等待服务端返回接收成功
  4. 数据容易丢失，数据不安全

• TCP 就好比在打电话

• UDP 就好比在发短信

4. SocketServer 模块

• python内置模块，可以简化socket套接字服务端的代码。

• 优点：简化TCP 与 UDP 服务端的代码

• 缺点：必须创建一个类

• 实例：

  # 客户端：
  import socket
  
  client = socket.socket()
  
  client.connect(
  
      ('127.0.0.1', 8888)
  )
  
  while True:
      send_msg = input('客户端: ')
  
      client.send(send_msg.encode('utf-8'))
  
      back_msg = client.recv(1024)
  
      print(back_msg.decode('utf-8'))
  
      
  # 服务端
  
  import socketserver
  
  
  # 定义类
  # TCP: 必须继承BaseRequestHandler类
  class MyTcpServer(socketserver.BaseRequestHandler):
  
      # 必须重写父类的handle, 当客户端连接时会调用该方法
      def handle(self):
          print(self.client_address)
  
          while True:
              try:
                  # 1.接收消息
                  # 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'))
  
              except 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()
  

5. 上传大文件

# 客户端：

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)
        
        
 # 服务端 ：

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()