Python-UDP编程

1、UDP编程：

　　测试命令：

　　　　windows：

　　　　　　　netstat  -anp udp | findstr 9999
　　　　Linux: 发给服务器数据

　　　　　　echo '233' | nc -u 127.0.0.1 9999

2、UDP服务器端编程：

　　UDP服务器端编程流程：（从图中可以看到，服务器端只需要一个socket）

　　　　

• • • 创建socket 对象，socket.SOCK_DGRAM
    • 绑定IP 和 Port， bind() 方法
    • 传输数据：
      • 接受数据：socket.recvfrom(bufsize [, flags] ) ,获取一个二元组（）
      • 发送数据：socket.sendto(string, address) 发给某地址某信息
    • 释放资源　　　　　

import socket

socket = socket.socket(type=socket.SOCK_DGRAM)

ip = '127.0.0.1'
port = 9999

laddr = ip, port

socket.bind(laddr) #  服务器端正式启动

data, raddr = socket.recvfrom(1024) # 没有接收到，会处于阻塞状态

socket.sendto(data, raddr)

socket.close()

 

　　UDP客户端编程流程：

　　　　注意：UDP是无连接协议，多以可以只有任何一端，例如客户端数据发往服务端，服务器端存在与否无所谓。

　　UDP编程中bind、connect、send、sendto、recv、recfrom方法使用

　　UDP的socket对象创建后，是么有占用本地地址额端口的

　　

　　　　注意：

　　　　　　1、UDP 创建socket后，不能直接recv，recvfrom，，只有知道了本地地址和端口，服务器端才能知道数据应该发给你

　　　　　　2、send 和 connect 搭配使用。

 　　心跳机制：

　　　　加一个ack机制 和 心跳 hearbeat

　　　　心跳，就是一端定时的发往另一端的信息，一般每次数据越少越好，心跳时间间隔约定好就行。

　　　　ack 即响应，一端收到另一端的消息后返回的确认消息

　　　　心跳机制：

1. 1. 一般来说是客户端定时发往服务器端的，服务器端并不需要ACK 回复客户端，只需要记录该客户端还活着就行（比如群聊，如果客户端不活着，就没必要回复）
   2. 如果是服务器端定时发往客户端的，一般需要 客户端ack 响应，表示活着，，如果没有收到ack的客户端，服务器端移除其信息，这种实现比较复杂，较少使用。
   3. 也就是双向都发送心跳，很少使用

 

UDP实现群聊：

　　server端：

import socket
import threading
import logging
import datetime


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

class ChatServer:
    def __init__(self, ip='127.0.0.1', port=9999, interval=10):
        self.laddr = ip, port
        self.event = threading.Event()
        self.sock = socket.socket(type=socket.SOCK_DGRAM)
        self.clients = {}
        self.interval = interval

    def start(self):
        self.sock.bind(self.laddr)

        threading.Thread(target=self.recv, name='recvive').start()

    def recv(self):
        while not self.event.is_set():
            data, raddr = self.sock.recvfrom(1024)
            localkeys = set()
            logging.info(data)

            # 心跳信息
            if data.strip() == b'^hb^':
                self.clients[raddr] = datetime.datetime.now().timestamp()
                continue

            if data.strip() == b'quit':
                # 若一个客户端刚进来，还没有加到字典中，直接pop，会报KerryError
                # if raddr in self.clients.keys():
                self.clients.pop(raddr, None)
                continue
            self.clients[raddr] = datetime.datetime.now().timestamp()

            # z再次发送数据的时间，如果之后没有再次进入，这次的时间就作为下次比较时间，所以这次的时间可以认为是最新的心跳信息
            current = datetime.datetime.now().timestamp()
            msg = '{}--{}'.format(data.decode(), '******').encode()

            # 过期的就不在发数据给客户端了，并且剔除掉
            #z 字典不能再遍历的时候，删除内容
            for r, t in self.clients.items():
                if current - t > self.interval:
                    localkeys.add(r)
                self.sock.sendto(msg, r)
            for r in localkeys:
                self.clients.pop(r)

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


def main():
    cs = ChatServer()
    cs.start()

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


if __name__ == "__main__":
    main()

 

　　client端：

import socket
import threading
import logging
import datetime


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

class ChatClient:
    def __init__(self, ip='127.0.0.1', port=9999, interval=3):
        self.raddr = ip, port
        self.event = threading.Event()
        self.sock = socket.socket(type=socket.SOCK_DGRAM)
        self.interval = interval

    def start(self):
        self.sock.connect(self.raddr)

        threading.Thread(target=self.recv, name='c-recv').start()

        #  每隔interval 就发送一次心跳信息
        threading.Thread(target=self.hearbeat, name='ht',daemon=True).start()

    def recv(self):
        while not self.event.is_set():
            data, raddr = self.sock.recvfrom(1024)
            print(data)
            print(raddr)
    def hearbeat(self):
        while not self.event.wait(self.interval):
            self.send('^hb^')



    def send(self, msg):
        self.sock.send(msg.encode())

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


def main():
    cc = ChatClient()
    cc.start()

    while True:
        cmd = input('>>')
        if cmd == 'quit':
            cc.stop()
            break
        cc.send(cmd)
        logging.info(threading.enumerate())



if __name__ == "__main__":
    main()

 

 

　　　　

　　　　注意：

　　　　　　如果是如上图所示，是一个解释器进程，建立两个对象，但是这两个对象分别在不同的线程中跑。

　　　　　　如果直接运行两次 client，就是两个客户端进程

 

UDP 协议的应用:

　　UDP 是无连接的，它是基于以下假设：

　　　　网络足够好
　　　　消息不会丢包

　　　　包不会乱序

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

 

　　应用场景：

　　　　视频，音频传输，一般来说丢一些包。