Socket 通信之 UDP 通信

补丁牛仔裤 2023-03-30 发布于广东

展开全文

前段时间，我们在这篇文章中谈到了多进程和进程之间的通信方式，主要谈到了本地进程之间使用队列（Queue）进程通信，如果我们要通信的进程不在同一台主机上，我们就无法使用队列进行通信了，这时就需要使用 Socket（套接字）。
Socket 是应用层和传输层之间的一层抽象协议，可以用来进行进程间通信，一般有 UDP 和 TCP 两种通信方式，前者速度稍快，稳定性不好，无法丢包重传。后者速度稍慢一点，但稳定性很好，可以丢包重传。
本文首先介绍使用 Socket 进行 UDP 通信。

UDP 通信流程

使用 Socket 进行 UDP 通信的流程如下：

创建一个 socket 对象
准备好目标主机 IP 和目标端口
绑定本机的端口（不必须）
发送/接收数据
关闭套接字

下面依次进行讲解。

创建套接字对象

要进行 Socket 通信，我们需要使用 socket 模块，首先需要创建一个 Socket 对象。下面是两种创建方式：

# 使用 UDP 进行通信
udpSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 使用 TCP 进行通信
tcpSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

目标主机的 IP 和端口

如果我们需要向别的主机发送数据，我们需要改主机的 IP 地址和相应的端口号。在使用 Socket 进行通信时，需要将两个信息写在一元组中，元组的第一项为目标主机 IP 地址，第二项为接受数据的端口号：

targetAddr = ("192.168.0.1", 8080)

其中，IP 地址使用字符串类型，端口号使用数字类型。

绑定本机的端口

如果不绑定端口，每次使用 Socket 时都会由操作系统动态分配一个端口，我们也可以绑定为某个固定的端口。这样做的好处是：如果我们想要接受其他主机的信息，其他主机可以直接向这个端口发送数据，如果使用动态端口的话，发送方并不知道目标端口是什么，因此无法向接收方发送数据。
绑定端口需要使用 Socket 对象的 bind 方法：

selfBind = ( [IP], PORT )
socketObj.bind( selfBind )

bind 方法接受一个元组作为参数，元组的第一项为绑定的 IP 地址，第二项为绑定的端口号。我们可以把第一项指定为本机上的任意一个 IP 地址，也可以设置为一个空字符串 ""，表示本机上任意合法的 IP 地址。

发送/接受数据

使用 UDP 套接字协议时，发送数据使用 Socket 对象的 sendto 方法，接受数据使用 Socket 对象的 recvfrom 方法。这两个方法的使用方式如下：

# 发送数据
socketObj.sendto( data, targetAddr )

# 接受数据
socketObj.recvfrom( maxSize )

sendto 方法接受两个参数：发送的数据和目标主机的 IP 和端口元组，在 Python3 中，发送的数据应该转为 byte 类型发送，Python2 中可以直接发送字符串。
recvfrom 接受一个参数：本次接受的最大数据尺寸。该方法是阻塞的，只有在接收到数据后才能进行后续的操作。

关闭套接字

就像使用文件那样，在使用完套接字后，需要关闭它，调用 close 方法即可。

socketObj.close()

单工通信的例子

上面我们介绍了 Socket 的使用方式，下面我们来做一个单工通信的例子（一方负责发送信息，一方负责接收信息）。
我们这里来创建两个文件：用以发送信息的 send.py 和用以接收信息的 recv.py。该实例在虚拟机中模拟（注意将虚拟机设置为桥接模式）。
创建 send.py：

# 导包
from socket import *

# 创建 socket 对象
udpSocket = socket(AF_INET, SOCK_DGRAM)
# 目标主机的 IP 和端口号
targetAddr = ("192.168.2.142",8080)
# 本地主机绑定端口
udpSocket.bind(("",3000))

# 主函数
def main():
    while True:
        # 接受发送的信息
        msg = input("Enter message:")
        # 发送信息 使用 utf-8 编码
        udpSocket.sendto(msg.encode("utf-8"),targetAddr)

if __name__ == '__main__':
    main()

创建 recv.py：

# 导包
from socket import *

# 创建 socket 对象
udpSocket = socket(AF_INET, SOCK_DGRAM)

# 本地主机绑定端口
udpSocket.bind(("",8080))

# 主函数
def main():
    while True:
        # 接收信息
        msg,addrInfo = udpSocket.recvfrom(1024)
        # 收到信息后使用 utf-8 解码
        print("收到来自 %s 的信息：%s"%(addrInfo[0],msg.decode("utf-8")))

if __name__ == '__main__':
    main()

运行结果如下：

socket单工通信.gif

双工通信例子

上面实现了一个单工通信的例子：一方负责发，一方负责接收。下面我们继续实现一个双工通信的例子，使双方都能够收发消息。
由于接收和发送消息时是使用 while 循环不断轮询的，因此要实现同时发送和接受，我们需要进行多任务处理。
新建一个 msg.py：

from threading import Thread
from socket import *

# 发送数据
class SendMsg(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.__selfPort = 3000
        self.__targetPort = 3001
        self.__socket = socket(AF_INET, SOCK_DGRAM)
        self.getInfo()

    # 获取目标主机的 IP
    def getInfo(self):
        # 获取目标主机的 IP
        self.__targetIp = input("请输入目标主机IP地址：")
        # 绑定本机端口
        self.__socket.bind(("",self.__selfPort))
        self.__targetAddr = (self.__targetIp, self.__targetPort)

    # 发送数据
    def run(self):
        while True:
            msg = input("\rEnter Message:")
            self.__socket.sendto(msg.encode("utf-8"),self.__targetAddr)

# 接受数据
class RecvMsg(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.__selfPort = 3001
        self.__socket = socket(AF_INET, SOCK_DGRAM)
        self.__socket.bind(("",self.__selfPort))

    # 发送数据
    def run(self):
        while True:
            msg,addrInfo  = self.__socket.recvfrom(1024)
            print("\r%s：%s"%(addrInfo[0],msg.decode("utf-8")))
            print("\rEnter Message:")

if __name__ == '__main__':
    send = SendMsg()
    recv = RecvMsg()
    send.start()
    recv.start()

这里我们使用 3000 端口发送数据，3001 端口接收数据，运行程序时只需填写目标主机的 IP 地址，就可以进行通信。
运行效果：

socket双工通信.gif

广播

我们还可以进行局域网内的广播，只需对 Socket 加上一条设置：

socketObj.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)

同时，发送广播需要一个广播地址，以及目标主机接受广播的端口：

broadAddr = ( "192.168.0.255", 8080 )

上面的设置只能给 0 网段的主机发送广播，要想给局域网中所有的主机发送广播，可以这样设置：

broadAddr = ( "<broadcast>", 8080 )

下面我们新建一个 send.py 用来发送广播：

from threading import Thread
from socket import *
from time import sleep

# 发送数据
class SendMsg(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.__dest = ("<broadcast>",3001)
        self.__socket = socket(AF_INET, SOCK_DGRAM)
        self.__socket.setsockopt(SOL_SOCKET,SO_BROADCAST,1)

    def sendInfo(self):
        self.__socket.sendto("hello~".encode("utf-8"),self.__dest)

    # 发送数据
    def run(self):
        while True:
            self.sendInfo()
            sleep(1)

if __name__ == '__main__':
    send = SendMsg()
    send.start()

新建一个 recv.py 用来接收广播：

from threading import Thread
from socket import *

# 接受数据
class RecvMsg(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.__selfPort = 3001
        self.__socket = socket(AF_INET, SOCK_DGRAM)
        self.__socket.bind(("",self.__selfPort))

    # 发送数据
    def run(self):
        while True:
            msg,addrInfo  = self.__socket.recvfrom(1024)
            print("\r%s：%s"%(addrInfo[0],msg.decode("utf-8")))
            
if __name__ == '__main__':
    recv = RecvMsg()
    recv.start()

运行效果如图：