网络编程之文件传输实例

一、文件传输包括两部分，服务端收发文件和客户端（即用户）收发文件。

　　收发文件与远程执行命令的程序原理是一样的，比如客户端下载文件的过程：

　　　　1、客户端提交下载命令；

　　　　2、服务端接收命令，解析，执行下载文件的方法，即以读的方式打开文件，利用for循环读出一行行内容，

　　　　然后发送（send）给客户端。

　　　　3、客户端以写的方式打开文件，将接受的文件内容接收写入文件中。

 

二、文件传输的几种模式

　　1、基础版

　　　　服务端文件夹应包括共享文件夹share和server.py

　　　　server.py

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcong

import socket
import struct
import json
import os
share_dir = r'D:pycharmTest1Thrid_module网络编程文件传输文件传输基础版服务端share'
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
server.bind(('127.0.0.1',3361))
server.listen(5)

while True:
    conn,client_addres = server.accept()
    while True:
        try:
            cmd = conn.recv(1024)
            if not cmd:break # 适用于linux
            # 执行客户端的命令，并返回执行后的信息
            # 1、解析客户端的指令，提取文件名
            data = cmd.decode('gbk').split()
            file_name = data[1]
            # 1、制作报头
            header_dic = {
                'file_name':file_name, # 客户端需要下载的文件名
                'md5':'xxxxxxxx',
                'total_size':os.path.getsize('%s\%s'%(share_dir,file_name)) # 服务端对应文件的大小
            }
            # 2、编辑并发送报头长度
            header_json = json.dumps(header_dic) # 报头字典转字符串
            header_bytes = header_json.encode('gbk') # 字符串转bytes
            conn.send(struct.pack('i',len(header_bytes)))# 发送报头长度
            # 3、发送报头信息
            conn.send(header_bytes)
            # 4、发送真实数据
            with open('%s\%s'%(share_dir,file_name),'rb') as f:
                for line in f:
                    conn.send(line)
        except ConnectionResetError:
            break
    conn.close()
server.close()

　　　　客户端文件夹应包括下载或上传文件夹down和client.py

　　　　client.py

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcong

import socket
import struct
import json
downland_dir = r'D:pycharmTest1Thrid_module网络编程文件传输文件传输基础版客户端dowland'
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

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

while True:
    cmd = input('输入下载的文件及后缀名>>：').strip()
    if not cmd:continue
    client.send(cmd.encode('gbk'))
    # 等待接收
    # 1、获取报头长度
    obj = client.recv(4)
    header_size = struct.unpack('i',obj)[0]
    # 2、获取报头内容
    header_bytes = client.recv(header_size)
    # 3、解析报头，获取真实数据长度
    header_data = header_bytes.decode('gbk') # bytes解码成字符串
    header_dic = json.loads(header_data)  # 字符串反序列化为字典（报头）
    total_size = header_dic['total_size'] # 得到真实数据长度
    file_name = header_dic['file_name']
    # 4、接收真实数据
    with open('%s\%s'%(downland_dir,file_name),'wb') as f:
        recv_size = 0
        while recv_size < total_size:
            line = client.recv(1024)
            f.write(line)
            recv_size += len(line)
            print('文件总大小：%s	已下载大小：%s'%(total_size,recv_size))

client.close()

　　

　　2、函数版

　　　　服务端文件夹包括recieve、share文件夹和server.py

　　　　server.py

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcong

import socket
import struct
import json
import os
share_dir = r'D:pycharmTest1Thrid_module网络编程文件传输文件传输优化_函数版服务端share'
recieve_dir = r'D:pycharmTest1Thrid_module网络编程文件传输文件传输优化_函数版服务端
ecieve'

def get(cmd,conn):
    # 执行客户端的命令，并返回执行后的信息
    # 1、解析客户端的指令，提取文件名
    data = cmd.decode('gbk').split()
    file_name = data[1]
    # 1、制作报头
    header_dic = {
        'file_name': file_name,  # 客户端需要下载的文件名
        'md5': 'xxxxxxxx',
        'total_size': os.path.getsize('%s\%s' % (share_dir, file_name))  # 服务端对应文件的大小
    }
    # 2、编辑并发送报头长度
    header_json = json.dumps(header_dic)  # 报头字典转字符串
    header_bytes = header_json.encode('gbk')  # 字符串转bytes
    conn.send(struct.pack('i', len(header_bytes)))  # 发送报头长度
    # 3、发送报头信息
    conn.send(header_bytes)
    # 4、发送真实数据
    with open('%s\%s' % (share_dir, file_name), 'rb') as f:
        for line in f:
            conn.send(line)
def put(cmd,conn):
    '''
    获取用户上传的内容
    :param cmd:
    :param conn:
    :return:
    '''
    # 1、接收报头的大小
    obj = conn.recv(4)
    header_size = struct.unpack('i', obj)[0]
    # 2、接收报头的信息
    head_bytes = conn.recv(header_size)
    # 3、解析报头信息并获取真实数据的大小
    head_data = head_bytes.decode('gbk') # bytes-->str
    head_dic = json.loads(head_data)  # str-->dict
    file_name = head_dic['file_name']
    total_size = head_dic['total_size']
    # 4、接收真实数据
    with open('%s\%s'%(recieve_dir,file_name),'wb') as f:
        recv_size = 0
        while recv_size < total_size:
            line = conn.recv(1024)
            f.write(line)
            recv_size += len(line)
            print('文件总大小为：%s	已接收的文件大小为：%s'%(total_size,recv_size))

def run():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.bind(('127.0.0.1', 8889))
    server.listen(5)
    while True:
        conn,client_addres = server.accept()
        while True:
            try:
                cmd = conn.recv(1024)
                data = cmd.decode('gbk').split()
                if data[0] == 'get':
                    get(cmd,conn)
                elif data[0] == 'put':
                    put(cmd,conn)

            except ConnectionResetError:
                break
        conn.close()
    server.close()

if __name__ == '__main__':
    run()

　　　　客户端文件夹包括dowland、share文件夹和client.py

　　　　client.py

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcong

import socket
import struct
import json
import os
downland_dir = r'D:pycharmTest1Thrid_module网络编程文件传输文件传输优化_函数版客户端dowland'
share_dir = r'D:pycharmTest1Thrid_module网络编程文件传输文件传输优化_函数版客户端share'

def get(client,cmd):
    '''
    用户下载功能
    :param client:
    :param cmd:
    :return:
    '''
    # 等待接收
    # 1、获取报头长度
    obj = client.recv(4)
    header_size = struct.unpack('i',obj)[0]
    # 2、获取报头内容
    header_bytes = client.recv(header_size)
    # 3、解析报头，获取真实数据长度
    header_data = header_bytes.decode('gbk')  # bytes解码成字符串
    header_dic = json.loads(header_data)  # 字符串反序列化为字典（报头）
    total_size = header_dic['total_size']  # 得到真实数据长度
    file_name = header_dic['file_name']
    # 4、接收真实数据
    with open('%s\%s' % (downland_dir, file_name), 'wb') as f:
        recv_size = 0
        while recv_size < total_size:
            line = client.recv(1024)
            f.write(line)
            recv_size += len(line)
            print('文件总大小：%s	已下载大小：%s' % (total_size, recv_size))
def put(client,cmd):
    '''
    用户上传功能
    :param cmd:
    :return:
    '''
    # 1、制作报头
    file_name = cmd.split()[1]
    file_dic = {
        'file_name':file_name,
        'md5':'xxxxxxxx',
        'total_size':os.path.getsize('%s\%s'%(share_dir,file_name))
    }
    # 2、编辑并发送报头长度
    header_json = json.dumps(file_dic)
    head_bytes = header_json.encode('gbk')
    client.send(struct.pack('i',len(head_bytes)))
    # 3、发送报头信息
    client.send(head_bytes)
    # 4、发送真实数据信息
    with open('%s\%s'%(share_dir,file_name),'rb') as f:
        for line in f:
            client.send(line)
            # print('文件总大小为：%s	已上传文件大小为：%s'%(file_dic['total_size'],))
def run():
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect(('127.0.0.1', 8889))
    while True:
        cmd = input('输入下载(get)或上传(put)的文件及后缀名>>：').strip()
        if not cmd:continue
        client.send(cmd.encode('gbk'))
        res = cmd.split()[0]
        if res == 'get':
            print('你正在进行下载操作...')
            get(client,cmd)
        elif res == 'put':
            print('你正在进行上传操作...')
            put(client,cmd)

    client.close()
if __name__ == '__main__':
    run()

 

　　3、面向对象版

　　　　服务端包括server_db文件夹(用于存放文件)和server.py

　　　　server.py

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcong

import socket
import struct
import json
import os

class My_server:
    address_family = socket.AF_INET
    socket_type = socket.SOCK_STREAM
    allow_reuse_addres = False # 端口重用
    max_size = 8192  # 最大单次接收字节数目
    coding = 'utf-8' # 编码,windows系统，mac或linux使用utf-8
    listen_queue = 5  # 监听数
    #server_dir = 'D:pycharmTest1Thrid_module网络编程文件传输文件传输优化_面向对象服务端server_db' # 服务器文件目录
    server_dir = 'server_db'
    def __init__(self,server_addres,bind_and_active=True):
        '''由构造函数调用来绑定套接字'''
        self.server_addres = server_addres
        self.socket = socket.socket(self.address_family,self.socket_type)
        if bind_and_active:
            try:
                self.server_bind()
                self.server_active()
            except:
                self.server_close()
                raise

    def server_bind(self):
        '''服务器socket套接字绑定方法'''
        if self.allow_reuse_addres:
            self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 设置端口重用
        self.socket.bind(self.server_addres)
        self.server_addres = self.socket.getsockname()  # 获取本地端点的地址

    def server_active(self):
        '''由构造函数调用以激活服务器 '''
        self.socket.listen(self.listen_queue)

    def get_request(self):
        '''从套接字获取请求和客户端地址'''
        return self.socket.accept()

    def close_request(self,request):
        '''调用以清理单个请求'''
        request.close()

    def server_close(self):
        '''调用以清理服务器'''
        self.socket.close()

    def run(self):
        '''入口程序'''
        while True:
            self.conn,self.client_addres = self.get_request()
            print('from client:',self.client_addres)
            while True:
                try:  # 异常处理
                    head_struct = self.conn.recv(4)#接收报头
                    #if not head_struct:break # linux适用
                    print(head_struct)
                    head_len = struct.unpack('i',head_struct)[0] # 获取报头字典长度
                    head_json = self.conn.recv(head_len).decode(self.coding) #接收字典并转成字符串
                    head_dic = json.loads(head_json) # 将字符串转为字典
                    print(head_dic)
                    cmd = head_dic['cmd']
                    if hasattr(self,cmd): # 反射，判断是否有字符串对应的方法
                        func = getattr(self,cmd)  # 获取字符串对应的方法
                        func(head_dic)  # 执行对应方法
                except Exception:
                    break

    def get(self,dic):
        '''执行用户输入的下载命令'''
        print(dic)
        cmd = dic['cmd']
        file_name = dic['filename'] # 获取下载的文件名
        file_path = os.path.normpath(os.path.join(self.server_dir,file_name)) # 获取文件位置
        if not os.path.isfile(file_path):
            print('文件%s不存在，请核对后再输入！'%file_name)
        else:
            file_size = os.path.getsize(file_path) # 获取文件大小
        # 制作报头
        head_dic = {
            'cmd':cmd,
            'filename':file_name,
            'filesize':file_size,
            'md5':'xxxxxx'
        }
        head_str = json.dumps(head_dic) # 字典转为字符串
        head_bytes= head_str.encode(self.coding) # 字符串转为bytes
        head_struct = struct.pack('i',len(head_bytes)) # 打包成固定字节长度的串
        # 发送报头长度
        self.conn.send(head_struct)
        # 发送报头
        self.conn.send(head_bytes)
        # 发送正式数据
        send_size = 0
        with open(file_path,'rb') as f:
            while send_size<file_size:
                for line in f:
                    self.conn.send(line)
                    send_size += len(line)
                    print('文件总大小：%s,已发送文件：%s'%(file_size,send_size/file_size))

    def put(self,dic):
        '''接收用户上传的文件'''
        file_path = os.path.normpath(os.path.join(self.server_dir,dic['filename'])) #设置存放文件的位置
        file_size= dic['filesize'] # 获取上传文件的大小
        recv_size = 0
        with open(file_path,'wb') as f:
            while recv_size<file_size:
                recv_data = self.conn.recv(self.max_size)
                f.write(recv_data)
                recv_size+=len(recv_data)
                print("文件总大小：%s,已接收文件大小：%s"(file_size,recv_size))

myserver = My_server(('127.0.0.1',3301))
if __name__ == '__main__':
    myserver.run()

　　　　客户端包括client_db文件夹（存放文件）和client.py

#！/usr/bin/env python3
#-*- coding:utf-8 -*-
# write by congcong

import socket
import json
import os
import struct

class My_client:
    addres_family = socket.AF_INET
    socket_type = socket.SOCK_STREAM
    allow_reuse_addres = False # 端口重用
    max_size = 8192 # 单次最大接收或发出文件数据量
    coding = 'utf-8' # 文件或命令编码格式
    listen_queue = 5
    #client_dir = 'D:pycharmTest1Thrid_module网络编程文件传输文件传输优化_面向对象客户端client_db'
    client_dir = 'client_db'
    def __init__(self,server_addres,connect=True):
      '''由构造函数调用来绑定套接字'''
      self.server_addres = server_addres
      self.socket = socket.socket(family=socket.AF_INET,type=socket.SOCK_STREAM)
      if connect:
          try:
              self.client_connect() # 调用链接方法
          except:
              self.client_connect()
              raise
    def client_connect(self):
        '''链接方法'''
        self.socket.connect(self.server_addres)
    def client_close(self):
        '''关闭链接方法'''
        self.socket.close()
    def run(self):
        '''客户端程序入口'''
        while True:
            res = input('输入getput 文件名+后缀>>').strip()
            if not res:continue
            str =res.split()
            cmd = str[0] # 获取get或put命令
            file_name = str[1]
            if hasattr(self,cmd):
                func = getattr(self,cmd)
                func(str)
    def get(self,res):
        '''执行下载方法'''
        cmd = res[0] # 得到下载命令
        file_name = res[1] # 得到文件名
        # 制作报头
        head_dic ={
            'cmd':cmd,
            'filename':file_name,
            'md5':'xxxxx'
        }
        print(head_dic)
        head_str = json.dumps(head_dic) # 字典转字符串
        head_byte= head_str.encode(self.coding) # 字符串转byte
        head_stuct = struct.pack('i',len(head_byte)) # byte打包为指定字节长度的包
        # 发送报头长度
        self.socket.send(head_stuct)
        # 发送报头里的数据
        self.socket.send(head_byte)
        # 接收下载信息的报头
        head_recv_struct = self.socket.recv(4)
        # 解析报头，获取下载文件的大小
        head_recv_size = struct.unpack('i',head_recv_struct)[0]
        # 接收下载信息的报头数据，并解码
        head_recv_data = self.socket.recv(head_recv_size).decode(self.coding)
        # 将解码的字符串反序列化为字典
        head_recv_dic = json.loads(head_recv_data)
        print(head_recv_dic)
        # 获取待接收的文件的大小和文件名
        file_size = head_recv_dic['filesize']
        recv_file_name = head_recv_dic['filename']
        # 接收下载数据
        file_path = os.path.normpath(os.path.join(self.client_dir, file_name))  # 设定下载文件存放位置
        recv_size = 0
        with open(file_path,'wb') as f:
            while recv_size < file_size:
                recv_data = self.socket.recv(self.max_size)
                f.write(recv_data)
                recv_size += len(recv_data)
                print('文件总大小：%s,已下载文件：%s'%(file_size,recv_size/file_size))

    def put(self, str):
        cmd = str[0]  # 获得'put'
        file_name = str[1]
        file_path = os.path.normpath(os.path.join(self.client_dir, file_name))
        # 制定报头
        if not os.path.isfile(file_path):
            # os.path.isfile(path)  #判断路径是否为文件
            print('%s is not exist' % file_name)
            return
        else:
            file_size = os.path.getsize(file_path)  # 获取文件大小
        head_dic = {
            'cmd': cmd,
            'filename': os.path.basename(file_path),
            'filesize': file_size,
        }  # 制作报头
        print(head_dic)
        head_json = json.dumps(head_dic)  # 将字典转为字符串
        head_bytes = bytes(head_json, encoding=self.coding)  # 字符串转为bytes
        print(head_bytes)  # b'{"cmd": "put", "filename": "pic.jpg", "filesize": 7}'
        head_struct = struct.pack('i', len(head_bytes))  # 打包成固定字节长度的bytes数据
        self.socket.send(head_struct)  # 发送报头长度
        self.socket.send(head_bytes)  # 发送报头
        send_size = 0
        with open(file_path, 'rb') as f:
            for line in f:
                self.socket.send(line)
                send_size += len(line)
                print("你上传的文件总大小为：%d	已上传：%d%%" % (file_size, (send_size / file_size) * 100))
            print('上传成功')

myclient = My_client(('127.0.0.1',3301))
if __name__ == '__main__':
    myclient.run()