8_8 TCP上传文件socketserver的应用

一。文件上传

　　对于一些比较大的文件，当传输的数据大于内存时，显然，一次性将数据读取到内存中，在从内存传输到服务器显然时不可取的。

　　所以，在上传文件时，可以在with open打开文件，边读取文件边发送，一行行的发送，在接收端也可以一行行的写入，这样在内存中占用的内存就只是一行而已。

　　注意，在读取文件所时可以将文件已二进制的方法读取，这样就可以免去编码过程。

　　如下：

import socket
import os
import json
import struct


server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)

while True:
    conn,addr = server.accept()
    while True:
        try:
            header_len = conn.recv(4)
            # 解析字典报头
            header_len = struct.unpack('i',header_len)[0]
            # 再接收字典数据
            header_dic = conn.recv(header_len)
            real_dic = json.loads(header_dic.decode('utf-8'))
            # 获取数据长度
            total_size = real_dic.get('file_size')
            # 循环接收并写入文件
            recv_size = 0
            with open(real_dic.get('file_name'),'wb') as f:
                while recv_size < total_size:
                    data = conn.recv(1024)
                    f.write(data)
                    recv_size += len(data)
                print('上传成功')
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()

import socket
import json
import os
import struct


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

while True:
    # 获取电影列表 循环展示
    MOVIE_DIR = r'D:\python脱产10期视频\day25\视频'
    movie_list = os.listdir(MOVIE_DIR)
    # print(movie_list)
    for i,movie in enumerate(movie_list,1):
        print(i,movie)
    # 用户选择
    choice = input('please choice movie to upload>>>:')
    # 判断是否是数字
    if choice.isdigit():
        # 将字符串数字转为int
        choice = int(choice) - 1
        # 判断用户选择在不在列表范围内
        if choice in range(0,len(movie_list)):
            # 获取到用户想上传的文件路径
            path = movie_list[choice]
            # 拼接文件的绝对路径
            file_path = os.path.join(MOVIE_DIR,path)
            # 获取文件大小
            file_size = os.path.getsize(file_path)
            # 定义一个字典
            res_d = {
                'file_name':'性感荷官在线发牌.mp4',
                'file_size':file_size,
                'msg':'注意身体,多喝营养快线'
            }
            # 序列化字典
            json_d = json.dumps(res_d)
            json_bytes = json_d.encode('utf-8')

            # 1.先制作字典格式的报头
            header = struct.pack('i',len(json_bytes))
            # 2.发送字典的报头
            client.send(header)
            # 3.再发字典
            client.send(json_bytes)
            # 4.再发文件数据(打开文件循环发送)
            with open(file_path,'rb') as f:
                for line in f:
                    client.send(line)
        else:
            print('not in range')
    else:
        print('must be a number')

　　需要注意的时struct在解包的时候需要使用列表【0】对其取值。

二。异常处理

　　在程序中难免会出现错误，有些错误是可以解决的，比如语法错误，这种错误编译器都是会提示的，而逻辑错误有时候不可避免，因为程序员不知道其什么时侯会发生错误。

　　针对这种错误，可以使用异常处理机制对其进行捕获

　　常见的错误类型有：

　　NAMERROR 名字错误

　　SyntaxError 语法错误

　　KeyError 键不存在

　　ValueError 值错误

　　IndexError 索引错误

　　处理这些bug时，只需要将可能出些这些bug的代码放入try。。except中。try中的代码越少越号。语法如下：

try：
    #可能出现错误的代码
except 错误类型 as e： #将错误信息赋值给e
    #出错之后的应对措施

　　在except中可以使用print（e）输出错误报告。

try：
    #可能出现错误的代码
except 错误类型 as e： #将错误信息赋值给e
    #出错之后的应对措施
else:
    #没有出错执行的代码

　　当程序中有else时，程序没有出现错误，就会执行else。

try：
    #可能出现错误的代码
except 错误类型 as e： #将错误信息赋值给e
    #出错之后的应对措施
else:
    #没有出错执行的代码
finall：
    #程序结束后执行的代码。

　　当程序中有finally时，无论代码有没有异常，都会执行finally。

　　操作场景，当对文件操作时，文件报错会使得文件没有关闭，占用资源，使用这个异常处理后，即使文件报错，也会把文件操作关E闭。

　　raise TypeError主动抛出异常。

　　当程序员需要主动抛出异常时，可以使用raise TypeError（‘’）主动抛出异常。

　　assert 断言

a=8
b=9
assert a<b

　　使用assert时，当程序正确时，会直接运行程序，不影响代码执行，如果错误则会抛出错误。

　　自定义异常：

class MyError(BaseException):
     def __init__(self,msg):
         super().__init__()
         self.msg=msg
     def __str__(self):
         return '<dfsdf%ssdfsdaf>' %self.msg

raise MyError('我自己定义的异常')

　　自定义异常可以定义被raise调用。出的报错信息就是__str__中的格式化信息。

三。UDP的使用

　　对于tcp的服务器使用，需要先定义一个socket，使用bind设置服务器地址，调用listen监听，在阻塞等待链接。

　　但是对于UDP的服务器来说没有链接池这个概念。

　　由于没有双向通道，所以它也不需要阻塞等待。

import socket


server = socket.socket(type=socket.SOCK_DGRAM)  # UDP协议
server.bind(('127.0.0.1',8080))
# UDP不需要设置半连接池 它也没有半连接池的概念

# 因为没有双向通道  不需要accept  直接就是通信循环
while True:
    data, addr = server.recvfrom(1024)
    print('数据:',data)  # 客户端发来的消息
    print('地址:',addr)  # 客户端的地址
    server.sendto(data.upper(),addr)

　　TCP的服务器，需要定义socket，并连接connet，到服务器，形成双向通道。

　　而UDP则不需要connect，只需要设置发送地址。

import socket


client = socket.socket(type=socket.SOCK_DGRAM)
# 不需要建立连接  直接进入通信循环
server_address = ('127.0.0.1',8080)
while True:
    client.sendto(b'hello',server_address)
    data, addr = client.recvfrom(1024)
    print('服务端发来的数据',data)
    print('服务端的地址',addr)

　　当需要发送时，使用sendto方法，对内容加地址进行发送，第二参数放地址。

　　当需要接受数据时，使用recvform方法接受数据，其产生的返回值有两个，一个是接受的数据，另一个是发送数据的地址。

　　udp满足以下特点：

　　1.udp协议客户端允许发空

　　　　因为udp自带包头。即使发送的是空也会发送包头。

　　2.udp协议不会粘包

　　3.udp协议服务端不存在的情况下，客户端照样不会报错

　　　　因为不存在连接，是一种发短信的方式。

　　4.udp协议支持并发

　　udp的并发可以使一个服务器同时连接多个客户端，其中使用轮流对其返回和接受值的方法连接多个客户端。例子如下：

import socket


server = socket.socket(type=socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8080))

while True:
    data, addr = server.recvfrom(1024)
    print(data.decode('utf-8'))
    msg = input('>>>:')
    server.sendto(msg.encode('utf-8'),addr)

import socket


client = socket.socket(type=socket.SOCK_DGRAM)
server_address = ('127.0.0.1',8080)

while True:
    msg = input('>>>:')
    msg = '来自客户端5的消息:%s'%msg
    client.sendto(msg.encode('utf-8'),server_address)
    data, server_addr = client.recvfrom(1024)
    print(data.decode('utf-8'))

　　并发：看起来像同时操作

　　并行：真的使同时操作

四。socketserver

　　在TCP中，如果对一个服务器同时连接多个客户端，会将其连接请求置于连接池里等待，只有当一个连接断开后，才会连接下一个连接请求。

　　所以，手动实现像udp一样的并发是非常困难的，但是可以使用socketserver，灵活的创建连接，使得看起来像同时运行。

　　tcp的使用：

import socketserver


class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        # print('来啦 老弟')
        while True:
            data = self.request.recv(1024)
            print(self.client_address)  # 客户端地址
            print(data.decode('utf-8'))
            self.request.send(data.upper())


if __name__ == '__main__':
    """只要有客户端连接  会自动交给自定义类中的handle方法去处理"""
    server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer)  # 创建一个基于TCP的对象
    server.serve_forever()  # 启动该服务对象

import socket

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

while True:
    client.send(b'hello')
    data = client.recv(1024)
    print(data.decode('utf-8'))

　　当调用一个ThreadingTCPServer方法时，需要传入两个参数，一个时服务器的地址，另一个是一个类，类中继承了socketserver中hander的方法，方法中写入对该客户端的操作，发送的数据等。

　　客户端和一般一样。

　　udp的使用。

　　对于UDP，socketserver也提供了方法去操作，所调用的方法是ThreadingUDPServer。

import socketserver


class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        # print('来啦 老弟')
        while True:
            data,sock = self.request
            print(self.client_address)  # 客户端地址
            print(data.decode('utf-8'))
            sock.sendto(data.upper(),self.client_address)


if __name__ == '__main__':
    """只要有客户端连接  会自动交给自定义类中的handle方法去处理"""
    server = socketserver.ThreadingUDPServer(('127.0.0.1',8080),MyServer)  # 创建一个基于TCP的对象
    server.serve_forever()  # 启动该服务对象

import socket
import time

client = socket.socket(type=socket.SOCK_DGRAM)
server_address = ('127.0.0.1',8080)

while True:
    client.sendto(b'hello',server_address)
    data,addr = client.recvfrom(1024)
    print(data.decode('utf-8'),addr)
    time.sleep(1)

　　其中，request返回的也是两个值，一个是返回的数据，另一个是可以对其调用的sock