Python网络编程（2）-粘包现象及socketserver模块实现TCP并发

1、 基于Tcp的远程调用命令实现

　　很多人应该都使用过Xshell工具，这是一个远程连接工具，通过上面的知识，就可以模拟出Xshell远程连接服务器并调用命令的功能。

　　Tcp服务端代码如下：

 import socket,subprocess
 ip_port = ("127.0.0.1",8000)
 tcp_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 tcp_server.bind(ip_port)
 tcp_server.listen(5)
 print("the server has started")
 while True:
     try:
         conn,addr = tcp_server.accept()
         cmd = conn.recv(1024)
         if not cmd:break
         res = subprocess.Popen(cmd.decode("utf-8"),shell=True,
                                stdout=subprocess.PIPE,
                                stdin=subprocess.PIPE,
                                stderr=subprocess.PIPE)
         error = res.stderr.read()
         if error:
             cmd_res = error
         else:
             cmd_res = res.stdout.read()
         if not cmd_res:
             cmd_res = "the reply is".encode("gbk")
         conn.send(cmd_res)
     except Exception:
         break

　　Tcp客户端代码如下：

 import socket,subprocess
 ip_port = ("127.0.0.1",8000)
 tcp_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 tcp_client.connect(ip_port)
 while True:
     cmd = input(">>>>").strip()
     if not cmd:continue
     if cmd ==quit:break
     tcp_client.send(cmd.encode("utf-8"))
     cmd_res = tcp_client.recv(1024)
     print("the reply is ",cmd_res.decode("gbk"))
 tcp_client.close()

　　但在用上面两个代码进行模拟Xshell远程调用的过程中，可能会出现一个问题：粘包

2、 粘包

　　在数据信息传输过程中，发动数据的速度可能是3kb/s，但是接收数据的速度可能是10kb/s，甚至更快，应用程序看到的数据都是一个整体或可以说是一个流（stream），一条数据信息有多少字节，应用程序是不可见的。Tcp是面向连接，面向流的协议，这也就成为Tcp容易出现粘包现象的原因。基于Tcp的套接字客户端像服务端上传文件的时候，文件的内容是按照一个个小的字节段传输的，接收方根本不知道什么时候开始，什么时候结束。

　　而Udp将数据信息分成一个个小的数据段，在提取数据的时候，不能以字节为单位任意提取数据，只能以数据段为单位进行提取。所以只有Tcp才会出现粘包现象，而Udp就不会。

　　粘包问题主要造成原因就是接收方不知道数据消息之间的界限，（即开始点和终止点），不知道一次所需提取的数据是多少，所以造成的问题。

　　Tcp是基于数据流、面向连接的协议，因为收发的消息不能为空，在服务端和客户端都必须添加空消息的处理机制，防止程序运行过程中卡住。Udp是基于数据报、无连接的协议，即使发送的是空消息，但实质上它会将发送的空消息封装上消息头，不会收到影响。

　　在如下两种情况下很容易发生粘包现象：

　　（1）   发送数据时间的间隔太短，数据量很小，就会粘合在一种，产生粘包现象。

　　（2）   客户端发送数据后，服务端只接受一部分，再次发送其它数据的时候，服务端会先从缓冲区提取上一次的遗留数据，产生粘包。

　　解决粘包问题的根本就在于：要让接收方知道将要接收数据消息的长度。基于上面的Tcp远程调用命令的程序，该如何解决粘包问题？

　　服务端：

 import socket,subprocess,struct
 ip_port = ("127.0.0.1",8000)
 tcp_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 tcp_server.bind(ip_port)
 tcp_server.listen(5)
 print("the server has started")
 while True:
     while True:
         conn,addr = tcp_server.accept()
         try:
             cmd = conn.recv(1024)
             if not cmd:break
             res = subprocess.Popen(cmd.decode("utf-8"),shell=True,
                                    stdout=subprocess.PIPE,
                                    stdin=subprocess.PIPE,
                                    stderr=subprocess.PIPE)
             error = res.stderr.read()
             if error:
                 cmd_res = error
             else:
                 cmd_res = res.stdout.read()
             if not cmd_res:
                 cmd_res = "the reply is".encode("gbk")
             length = len(cmd_res)
             send_length = struct.pack("i",length)
             conn.send(send_length,cmd_res)
         except Exception:
             break

　　客户端：

 import socket,subprocess,struct
 from functools import partial
 ip_port = ("127.0.0.1",8000)
 tcp_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 tcp_client.connect(ip_port)
 while True:
     cmd = input(">>>>").strip()
     if not cmd:continue
     if cmd ==quit:break
     tcp_client.send(cmd.encode("utf-8"))

     recv_length = tcp_client.recv(4)
     length = struct.unpack("i",recv_length)[0]
     recv_msg = "".join(iter(partial(tcp_client.recv,1024),b""))
     print("the reply is",recv_msg.decode("gbk"))
 tcp_client.close()

3、 socketserver模块

　　在使用上面的程序进行通信时，是没有达到并发的。也就意味着，当第一个客户端占用服务端的资源的时候，第二个客户端再向服务端发起请求，是无法进行通信的。通过sockserver可以实现该功能。

　　sockserver是标准库中的一个高级模块，通过socketserver，将可以使用类来编写网络应用程序，以面向对象的方式的处理方式将更具有组织性和逻辑性。

　　socketserver包含了4个基本的类：基于TCP流式套接字的TCPServer；基于UDP数据报套接字的UDPServer，以及基于文件的基础同步UnixStreamServer和UnixDatagramServer。使用最多的TCPServer，后面三个很少用到。

　　在socketserver服务器框架中，基本所有的处理逻辑代码会放在一个请求处理程序中，（即一个类），服务端每当收到一个请求，就会实例化一个处理程序，并且调用相应的方法来响应客户端发来的请求，BaseRequestHandler类把所有的操作都放在handle方法中，这个方法会访问属性self.request中的客户端套接字。

　　服务端做如下改写：

 import socketserver,struct
 class Server2(socketserver.BaseRequestHandler):
     def handle(self):
        while True:
            try:
                data = self.request.recv(1024)
                if not data:break
                self.request.send(data.title())
            except Exception:
                break
 if __name__ == "__main":
     s = socketserver.ThreadingTCPServer(("127.0.0.1",8080),Server2)
     s.serve_forever()

　　在这个程序中，self.request就等同于前面创建简单TCP服务端的conn，通过重写handle方法，该方法在默认情况下为空。当接收到一个客户端请求的时候，他就会调用handle()方法，然后通过socketserver.ThreadingTCPServer方法，传入给定的主机ip地址、端口号和所定义的类，最后使用serve_forever()方法来启动TCP服务器。无限循环的等待并服务于客户端请求。