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协议。