16、Python之socket网络编程

一、socket

socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）。基本上，Socket 是任何一种计算机网络通讯中最基础的内容。例如当你在浏览器地址栏中输入 http://www.cnblogs.com/ 时，你会打开一个套接字，然后连接到http://www.cnblogs.com/ 并读取响应的页面然后然后显示出来。而其他一些聊天客户端如 gtalk 和 skype 也是类似。任何网络通讯都是通过 Socket 来完成的。

Python 官方关于 Socket 的函数请看 http://docs.python.org/library/socket.html

socket和file的区别：

　　1、file模块是针对某个指定文件进行【打开】【读写】【关闭】

　　2、socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】

根据上图，下面我们就用python来写一个socket的服务端。

import socket
#第一步  创建流套接字描述符
server = socket.socket()
#第二步 命名套接字（协议，地址，端口）
server.bind(("localhost",8081))
#第三步 监听客户端socket请求
server.listen()
#建立连接
conn,address = server.accept()
#第四部 数据传输
rec_data = conn.recv(1024)
print(rec_data)
conn.send(rec_data.upper())
#第五步骤 关闭
server.close()

上面服务端的逻辑就是将客户端发送过来的数据转转换为大写再发送给客户端，下面我们再写一个客户端的程序。

import socket
#第一步  创建流套接字描述符
client = socket.socket()
#第二步 连接远程socket服务器
client.connect(("localhost",8081))
#第四步 数据交换
user_data = "abcdefg"
client.send(user_data.encode("utf-8")) #数据传输必须采用二进制的格式
print("发送的数据:",user_data)
recv_data = client.recv(1024)
print("返回的数据:",recv_data.decode("utf-8"))
client.close()

先启动服务端，再执行客户端的代码，执行结果为：

但是，我们发现当我们执行完程序后，客户端和服务端的程序全都运行结束了，而我们知道服务端的程序应该是一直运行的，因此我们对服务端的程序进行改造，增加while循环，使得服务端的代码一直处于运行状态。改造如下：

import socket
#第一步  创建流套接字描述符
server = socket.socket()
#第二步 命名套接字（协议，地址，端口）
server.bind(("localhost",8081))
while True:
    #第三步 监听客户端socket请求
    server.listen()
    #建立连接
    conn,address = server.accept()
    #第四部 数据传输
    rec_data = conn.recv(1024)
    print(rec_data)
    conn.send(rec_data.upper())
    #第五步骤 关闭
server.close()

这样，服务端的代码就一直处于等待服务状态。好了，现在让我们把焦点转到数据交换上，conn.recv(1024)这句代码的意思是接受1024个字节的数据，那么问题来了，如果服务端或客户端发送的数据超过1024个字节怎么办？其实，客户端和服务端的数据交换，大致原理是这样的滴：服务端把数据发送到一个队列中，客户端每次从这个队列中取数据。这就好比，A把苹果放在一个篮子里面，B去取，但是B每次只能取4个，如果A放了5个苹果在篮子里面，那B也只能取4个，剩下的1个，就会被其他的人拿走（可能这个人想要的是香蕉）。这样整个流程就乱了。为了解决这样的问题，我们可以先让A告诉B他放了几个苹果，然后B就知道他要取多少个了，为了突显效果，我们现在让客户端和服务端每次只接受4个字节的数据（将客户端和服务端conn.recv(1024)改成conn.recv(4)）。

      

运行结果表明，客户端发送了5个字节是数据，服务端只取了4个字节，现在我们改造代码，让客户端和服务都循环去接收数据。改造后接近完美的服务端：

import socket
#第一步  创建流套接字描述符
server = socket.socket()
#第二步 命名套接字（协议，地址，端口）
server.bind(("localhost",8081))
while True:
    #第三步 监听客户端socket请求
    server.listen()
    # 建立连接
    conn, address = server.accept()
    while True:
        try:
            # 第四部 数据传输
            rec_data_szie = conn.recv(4)  # 先拿到要发送的数据大小
            conn.send(b"200")  # 回复客户端已经收到
            b_real_size = 0
            rec_data = b''
            while b_real_size != int(rec_data_szie.decode("utf-8")):  # 循环接收数据
                rec_data += conn.recv(4)
                b_real_size = len(rec_data)
            print(rec_data)
            conn.send(str(len(rec_data.upper())).encode("utf-8"))  # 发送给客户端 服务端要发送的数据大小
            conn.recv(5)
            conn.send(rec_data.upper())
            print("一次数据交换完成")
        except ConnectionResetError as e:
            print("客户端断开")
            break
    #第五步骤 关闭
server.close()

改造后接近完美的客户端：

import socket
#第一步  创建流套接字描述符
client = socket.socket()
#第二步 连接远程socket服务器
client.connect(("localhost",8081))
#第四步 数据交换
while True:
    user_data = input("输入数据:")
    b_user_data = user_data.encode("utf-8")
    b_user_data_size = str(len(b_user_data)).encode("utf-8")
    client.send(b_user_data_size) #数据传输必须采用二进制的格式
    client.recv(4)
    client.send(b_user_data)
    print("发送的数据:",user_data)
    server_data_size = int(client.recv(4).decode())
    client.send(b'200')
    real_data_size = 0
    recv_data = b''
    while real_data_size!= server_data_size:
        print(real_data_size,server_data_size)
        recv_data += client.recv(4)
        real_data_size = len(recv_data)
    print("返回的数据:",recv_data.decode("utf-8"))
client.close()

上面的客户端和服务端就可以进行无畅通的数据交换了。

二、SocketServer

    socketServer是对服务端进行封装的一个类，与我们上面自己写的服务端的代码相比有两个优点，第一，使用方便（不需要自己写循环啥的了），第二，支持多用户同时进行通信（咱们上面服务端的代码是不行的，你可以踹一踹）。

   下面介绍一下如何使用socketServer来写服务端代码，步骤如下：

1、创建MyTCPHandler类（自定义类），继承socketserver.BaseRequestHandler)
2、重写handle方法，此方法为服务端处理客户端的代码逻辑
3、通过server = socketserver.TCPServer((HOST,PORT),MyTCPHandler)创建server对象
   server = socketserver.ThreadingTCPServer((HOST,PORT),MyTCPHandler)(多线程)
4、server.serve_forever()等待处理请求

经过上面的步骤后，我们就可以基于SocketServer编写服务端的代码，现在把上面socket编写的服务端的代码改造成基于SocketServer的。

import socketserver

class MyTCPHandler(socketserver.BaseRequestHandler):#自定义类
    def handle(self):
        while True:
            try:
                # 第四部 数据传输
                rec_data_szie = self.request.recv(4)  # 先拿到要发送的数据大小
                self.request.send(b"200")  # 回复客户端已经收到
                b_real_size = 0
                rec_data = b''
                while b_real_size != int(rec_data_szie.decode("utf-8")):  # 循环接收数据
                    rec_data += self.request.recv(4)
                    b_real_size = len(rec_data)
                print(rec_data)
                self.request.send(str(len(rec_data.upper())).encode("utf-8"))  # 发送给客户端 服务端要发送的数据大小
                self.request.recv(5)
                self.request.send(rec_data.upper())
                print("一次数据交换完成")
            except ConnectionResetError as e:
                print("客户端断开")
                break
server = socketserver.ThreadingTCPServer(("localhost",8081),MyTCPHandler)
server.serve_forever()

三、简易FTP实战

    通过上面socket的学习，我们可开发一个简易的ftp工具用于上传和下载文件，核心代码如下，服务端：

import socketserver,json,os

class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            try:
                user_data = self.request.recv(1024).decode()
                print("服务器收到的用户数据:", user_data)
                user_data_dic = json.loads(user_data)
                self.request.send(b"200")
                getattr(self,user_data_dic["action"])(user_data_dic)
            except (ConnectionResetError,TypeError) as e:
                print(e)
                break
            # except:
            #     print("系统异常！")
            #     break

    def upload(self,user_data_dic):
        real_b_data_size = 0
        file_data_size = user_data_dic["file_size"]
        file_name = user_data_dic["path"] + "/" + user_data_dic["file_name"].split('/')[-1]
        print("文件名:",file_name)
       # b_data = b''
        upload_process, first_upload_process = 0, 0
        while True:
            first_upload_process = upload_process  # 记录上一次的进度
            f = open(file_name, "ab")
            b_data = self.request.recv(4096)
            f.write(b_data)
            real_b_data_size = real_b_data_size + len(b_data)
            upload_process = (real_b_data_size * 100 // file_data_size);
            if first_upload_process != upload_process or upload_process == 100:
                print("上传进度:%s
" % upload_process)
            if real_b_data_size >= file_data_size:
                f.close()
                # print("b_data:", b_data)
                # self.request.send(b"ok")
                break
    def ls(self,user_data_dic):
        b_list_dir = json.dumps(os.listdir(user_data_dic["path"])).encode("utf-8")
        self.request.recv(1024)
        self.request.send(b_list_dir)
    def cd(self,user_data_dic):
        re_data_dict = {"flag":False,"path":None}
        self.request.recv(1024)
        path = user_data_dic["path"] + "/" + user_data_dic["dir"]
        dir = user_data_dic["dir"]
        if os.path.isdir(path):
            re_data_dict["flag"] = True
            path_list = path.split('/')
            if dir == "..":
                del path_list[-1],path_list[-1]
                path_str = ""
                if len(path_list) >= 1:
                    for path_temp in path_list:
                        path_str = path_str + path_temp + "/"
                    path_str = path_str[:-1]
                    re_data_dict["path"] = path_str
                else:
                    re_data_dict["flag"] = False
            else:
                re_data_dict["path"] = path
        b_recv_data = json.dumps(re_data_dict).encode("utf-8")
        self.request.send(b_recv_data)


port = ("localhost",8888)
server = socketserver.ThreadingTCPServer(port,MyTCPHandler)
server.serve_forever()

客户端代码如下：

import socket,os,json

class MyTCPClient(object):
    def __init__(self,port,path):
        self.__conn = socket.socket()
        self.__conn.connect(port)
        self.path = path
    def upload(self,file_name):
        if os.path.isfile(file_name):
            user_data = {
                         "file_name":None,
                         "file_size":None,
                         "action": "upload",
                         "path":self.path
                         }
            user_data["file_name"] = file_name #文件名
            f = open(file_name,"rb")
            file_size = os.stat(file_name).st_size
            user_data["file_size"] = file_size
            b_user_data = str(json.dumps(user_data)).encode("utf-8")
            print("用户数据:",b_user_data)
            self.__conn.send(b_user_data)
            b_code = self.__conn.recv(1024)
            print("b_code:",b_code)
            for line in f:
                self.__conn.send(line)  #发送数据
            else:
                print("上传成功!")
            f.close()
        else:
            print("查无此文件！")
    def help(self):
        print("1、upload fileName
2、download fileName
3、cd 命令")
    def __del__(self):
        self.__conn.close()
    def __tradeCenter(self,user_data_dict):
        b_user_data = json.dumps(user_data_dict).encode("utf-8")
        self.__conn.send(b_user_data)
        recv_data = self.__conn.recv(1024)
        print(recv_data)
        self.__conn.send(b"readdly")
        return self.__conn.recv(1024)
    def cd(self,dir):
        user_data_dict = {"path":self.path,"action":"cd","dir":dir}
        recv_data = self.__tradeCenter(user_data_dict).decode()
        recv_data_dict = json.loads(recv_data)
        if recv_data_dict["flag"]:
            self.path = recv_data_dict["path"]
            print(recv_data_dict)
        else:
            print("不存在此目录!")
    def ls(self,dir):
        user_data_dict = {"path":self.path,"action":"ls"}
        dir_str = self.__tradeCenter(user_data_dict).decode("utf-8")
        dir_list = json.loads(dir_str)
        print("33[041;1m目录列表:33[0m")
        for file in dir_list:
            print(file)
    def pwd(self,arge):
        print(self.path)

my_ftp_client = MyTCPClient(("localhost",8888),"gwx")
while True:
    print("欢迎使用ftp系统!")
    my_ftp_client.help()
    while True:
        data = input(my_ftp_client.path+">>")
        if data is not '':
            break
    if data == 'exit':
        break
    temp_data = data.split(" ")
    print(temp_data)
    try:
        getattr(my_ftp_client,temp_data[0])(temp_data[1])
    except (AttributeError,IndexError) as e:
        print("请输入正确的命令")
        my_ftp_client.help()

 注：由于时间及个人能力有限，只供参考，谢谢！