Socket网络编程-UDP编程

　　　　　　　　　　　　Socket网络编程-UDP编程

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.UDP编程概述

1>.UDP服务端编程流程

　　创建socket对象。socket.SOCK_DGRAM 

　　绑定IP和Port，bind()方法

　　传输数据
　　　　接收数据，socket.recvfrom(bufsize[, flags])，获得一个二元组(string, address)
　　　　发送数据，socket.sendto(string, address) 发给某地址某信息 

　　释放资源

2>.UDP客户端编程流程

　　创建socket对象。socket.SOCK_DGRAM
　　发送数据，socket.sendto(string, address)发给某地址某信息 
　　　　
　　接收数据，socket.recvfrom(bufsize[, flags])，获得一个二元组(string, address) 

　　释放资源 

3>.UDP编程中常用的方法

　　bind方法
　　　　可以指定本地地址和端口laddr，会立即占用

　　connect方法
　　　　可以立即占用本地地址和端口laddr，填充远端地址和端口raddr

　　sendto方法
　　　　可以立即占用本地地址和端口laddr，并把数据发往指定远端。只有有了本地绑定端口，sendto就可以向任何远端发送数据

　　send方法
　　　　需要和connect方法配合，可以使用已经从本地端口把数据发往raddr指定的远端

　　recv方法
　　　　要求一定要在占用了本地端口后，返回接收的数据

　　recvfrom方法
　　　　要求一定要占用了本地端口后，返回接收的数据和对端地址的二元组

4>.心跳机制

　　增加心跳heartbeat机制或ack机制。这些机制同样可以用在TCP通信的时候。 心跳，就是一端定时发往另一端的信息，一般每次数据越少越好。心跳时间间隔约定好就行。 ack即响应，一端收到另一端的消息后返回的确认信息。

　　心跳机制实现策略:
　　　　1.一般来说是客户端定时发往服务端的，服务端并不需要ack回复客户端，只需要记录该客户端还活 着就行了。当然服务端也可响应客户端
　　　　2.如果是服务端定时发往客户端的，一般需要客户端ack响应来表示活着，如果没有收到某客户端的ack响应，服务端移除其信息。这种实现较为复杂，用的较少
　　　　3.也可以双向都发心跳的，用的更少 

二.UDP版群聊案例

1>.UDP版群聊服务端代码

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 import socket
 import threading
 import datetime
 import logging

 FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
 logging.basicConfig(format=FORMAT, level=logging.INFO)

 #在服务器端代码中使用第一种心跳机制改进
 class ChatUDPServer:
     def __init__(self, ip='127.0.0.1', port=6688, interval=10):
         self.addr = (ip, port)
         self.sock = socket.socket(type=socket.SOCK_DGRAM)
         self.clients = {} # 记录客户端，改为字典
         self.event = threading.Event()
         self.interval = interval # 默认10秒，超时就要移除对应的客户端

     def start(self):
         self.sock.bind(self.addr) # 立即绑定
         # 启动线程
         threading.Thread(target=self.recv, name='recv').start()

     def recv(self):
         removed = set()  # 超时的
         while not self.event.is_set():
             data, raddr = self.sock.recvfrom(1024)  # 阻塞接收数据
             current = datetime.datetime.now().timestamp()  # float
             if data.strip() == b'^hb^': # 心跳信息
                 print('^^^^^^^^hb', raddr)
                 self.clients[raddr] = current
                 continue
             elif data.strip() == b'quit':
                 #有可能发来数据的不在clients中
                 self.clients.pop(raddr, None)
                 logging.info('{} leaving'.format(raddr))
                 continue

             #有信息来就更新时间
             #什么时候比较心跳时间呢? 发送信息的时候，反正要遍历一遍
             self.clients[raddr] = current
             msg = '{}. from {}:{}'.format(data.decode(), *raddr)
             logging.info(msg)
             msg = msg.encode()

             for c, stamp in self.clients.items():
                 if current - stamp > self.interval:
                     removed.add(c)
                 else:
                     self.sock.sendto(msg, c)  # 不保证对方能够收到

             for c in removed:
                self.clients.pop(c)
                removed.clear()

     def stop(self):
         self.event.set()
         self.clients.clear()
         self.sock.close()

 def main():
     server = ChatUDPServer()
     server.start()

     while True:
         cmd = input(">>> ")
         if cmd.strip() == 'quit':
             server.stop()
             break
         logging.info(threading.enumerate())
         logging.info(server.clients)

 if __name__ == '__main__':
     main()

2>.UDP版群聊客户端代码

 #！/usr/bin/env python
 #_*_conding:utf-8_*_
 #@author :yinzhengjie
 #blog:http://www.cnblogs.com/yinzhengjie

 import threading
 import socket
 import logging

 FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
 logging.basicConfig(format=FORMAT, level=logging.INFO)

 #增加定时发送心跳代码
 class ChatUdpClient:
     def __init__(self, rip='127.0.0.1', rport=6688):
         self.sock = socket.socket(type=socket.SOCK_DGRAM)
         self.raddr = (rip, rport)
         self.event = threading.Event()

     def start(self):
         self.sock.connect(self.raddr) # 占用本地地址和端口，设置远端地址和端口
         threading.Thread(target=self._sendhb, name='heartbeat', daemon=True).start()
         threading.Thread(target=self.recv, name='recv').start()

     def _sendhb(self): # 心跳
         while not self.event.wait(5):
             self.send('^hb^')

     def recv(self):
         while not self.event.is_set():
             data, raddr = self.sock.recvfrom(1024)
             msg = '{}. from {}:{}'.format(data.decode(), *raddr)
             logging.info(msg)

     def send(self, msg:str):
         self.sock.send(msg.encode())
         # self.sock.sendto(msg.encode(), self.raddr)

     def stop(self):
         self.event.set()
         self.send('quit')   #通知服务端退出
         self.sock.close()

 def main():
     client1 = ChatUdpClient()
     client2 = ChatUdpClient()
     client1.start()
     client2.start()
     print(client1.sock)
     print(client2.sock)

     while True:
         cmd = input('Input your words >> ')
         if cmd.strip() == 'quit':
             client1.stop()
             client2.stop()
             break
         client1.send(cmd)
         client2.send(cmd)

 if __name__ == '__main__':
     main()

三.UDP协议应用

　　UDP是无连接协议，它基于以下假设:
　　　　网络足够好
　　　　消息不会丢包
　　　　包不会乱序

　　但是，即使是在局域网，也不能保证不丢包，而且包的到达不一定有序。

　　应用场景:
　　　　视频、音频传输，一般来说，丢些包，问题不大，最多丢些图像、听不清话语，可以重新发话语来解 决。
　　　　海量采集数据，例如传感器发来的数据，丢几十、几百条数据也没有关系。 DNS协议，数据内容小，一个包就能查询到结果，不存在乱序，丢包，重新请求解析。
　　　　一般来说，UDP性能优于TCP，但是可靠性要求高的场合的还是要选择TCP协议。 DNS使用的就是UDP协议和TCP协议。