37 - 网络编程-UDP编程

目录

  • 1 UDP协议
  • 2 UDP通信流程
  • 3 UDP编程
    • 3.1 构建服务端
    • 3.3 常用方法
  • 4 聊天室
  • 5 UDP协议应用

1 UDP协议

UDP是面向无连接的协议，使用UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，就可以直接发数据包。但是，能不能到达就不知道了。虽然用UDP传输数据不可靠，但它的优点是和TCP比，速度快，对于不要求可靠到达的数据，就可以使用UDP协议。

2 UDP通信流程

我们先来了解一下，python的socket的通讯流程:

服务端：

  1. 创建Socket对象
  2. 绑定IP地址Address和端口Port，使用bind方法，IPv4地址为一个二元组(‘IP‘,Port)，一个UDP端口只能被绑定一次
  3. 接受数据，recvfrom方法，使用缓冲区接受数据
  4. 发送数据，sendto方法，类型为bytes
  5. 关闭连接

客户端：

  1. 创建Socket对象
  2. 连接服务端。connect方法（可选）
  3. 发送数据，sendto/send方法，类型为bytes
  4. 接受数据，recvfrom/recv方法，使用缓冲区接受数据
  5. 关闭连接

我们可以看到UDP不需要维护一个连接，所以比较简单

3 UDP编程

????????使用udp编程和使用tcp编程用于相似的步骤，而因为udp的特性，它的服务端不需要监听端口，并且客户端也不需要事先连接服务端。根据上图，以及建立服务端的流程，我门来捋一下服务端的逻辑到代码的步骤：

3.1 构建服务端

  1. 创建服务端
socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
# socke.AF_INET 指的是使用 IPv4
# socket.SOCK_STREAM 指定使用面向数据报的UDP协议
  1. 绑定IP地址和端口。
socket.bind(('127.0.0.1',999))
# 小于1024的端口只有管理员才可以指定
  1. 接受数据(阻塞)
data, client_info = sock.recvfrom(1024)
# 返回一个元组，数据和客户端的地址，因为UDP没有连接，所以只能通过提取消息的发送的源地址，才能在应答时指定对方地址
  1. 发送数据
sock.sendto('data'.encode(),('127.0.0.1',999)) # bytes格式
# 第二个参数为客户端地址
  1. 关闭连接
sock.close()

完成的代码：

import socket

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)      # 指定socket的协议，UDP使用的是SOCK_DGRAM
server.bind(('127.0.0.1', 9999))                               # 绑定端口

print('UDP Server is Starting...')
data, addr = server.recvfrom(1024)                             # 接受(包含数据以及客户端的地址)
print('Received from {}'.format(addr))
server.sendto('hello,{}'.format(addr).encode('utf-8'), addr)   # 应答，格式为(应答的数据，客户端的IP和Port元组)

为什么要使用recvfrom/sendto?

  1. UDP无连接的特性，当服务端收到一条消息时，不会为它维护一个socket的，那么如何应答呢？
  2. UDP报文中包含对方的IP和Port信息，使用recvfrom，就会返回对方发送的数据和对方的地址
  3. sendto由于没有socket的特性，所以应答时也需要传递client的地址和端口

    3.2 构建客户端

  4. 创建客户端
socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
# socke.AF_INET 指的是使用 IPv4
# socket.SOCK_STREAM 指定使用面向数据报的UDP协议
  1. 添加服务端地址信息（可选）。
socket.connect(('127.0.0.1',999))
# UDP不会创建连接，所以这里仅仅是在socket上添加了本段/对端的地址而已，并不会发起连接
  1. 接受数据(阻塞)
data, client_info = sock.recv(1024)
# 返回一个元组，数据和客户端的地址，因为UDP没有连接，所以只能通过提取消息的发送的源地址，才能在应答时指定对方地址
  1. 发送数据
sock.sendto('data'.encode(),('127.0.0.1',999)) # bytes格式
# 第二个参数为客户端地址
  1. 关闭连接
sock.close()

为什么connect是可选的？

  1. 当执行connect时，由于UDP的特性，并不会为我们创建连接，这里仅仅是在socket上添加了对端的地址而已，并不会发起连接
import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
print(client) # <socket.socket fd=140, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0>
client.connect(('127.0.0.1', 9999))
print(client) # <socket.socket fd=140, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 51859), raddr=('127.0.0.1', 9999)>
  1. 如果不执行connect，那么在使用send发生时，就无法知道对端的IP地址，那么只能使用sendto来指定了。
  2. 为什么接收时使用recv，因为是client，只会有server应答消息，所以就不需要来区分了。
  3. 如果指定了connect，sendto已久可以发给任意终端，但recv只能接受connect指定的对端，发来的消息。

完整的代码：

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)            # 指定socket的协议，UDP使用的是SOCK_DGRAM
client.sendto('hello world'.encode('utf-8'), ('127.0.0.1', 9999))    # 发送数据，格式为(发送的数据，服务端的IP和Port元组)
print(client.recv(1024).decode('utf-8'))                             # 同样使用recv来接受服务端的应答数据

UDP的使用与TCP类似，但是不需要建立连接。此外，服务器绑定UDP端口和TCP端口互不冲突，也就是说，UDP的9999端口与TCP的9999端口可以各自绑定。　

3.3 常用方法

服务器端套接字:

函数 描述
s.bind() 绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。

客户端套接字:

函数 描述
s.connect() 初始化UDP连接对象的，本段/对端地址。
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数:

函数 描述
s.recv() 接收TCP/UDP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。
s.send() 发送TCP/UDP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。
s.recvfrom() 接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
s.sendto() 发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
s.close() 关闭套接字
s.fileno() 返回套接字的文件描述符。
s.setblocking(flag) 如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
s.makefile() 创建一个与该套接字相关连的文件

4 聊天室

下面来模仿上一篇TCP版本的聊天室的结构来创建一个UDP版本的聊天室
服务端：

import socket
import threading
import datetime
import logging

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

class ChatUDPServer:

    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
        self.event = threading.Event()
        self.clients = {}
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    def start(self):
        self.sock.bind((self.ip, self.port))
        threading.Thread(target=self.recv, name='start').start()

    def recv(self):
        while not self.event.is_set():
            # 待清理的列表
            clean = set()

            # 远程主机关闭连接时，这里会触发异常。不知道为啥
            try:
                data, client_addr = self.sock.recvfrom(1024)
            except ConnectionResetError:
                continue

            if data.upper() == 'quit' or data == b'':
                self.clients.pop(client_addr)
                logging.info(client_addr, 'is down')
                continue

            # 心跳包，内容越小越好
            if data.lower() == b'@im@':
                self.clients[client_addr] = datetime.datetime.now().timestamp()
                continue

            logging.info('{}:{} {}'.format(*client_addr, data.decode()))
            self.clients[client_addr] = datetime.datetime.now().timestamp()
            msg = "{}:{} {}".format(*client_addr, data.decode()).encode()
            current = datetime.datetime.now().timestamp()
            for client, date in self.clients.items():
                # 如果10s内没有发送心跳包，则进行清理
                if current - date > 10:
                    clean.add(client)
                else:
                    self.sock.sendto(msg, client)

            # 清理超时连接
            for client in clean:
                self.clients.pop(client)

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

if __name__ == '__main__':
    cus = ChatUDPServer('127.0.0.1', 9999)
    cus.start()

    while True:
        cmd = input('>>>>: ').strip()
        if cmd.lower() == 'quit':
            cus.stop()
            break
        else:
            print(threading.enumerate())

客户端:

import socket
import threading
import logging

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

class ChatUDPClient:

    """
    self.ip: 服务端地址
    self.port：服务端端口
    self.socket：创建一个socket对象，用于socket通信
    self.event：创建一个事件对象，用于控制链接循环
    """

    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
        self.socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
        self.event = threading.Event()

    def connect(self):
        self.socket.connect((self.ip, self.port))
        threading.Thread(target=self.recv, name='recv',daemon=True).start()
        threading.Thread(target=self._heart,name='heart',daemon=True).start()

    def _heart(self):
        while not self.event.wait(5):
            data = '@im@'
            self.send(data)

    def recv(self):
        while not self.event.is_set():

            # 某些服务端强制关闭时，会出b''，这里进行判断
            try:
                data = self.socket.recv(1024)
                if data == b'':
                    self.event.set()
                    logging.info('{}:{} is down'.format(self.ip, self.port))
                    break
                logging.info(data.decode())

            # 有些服务端在关闭时不会触发b''，这里会直接提示异常，这里进行捕捉
            except (ConnectionResetError,OSError):
                self.event.set()
                logging.info('{}:{} is down'.format(self.ip, self.port))

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

    def stop(self):
        self.send('quit')
        self.socket.close()

if __name__ == '__main__':
    ctc = ChatUDPClient('127.0.0.1', 9999)
    ctc.connect()

    while True:
        info = input('>>>>:').strip()
        if not info: continue
        if info.lower() == 'quit':
            logging.info('bye bye')
            ctc.stop()
            break
        if not ctc.event.is_set():
            ctc.send(info)
        else:
            logging.info('Server is down...')
            break

5 UDP协议应用

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

  • 网络足够好
  • 消息不会丢包
  • 包不会乱序

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

应用场景：

  1. 视频音频传输，一般来说，丢些包，问题不大，最多丢些图像，听不清话语。
  2. 海量采集数据，例如传感器发来的数据，丢几十、几百条数据也没有关系。
  3. DNS协议，数据内容小，一个包就能查到结果，不存在乱序，丢包时重新请求解析即可。

一般来说，UDP性能优于TCP，但是可靠性要求高的场合还是要选择TCP协议。

原文地址：https://www.cnblogs.com/dachenzi/p/10505601.html

时间： 2024-10-28 06:42:44

37 - 网络编程-UDP编程的相关文章

Linux 网络编程——UDP编程

概述 UDP 是 User Datagram Protocol 的简称, 中文名是用户数据报协议,是一个简单的面向数据报的运输层协议,在网络中用于处理数据包,是一种无连接的协议.UDP 不提供可靠性的传输,它只是把应用程序传给 IP 层的数据报发送出去,但是并不能保证它们能到达目的地.由于 UDP 在传输数据报前不用在客户和服务器之间建立一个连接,且没有超时重发等机制,故而传输速度很快. UDP 有如下的特点: 1)邮件系统服务模式的抽象(可通过邮件模型来进行对比) 2)每个分组都携带完整的目的

嵌入式 Linux网络编程（三）——UDP编程模型

嵌入式 Linux网络编程(三)--UDP编程模型 UDP编程模型: UDP循环服务器模型为: socket(...); bind(...); while(1) {    recvfrom(...);    process(...);    sendto(...); } server.c代码: #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #inc

Java笔记二十三.网络编程基础与UDP编程

网络编程基础与UDP编程 转载请表明出处:http://blog.csdn.net/u012637501(嵌入式_小J的天空) 一.网络编程基础 1.TCP/IP协议:TCP/IP协议是一个非常实用的网络应用程序通信协议,包括TCP(传输控制协议)和IP地址(计算机唯一标识号). 2.IP地址:IP在互联网中能唯一标识一台计算机,是每一台计算机的唯一标识(身份证),通过这个标识号来指定接收数据的计算机和识别发送数据的计算机,该标识号即为IP地址. (1)Ipv4:指在计算机中IP地址用4个字节(

黑马程序员 网络编程 UDP与TCP

---------------------- ASP.Net+Unity开发..Net培训.期待与您交流! ----------------------/* 网络编程分为两种模式:TCP和UDP 连接互联网的计算机以亿计,为了唯一的标识出每台电脑,互联网就给每台电脑分配一个 唯一独立的ip地址,通过这个ip地址就可以进行计算机之间的数据交换 我们计算机交换的数据功能我们在java中把它封住成一个叫Socket的类, 简称套接字, 端口号:计算机数据的交换一般都是电脑上的程序来维护的,而电脑上又运

网络编程之UDP编程

网络编程之UDP编程 UDP协议是一种不可靠的网络协议,它在通信的2端各建立一个Socket,但是这个Socket之间并没有虚拟链路,这2个Socket只是发送和接受数据的对象,Java提供了DatagramSocket对象作为基于UDP协议的Socket,使用DatagramPacket代表DatagramSocket发送和接受数据报.值得注意的是:UDP编程必须先由客户端发出信息.一个客户端就是一封信,Socket相当于美国式邮筒(信件的收发都在一个邮筒中).端口与协议相关,所以TCP的30

[C# 网络编程系列]专题六：UDP编程

转自:http://www.cnblogs.com/zhili/archive/2012/09/01/2659167.html 引用: 前一个专题简单介绍了TCP编程的一些知识,UDP与TCP地位相当的另一个传输层协议,它也是当下流行的很多主流网络应用(例如QQ.MSN和Skype等一些即时通信软件传输层都是应用UDP协议的)底层的传输基础,所以在本专题中就简单介绍下UDP的工作原理和UDP编程的只是,希望可以对刚接触网络编程的朋友起到入门的作用. 一.UDP介绍 UDP和TCP都是构建在IP层

网络编程UDP Demo

package 网络编程UDP; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.SocketException; public class UDPClient { public static void main(String[] args) { DatagramSocket ds = null; try { // 创建客户端的

网络编程UDP Demo1

!!!这是循环打印的输入的内容,如果要循环输入的话,一定要记得切换线程来输入,要不不管用的 package 网络编程UDP; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.SocketException; public class UDPClient { public static void main(String[] arg

c/c++ 网络编程 UDP 发送端 bind 作用

网络编程 UDP 发送端 bind 作用 upd 发送端 调用bind函数的效果:把socket特定到一个指定的端口,如果不调用bind,内核会随机分配一个端口. upd 发送端 调用bind函数的目的:假如有2个发送端,接收端需要识别是从哪个发送端过来的,就可以分别在发送端调用bind函数,这样一来,接收端就能够知道是哪个发送端过来的数据了. 运行方法:先运行[1,先接收再发送],再运行[2,先发送再接收] 1,先接收再发送: #include <stdio.h> #include <