socket,socketserver,tcp黏包问题,网络编程

1,socket的使用

1. 基于TCP的socket的使用
   TCP是有链接，面向流的，客户端和服务端一旦连接，不在断开的时候是不会断的
   简单使用
   

   #!/usr/bin/env python
   # -*- coding: utf-8 -*-
   # @time     : 2019/6/13 19:36
   # @Author   : aolishuai
   # @File     : 服务端
   
   import socket
   
   #创建一个socket对象
   server = socket.socket()#创建一个手机
   
   ip_port = ('192.168.1.9',8001)#创建一张电话卡
   
   server.bind(ip_port)#插上电话卡
   
   #监听IP地址和端口
   server.listen()#开机,listen(10)后面可以有10人等待，超过10人，直接让超过的人数去掉
   
   
   print(1111)
   #等待客户端的连接
   conn, addr =server.accept()
   #接收消息
   from_client_msg=conn.recv(1024)#单位大小为B，1KB=1024B
   #消息字符转换并打印
   print(from_client_msg.decode('utf-8'))
   #消息发给客户端
   conn.send("勇士说的".encode('utf-8'))
   
   #消息发完断开连接,
   conn.close()
   #服务端关机
   server.close()

   #!/usr/bin/env python
   # -*- coding: utf-8 -*-
   # @time     : 2019/6/13 19:36
   # @Author   : aolishuai
   # @File     : 客户端
   import socket
   client = socket.socket()
   #拿到服务端IP和端口
   server_ip_port = ('192.168.1.9',8001)
   #连接服务端
   client.connect(server_ip_port)
   #发消息
   client.send("kd断了".encode('utf-8'))
   
   from_server_msg=client.recv(1024)
   from_server_msg=from_server_msg.decode("utf-8")
   print(from_server_msg)
   
   #客户端关闭
   client.close()

    

2. UDP是没有连接，服务端只能在接收客户端发过来的消息获取到客户端的地址之后，才能返回消息
   

   #!/usr/bin/env python
   # -*- coding: utf-8 -*-
   # @time     : 2019/6/14 15:51
   # @Author   : aolishuai
   # @File     : server
   
   import socket
   
   sk = socket.socket(type=socket.SOCK_DGRAM)
   sk.bind(('127.0.0.1',8081))
   
   msg,addr = sk.recvfrom(1024)
   print(msg.decode('utf-8'))
   sk.sendto(b'hihao',addr)
   
   sk.close()

   #!/usr/bin/env python
   # -*- coding: utf-8 -*-
   # @time     : 2019/6/14 15:51
   # @Author   : aolishuai
   # @File     : client
   import socket
   sk = socket.socket(type=socket.SOCK_DGRAM)
   ip_port=('127.0.0.1',8081)
   
   sk.sendto(b'hi',ip_port)
   msg,addr=sk.recvfrom(1024)
   print(msg.decode('utf-8'))
   sk.close()

   简单的UDPsock使用，服务端是一个时间服务器，在客户端需要发送的时候，发送对应格式的时间

   #!/usr/bin/env python
   # -*- coding: utf-8 -*-
   # @time     : 2019/6/14 16:18
   # @Author   : aolishuai
   # @File     : time_server
   import socket,time
   
   sk = socket.socket(type=socket.SOCK_DGRAM)
   ip_port=('127.0.0.1',8082)
   
   sk.bind(ip_port)
   
   while True:
       msg,addr = sk.recvfrom(1024)
       msg=msg.decode('utf-8')
       print(msg)
       t =time.localtime(time.time())
       give_t = time.strftime(msg,t)
       sk.sendto(give_t.encode('utf-8'),addr)
   
   sk.close()

　　　　

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @time     : 2019/6/14 16:18
# @Author   : aolishuai
# @File     : time_client

import socket

sk = socket.socket(type=socket.SOCK_DGRAM)
ip_port=('127.0.0.1',8082)
while True:
    geshi = input('请输入时间格式:').encode('utf-8')
    sk.sendto(geshi,ip_port)
    msg,addr = sk.recvfrom(1024)
    msg= msg.decode('utf-8')
    print('时间是{0}'.format(msg))
sk.close()

 

1. 1. 黏包问题
      

      黏包问题：
          tcp协议在进行socket传输的时候，
          1，不知道包有多大，接收的时候可能分多次接收
          2，连续传递小数据包，自身优化时间算法，将多个小包一块发送
          这两种情况会导致黏包
      
      
      解决黏包问题
      1，传输的时候，先传递包大小，根据大小，确定接收值，返回收到后，再进行传输
      2，使用struct模块，传输的时候先将包大小传过去，在直接传输数据包
      
      
      1，不使用struct模块解决黏包问题，需要在发送你要发的数据之前，先计算数据大小，先告诉服务端要发的数据大小，然后服务端通过接受到数据大小来确定接收数值

      #!/usr/bin/env python
      # -*- coding: utf-8 -*-
      # @time     : 2019/6/14 22:40
      # @Author   : aolishuai
      # @File     : server
      import socket
      
      sk = socket.socket()
      ip_port = ('127.0.0.1', 8010)
      sk.bind(ip_port)
      sk.listen()
      conn, addr = sk.accept()
      
      while True:
          cmd = input('请输入命令:').encode('gbk')
          conn.send(cmd)
          ret = conn.recv(1024).decode('utf-8')
          conn.send(b'ok')
          ret2 = conn.recv(int(ret)).decode('gbk')
          print(ret2)
      
      
      conn.close()
      sk.close()

      　

      #!/usr/bin/env python
      # -*- coding: utf-8 -*-
      # @time     : 2019/6/14 22:40
      # @Author   : aolishuai
      # @File     : client
      import socket,subprocess
      
      sk = socket.socket()
      ip_port = ('127.0.0.1',8010)
      sk.connect(ip_port)
      
      while True:
          msg = sk.recv(1024).decode('gbk')
          ret = subprocess.Popen(msg,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
          std_out = ret.stdout.read()
          std_err = ret.stderr.read()
          num = str(len(std_out)+len(std_err)).encode('utf-8')
          sk.send(num)
          sk.recv(1024)
          sk.send(std_out)
          sk.send(std_err)
      sk.close()

       

   2.  

      使用struct模块解决黏包问题，struct能把一个类型的数据，转换成相应的bytes类

      #!/usr/bin/env python
      # -*- coding: utf-8 -*-
      # @time     : 2019/6/15 10:56
      # @Author   : aolishuai
      # @File     : server
      
      import socket,struct
      
      sk = socket.socket()
      ip_port = ('127.0.0.1', 8010)
      sk.bind(ip_port)
      sk.listen()
      conn, addr = sk.accept()
      
      while True:
          cmd = input('请输入命令:').encode('gbk')
          conn.send(cmd)
          #ret = conn.recv(1024).decode('utf-8')
          ret = conn.recv(4)
          ret = struct.unpack('i',ret)[0]
      
      
          #conn.send(b'ok')
          ret2 = conn.recv(ret).decode('gbk')
          print(ret2)
      
      
      conn.close()
      sk.close()

      #!/usr/bin/env python
      # -*- coding: utf-8 -*-
      # @time     : 2019/6/15 10:56
      # @Author   : aolishuai
      # @File     : client
      import socket,subprocess,struct
      
      sk = socket.socket()
      ip_port = ('127.0.0.1',8010)
      sk.connect(ip_port)
      
      while True:
          msg = sk.recv(1024).decode('gbk')
          ret = subprocess.Popen(msg,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
          std_out = ret.stdout.read()
          std_err = ret.stderr.read()
          #num = str(len(std_out)+len(std_err)).encode('utf-8')
          num  = len(std_out)+len(std_err)
          num = struct.pack('i',num)
          sk.send(num)
          #sk.recv(1024)
          sk.send(std_out)
          sk.send(std_err)
      sk.close()

       

      
      　

2，socketserver

使用tcp时，server端和client端只能链一个，通过socketserver能够使多个client与server同时连接

启用的时候，只有server端需要继承socketserver服务

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @time     : 2019/6/16 13:25
# @Author   : aolishuai
# @File     : socketserver

import socketserver
#必须创建一个类
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            msg = self.request.recv(1024).decode('utf-8')
            print(msg)
            info = input('>>>')
            self.request.send(info.encode('utf-8'))


        #print(self.request.recv(1024))#self.request==conn


if __name__ == '__main__':
    server = socketserver.ThreadingTCPServer(('127.0.0.1',8090),MyServer)
    server.serve_forever()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @time     : 2019/6/16 13:33
# @Author   : aolishuai
# @File     : client
import socket
sk = socket.socket()
sk.connect('127.0.0.1',8090)
while True:
    msg = input('>>>>>')
    sk.send(msg.encode('utf-8'))
    ret = sk.recv(1024).decode('utf-8')
    print(ret)
sk.close()