在前几篇文章中，我们探讨了 IP、端口、URL、DNS、DHCP、HTTP、TCP 与 UDP 等核心网络概念。这些协议共同构成了互联网通信的基础。然而，应用程序是如何与这些底层协议进行交互，从而发送和接收数据的呢？这就要引出本文的主角：Socket。Socket 是应用层与传输层（TCP/UDP）进行交互的 API 接口，是网络编程的基石。本文将深入探讨 Socket 的核心概念，并通过 Swift 语言，展示如何在 iOS 和 macOS 平台上进行 TCP 和 UDP 的 Socket 编程实践。为了让读者能够完整地体验通信过程，本文不仅提供了客户端代码，还提供了可在 macOS 上运行的服务器端示例。

本系列其余几篇的目录：

• 计算机网络之一 - IP 与端口
• 计算机网络之二 - URL 与 DNS
• 计算机网络之三 - DHCP 与内网穿透
• 计算机网络之四 - 虚拟网卡与 WireGuard
• 计算机网络之五 - HTTP 与 HTTPS
• 计算机网络之六 - 可靠的 TCP 与高效的 UDP

引言

在前文 [计算机网络之六 - 可靠的 TCP 与高效的 UDP] 中，我们详细剖析了 TCP 和 UDP 这两种核心传输层协议的设计哲学与工作机制。TCP 通过复杂的握手、确认、重传等机制保证了数据的可靠传输，而 UDP 则以极简的方式提供了高效的数据报投递服务。

然而，这些协议本身是内核的一部分，应用程序无法直接调用。为了让应用层能够利用这些协议进行网络通信，操作系统提供了一套标准的 API 接口，这套接口就是 Socket。Socket 抽象了网络通信的过程，使得开发者可以像操作文件一样读写网络数据，而无需关心底层协议的具体实现细节。

本文将：

1. 解释 Socket 的基本概念和工作原理。
2. 通过 Swift 代码，分别演示如何使用原生 BSD Socket API 和 Apple 的 Network 框架实现 TCP 和 UDP 通信。
3. 对比两种实现方式的优缺点，并探讨在实际开发中的选择策略。

Socket 基础概念

Socket，通常翻译为“套接字”，是应用层与传输层（TCP/UDP）进行交互的 API 接口。它提供了一组抽象，使得应用程序可以像读写文件一样进行网络数据的发送和接收，而无需关心底层网络协议的具体实现。

Socket 的核心作用

Socket 的核心作用是唯一标识一个网络连接。一个 Socket 通常由以下四个元素组成，称为“四元组”：

• 源 IP 地址: 发送方的 IP 地址。
• 源端口号: 发送方应用程序监听的端口号。
• 目标 IP 地址: 接收方的 IP 地址。
• 目标端口号: 接收方应用程序监听的端口号。

这四个元素共同构成了一个独一无二的网络连接标识符。例如，当你在浏览器中访问 https://blog.rakuyoo.top:443 时，浏览器会创建一个 Socket，其四元组可能是 (你的IP, 一个随机端口, blog.rakuyoo.top的IP, 443)。

Socket 的类型

根据传输层协议的不同，Socket 主要分为两大类：

1. Stream Socket (SOCK_STREAM):

   • 这是面向连接的 Socket，通常与 TCP 协议绑定。
   • 它提供一个有序的、可靠的、双向的字节流服务。
   • 数据通过 Stream Socket 发送，就像水流一样，没有边界，接收方收到的数据流与发送方发出的顺序完全一致，并且保证不丢失、不重复。

2. Datagram Socket (SOCK_DGRAM):

   • 这是无连接的 Socket，通常与 UDP 协议绑定。
   • 它提供一个尽力而为的数据报服务。
   • 数据被封装成一个个独立的“包裹”（数据报）进行发送。这些数据报可能会丢失、重复或乱序到达。

Socket 的工作流程

无论是 TCP 还是 UDP，使用 Socket 进行编程都遵循一个基本的流程，但具体细节会有所不同。

TCP Socket 工作流程

TCP 是面向连接的协议，其 Socket 通信流程可以概括为以下几步：

1. 创建 Socket: 应用程序调用系统调用（如 socket()）创建一个 Socket 实例。
2. 绑定地址 (服务器端): 服务器端将 Socket 与一个本地的 IP 地址和端口号绑定（bind()），以便客户端能够找到它。
3. 监听连接 (服务器端): 服务器端调用 listen() 进入监听状态，等待客户端的连接请求。
4. 发起连接 (客户端): 客户端调用 connect()，主动向服务器的指定地址发起连接请求。这会触发 TCP 的三次握手过程。
5. 接受连接 (服务器端): 服务器端调用 accept()，接受客户端的连接请求。这标志着三次握手的完成，一个新的、专用于与该客户端通信的 Socket 会在服务器端被创建。
6. 数据传输: 连接建立后，客户端和服务器端可以通过 send() 和 recv()（或 write() 和 read()）等函数进行双向的数据传输。
7. 关闭连接: 通信结束后，任意一方都可以调用 close() 来关闭 Socket，这会触发 TCP 的四次挥手过程，安全地释放连接资源。

下图展示了 TCP Socket 的典型工作流程：

sequenceDiagram
    participant C as TCP 客户端 (Swift)
    participant S as TCP 服务器 (nc)
    
    C->>S: 1. socket() 创建 Socket
    Note over C: socketFD = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)
    
    C->>S: 2. connect() 发起连接
    Note over C: connect(socketFD, serverAddr, addrLen)
    S-->>C: 3. 三次握手 (SYN, SYN-ACK, ACK)
    Note over S,C: TCP 连接建立
    
    C->>S: 4. send() 发送数据
    Note over C: send(socketFD, "Hello", ...)
    S-->>C: 5. recv() 接收数据
    Note over S: print("Hello")
    
    S->>C: 6. send() 回传响应
    Note over S: echo "Hello" back
    C-->>S: 7. recv() 接收响应
    Note over C: print("Hello")
    
    C->>S: 8. close() 关闭连接
    Note over C: close(socketFD)
    S-->>C: 9. 四次挥手 (FIN, ACK, FIN, ACK)
    Note over S,C: TCP 连接关闭

UDP Socket 工作流程

UDP 是无连接的协议，其 Socket 通信流程相对简单：

1. 创建 Socket: 调用 socket() 创建一个 Socket 实例。
2. 绑定地址 (可选): 对于接收数据的端（无论是服务器还是客户端），通常需要调用 bind() 将 Socket 与一个本地地址绑定。发送数据的端通常不需要显式绑定，操作系统会自动分配一个临时端口。
3. 数据传输: 发送方使用 sendto() 将数据报发送到指定的目标地址。接收方使用 recvfrom() 接收来自任意发送方的数据报。每一次 sendto() 和 recvfrom() 都是独立的操作。
4. 关闭 Socket: 通信结束后，调用 close() 关闭 Socket。

下图展示了 UDP Socket 的典型工作流程：

sequenceDiagram
    participant C as UDP 客户端 (Swift)
    participant S as UDP 服务器 (nc)
    
    C->>S: 1. socket() 创建 Socket
    Note over C: socketFD = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)
    
    C->>S: 2. sendto() 发送数据报
    Note over C: sendto(socketFD, "Hello", ..., serverAddr, addrLen)
    S-->>C: 3. recvfrom() 接收数据报
    Note over S: print("Hello")
    
    S->>C: 4. sendto() 回传响应 (可选)
    Note over S: echo "Hello" back
    C-->>S: 5. recvfrom() 接收响应 (可选)
    Note over C: print("Hello")
    
    C->>S: 6. close() 关闭 Socket
    Note over C: close(socketFD)

Socket 地址结构

在进行 Socket 编程时，需要指定通信双方的地址信息。操作系统提供了标准的 C 结构体来表示这些地址，例如 sockaddr_in 用于 IPv4 地址。这些结构体包含 IP 地址和端口号等信息。在 Swift 等高级语言中，通常会提供更现代化的封装来处理这些底层结构。

理解了这些基本概念后，我们就可以开始动手实践，看看如何在 Swift 中实现这些流程。

TCP Socket 实战 (Swift)

为了让读者能够完整地体验 TCP Socket 通信的全过程，本文提供了一个用 Swift 编写的简单 TCP 服务器示例。读者可以在 Mac 上创建一个 Command Line Tool 项目来运行此服务器代码。

下面是一个使用 Swift 原生 API 创建的 TCP 服务器示例：

import Foundation

// Import the necessary BSD Socket library
#if os(Linux)
import Glibc
#else
import Darwin
#endif

func createTCPServerNative(port: Int) {
    var serverSocketFD: Int32 = -1
    var serverAddress = sockaddr_in()
    
    do {
        // 1. Create a TCP socket (SOCK_STREAM)
        serverSocketFD = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)
        guard serverSocketFD != -1 else {
            throw SocketError.socketCreationFailed
        }
        print("Server Socket created successfully.")
        
        // 2. Prepare the server address structure
        bzero(&serverAddress, MemoryLayout<sockaddr_in>.size)
        serverAddress.sin_family = sa_family_t(AF_INET)
        // INADDR_ANY means the socket will bind to all available interfaces.
        serverAddress.sin_addr.s_addr = in_addr_t(INADDR_ANY).bigEndian
        serverAddress.sin_port = in_port_t(port).bigEndian
        
        // 3. Bind the socket to the address
        let bindResult = withUnsafePointer(to: &serverAddress) {
            bind(serverSocketFD, UnsafePointer<sockaddr>(OpaquePointer($0)), socklen_t(MemoryLayout<sockaddr_in>.size))
        }
        guard bindResult != -1 else {
            throw SocketError.bindFailed
        }
        print("Server Socket bound to port \(port).")
        
        // 4. Start listening for incoming connections
        // The second parameter (backlog) defines the maximum length of the queue for pending connections.
        let listenResult = listen(serverSocketFD, 5)
        guard listenResult != -1 else {
            throw SocketError.listenFailed
        }
        print("Server is listening on port \(port)...")
        
        // 5. Accept and handle incoming connections in a loop
        while true {
            print("Waiting for a client to connect...")
            var clientAddress = sockaddr_in()
            var clientAddressLength = socklen_t(MemoryLayout<sockaddr_in>.size)
            
            let clientSocketFD = withUnsafeMutablePointer(to: &clientAddress) {
                accept(serverSocketFD, UnsafeMutablePointer<sockaddr>(OpaquePointer($0)), &clientAddressLength)
            }
            
            if clientSocketFD == -1 {
                print("Accept failed, continuing to listen...")
                continue
            }
            
            // Get client information
            let clientIP = String(cString: inet_ntoa(clientAddress.sin_addr))
            let clientPort = Int(clientAddress.sin_port.byteSwapped) // Convert from network byte order
            print("Client connected: \(clientIP):\(clientPort)")
            
            // 6. Handle the client connection
            handleTCPClient(clientSocketFD: clientSocketFD)
            
            // 7. Close the client socket
            close(clientSocketFD)
            print("Client connection closed.")
        }
        
    } catch {
        print("Server Error: \(error)")
    }
    
    // 8. Close the server socket
    if serverSocketFD != -1 {
        close(serverSocketFD)
        print("Server Socket closed.")
    }
}

func handleTCPClient(clientSocketFD: Int32) {
    let bufferSize = 1024
    var buffer = [CChar](repeating: 0, count: bufferSize)
    
    // Receive data from the client
    let recvResult = recv(clientSocketFD, &buffer, bufferSize - 1, 0)
    if recvResult > 0 {
        buffer[recvResult] = 0
        if let request = String(cString: buffer, encoding: .utf8) {
            print("Received from client: \(request)")
            
            // Echo the message back to the client
            let response = "Echo: \(request)"
            _ = send(clientSocketFD, response, response.count, 0)
        }
    } else if recvResult == 0 {
        print("Client closed the connection.")
    } else {
        print("Error receiving data from client.")
    }
}

// Define custom errors for better error handling
enum SocketError: Error {
    case socketCreationFailed
    case bindFailed
    case listenFailed
    case acceptFailed
    case sendFailed
    case receiveFailed
}

// Start the server
// To run this server, create a Swift command line tool project and replace its main.swift with this code.
// Then run the project. The server will start listening on port 8080.
// createTCPServerNative(port: 8080)

服务器代码解析:

1. 创建 Socket: 与客户端类似，服务器也需要创建一个 Socket。对于 TCP 服务器，我们使用 SOCK_STREAM 和 IPPROTO_TCP。
2. 绑定地址: 服务器需要将自己的 Socket 绑定到一个特定的 IP 地址和端口号上，这样客户端才能通过这个地址找到服务器。INADDR_ANY 表示服务器将监听所有可用的网络接口。
3. 监听连接: listen() 函数使服务器进入监听状态，准备接收客户端的连接请求。backlog 参数指定了等待处理的连接请求队列的最大长度。
4. 接受连接: accept() 函数用于接受客户端的连接请求。当一个新的连接请求到达时，accept() 会返回一个新的 Socket 文件描述符，专门用于与该客户端通信。原来的服务器 Socket 继续监听其他连接请求。
5. 处理客户端: handleTCPClient() 函数负责与已连接的客户端进行数据交互。
6. 循环监听: 服务器通常在一个无限循环中运行，持续监听并处理新的连接请求。

在运行客户端示例之前，请先启动这个 TCP 服务器。服务器启动后，它会监听 8080 端口，等待客户端连接。

使用原生 BSD Socket API

使用 Swift 直接调用底层的 BSD Socket API 是一种更接近操作系统的方式。这种方式提供了最大的控制力，但也意味着需要处理更多的细节和潜在的平台差异（如 Linux 和 Darwin）。

下面是一个使用 Swift 原生 API 创建 TCP 客户端的示例。这段代码演示了创建 Socket、连接服务器、发送数据、接收响应以及关闭连接的完整流程。

import Foundation

// Import the necessary BSD Socket library
#if os(Linux)
import Glibc
#else
import Darwin
#endif

func createTCPClientNative(host: String, port: Int) {
    var socketFD: Int32 = -1
    var serverAddress = sockaddr_in()

    do {
        // 1. Create a TCP socket (SOCK_STREAM)
        // PF_INET specifies the IPv4 protocol family.
        // SOCK_STREAM indicates a stream socket (TCP).
        // IPPROTO_TCP specifies the TCP protocol.
        socketFD = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)
        guard socketFD != -1 else {
            throw SocketError.socketCreationFailed
        }
        print("Socket created successfully.")

        // 2. Prepare the server address structure
        // Clear the serverAddress struct by filling it with zeros.
        bzero(&serverAddress, MemoryLayout<sockaddr_in>.size)
        // Set the address family to IPv4.
        serverAddress.sin_family = sa_family_t(AF_INET)
        // Set the port number (convert to network byte order).
        serverAddress.sin_port = in_port_t(port).bigEndian
        // Convert the IP address string to a network address structure.
        // INADDR_ANY means any IP address on the local machine.
        // For connecting to a specific host, we use inet_pton.
        if host == "localhost" || host == "127.0.0.1" {
            serverAddress.sin_addr.s_addr = in_addr_t(INADDR_LOOPBACK).bigEndian
        } else {
            // For other hosts, convert the string IP address.
            guard inet_pton(AF_INET, host, &serverAddress.sin_addr) == 1 else {
                throw SocketError.invalidAddress
            }
        }

        // 3. Connect to the server
        // Cast sockaddr_in to the generic sockaddr pointer required by connect().
        let connectResult = withUnsafePointer(to: &serverAddress) {
            connect(socketFD, UnsafePointer<sockaddr>(OpaquePointer($0)), socklen_t(MemoryLayout<sockaddr_in>.size))
        }
        guard connectResult != -1 else {
            throw SocketError.connectionFailed
        }
        print("Connected to server at \(host):\(port)")

        // 4. Send a message to the server
        let message = "Hello from Swift TCP Client (Native)!"
        let sendResult = send(socketFD, message, message.count, 0)
        guard sendResult != -1 else {
            throw SocketError.sendFailed
        }
        print("Message sent: \(message)")

        // 5. Receive a response from the server
        // Allocate a buffer to store the incoming data.
        let bufferSize = 1024
        var buffer = [CChar](repeating: 0, count: bufferSize)
        let recvResult = recv(socketFD, &buffer, bufferSize - 1, 0) // -1 to leave space for null terminator
        guard recvResult > 0 else {
            if recvResult == 0 {
                print("Server closed the connection.")
            } else {
                throw SocketError.receiveFailed
            }
        }
        // Null-terminate the received data to safely convert to a String.
        buffer[recvResult] = 0
        if let response = String(cString: buffer, encoding: .utf8) {
            print("Received response: \(response)")
        }

    } catch {
        print("Error: \(error)")
    }

    // 6. Close the socket
    // It's crucial to close the socket to free up resources.
    if socketFD != -1 {
        close(socketFD)
        print("Socket closed.")
    }
}

// Define custom errors for better error handling
enum SocketError: Error {
    case socketCreationFailed
    case invalidAddress
    case connectionFailed
    case sendFailed
    case receiveFailed
}

// Example usage:
// To test this, first start the TCP server provided in this article.
// Then run this client code in a Swift Playground or iOS project.
// createTCPClientNative(host: "127.0.0.1", port: 8080)

代码解析:

1. 导入库: 根据操作系统导入不同的底层 Socket 库 (Darwin for macOS/iOS, Glibc for Linux)。
2. 创建 Socket: socket(domain, type, protocol) 是创建 Socket 的核心函数。PF_INET 表示 IPv4，SOCK_STREAM 表示 TCP 流式 Socket，IPPROTO_TCP 指定使用 TCP 协议。
3. 配置地址: sockaddr_in 结构体用于存储 IPv4 地址信息。我们填充了地址族 (sin_family)、端口 (sin_port，注意使用 bigEndian 转换为主机字节序) 和 IP 地址 (sin_addr)。
4. 建立连接: connect() 函数用于发起 TCP 连接，它会触发三次握手过程。
5. 数据传输: send() 和 recv() 分别用于发送和接收数据。
6. 关闭连接: close() 函数用于关闭 Socket，释放资源，并触发 TCP 的四次挥手过程。
7. 错误处理: 通过自定义 SocketError 枚举和 do-catch 块来处理可能出现的错误。

要运行此示例，请先启动 nc 服务器，然后在 Swift Playground 或 iOS 项目中调用 createTCPClientNative(host: "127.0.0.1", port: 8080)。

使用 Network 框架

Apple 的 Network 框架是为 Swift 量身打造的现代化网络库，它提供了更高层次的抽象和更好的异步支持（与 Swift Concurrency 集成），并且是跨平台的（iOS, macOS, watchOS, tvOS, catalyst）。

下面的示例展示了如何使用 Network 框架实现一个 TCP 客户端。

import Foundation
import Network

func createTCPClientWithNetworkFramework(host: String, port: Int) {
    // 1. Define the server endpoint
    // NWEndpoint.Host can be a hostname or an IP address string.
    // NWEndpoint.Port can be a well-known port or a raw port number.
    guard let serverHost = NWEndpoint.Host(host), let serverPort = NWEndpoint.Port(rawValue: port) else {
        print("Invalid host or port")
        return
    }
    let connection = NWConnection(host: serverHost, port: serverPort, using: .tcp)
    
    // 2. Set up the state update handler
    // This handler is called whenever the connection state changes.
    connection.stateUpdateHandler = { newState in
        switch newState {
        case .ready:
            print("Connection ready.")
            // Connection is established, now we can send data.
            let message = "Hello from Swift TCP Client (Network Framework)!"
            let messageData = message.data(using: .utf8)!
            connection.send(content: messageData, completion: .contentProcessed { error in
                if let error = error {
                    print("Send error: \(error)")
                } else {
                    print("Message sent: \(message)")
                }
            })
            
        case .waiting(let error):
            print("Connection waiting with error: \(error)")
        case .failed(let error):
            print("Connection failed with error: \(error)")
            // It's important to cancel the connection on failure.
            connection.cancel()
        case .cancelled:
             print("Connection cancelled.")
        case .preparing:
             print("Connection is preparing.")
        case .setup:
             print("Connection is being set up.")
        @unknown default:
            print("Unknown connection state.")
            connection.cancel()
        }
    }
    
    // 3. Set up the receive handler
    // This function tells the connection to start listening for incoming data.
    func receive() {
        connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) { data, _, isComplete, error in
            if let data = data, !data.isEmpty {
                if let response = String(data: data, encoding: .utf8) {
                    print("Received response: \(response)")
                }
            }
            
            if let error = error {
                print("Receive error: \(error)")
                connection.cancel()
            } else if isComplete {
                // isComplete being true usually means the connection is closing.
                print("Connection complete, closing.")
                connection.cancel()
            } else {
                // Continue to receive data.
                receive()
            }
        }
    }
    
    // 4. Start the connection
    connection.start(queue: .main)
    
    // 5. Set up a timeout or a way to stop the connection after some time/activity
    // For simplicity, we'll just schedule a cancel after a few seconds.
    DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
        if connection.state == .ready {
            print("Test duration over, closing connection.")
            connection.cancel()
        }
    }
}

// Example usage:
// To test this, first start the TCP server provided in this article.
// Then run this client code in a Swift Playground or iOS project.
// createTCPClientWithNetworkFramework(host: "127.0.0.1", port: 8080)

代码解析:

1. 创建连接: NWConnection 是 Network 框架中表示连接的核心类。我们通过指定主机、端口和协议 (.tcp) 来创建它。
2. 状态管理: 通过 stateUpdateHandler 监听连接状态的变化（准备就绪、等待、失败等）。这是处理连接生命周期的关键。
3. 发送数据: 使用 connection.send(content:completion:) 方法发送数据。.contentProcessed 完成回调可以处理发送成功或失败的情况。
4. 接收数据: 通过递归调用 connection.receive(...) 方法来持续监听来自服务器的数据。
5. 启动与关闭: connection.start(queue:) 启动连接过程。connection.cancel() 用于取消连接，释放资源。

Network 框架的优势在于其声明式的 API 和强大的异步支持，使得网络代码更加清晰和易于管理。它也内置了对 TLS/SSL 的支持，便于实现安全连接。

UDP Socket 实战 (Swift)

为了让读者能够完整地体验 UDP Socket 通信的全过程，本文提供了一个用 Swift 编写的简单 UDP 服务器示例。读者可以在 Mac 上创建一个 Command Line Tool 项目来运行此服务器代码。

下面是一个使用 Swift 原生 API 创建的 UDP 服务器示例：

import Foundation

// Import the necessary BSD Socket library
#if os(Linux)
import Glibc
#else
import Darwin
#endif

func createUDPServerNative(port: Int) {
    var serverSocketFD: Int32 = -1
    var serverAddress = sockaddr_in()
    
    do {
        // 1. Create a UDP socket (SOCK_DGRAM)
        serverSocketFD = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)
        guard serverSocketFD != -1 else {
            throw SocketError.socketCreationFailed
        }
        print("UDP Server Socket created successfully.")
        
        // 2. Prepare the server address structure
        bzero(&serverAddress, MemoryLayout<sockaddr_in>.size)
        serverAddress.sin_family = sa_family_t(AF_INET)
        // INADDR_ANY means the socket will bind to all available interfaces.
        serverAddress.sin_addr.s_addr = in_addr_t(INADDR_ANY).bigEndian
        serverAddress.sin_port = in_port_t(port).bigEndian
        
        // 3. Bind the socket to the address
        let bindResult = withUnsafePointer(to: &serverAddress) {
            bind(serverSocketFD, UnsafePointer<sockaddr>(OpaquePointer($0)), socklen_t(MemoryLayout<sockaddr_in>.size))
        }
        guard bindResult != -1 else {
            throw SocketError.bindFailed
        }
        print("UDP Server Socket bound to port \(port).")
        
        print("UDP Server is listening on port \(port)...")
        
        // 4. Receive and handle incoming datagrams in a loop
        while true {
            print("Waiting for a UDP datagram...")
            let bufferSize = 1024
            var buffer = [CChar](repeating: 0, count: bufferSize)
            var clientAddress = sockaddr_in()
            var clientAddressLength = socklen_t(MemoryLayout<sockaddr_in>.size)
            
            let recvfromResult = withUnsafeMutablePointer(to: &clientAddress) {
                recvfrom(serverSocketFD, &buffer, bufferSize - 1, 0, UnsafeMutablePointer<sockaddr>(OpaquePointer($0)), &clientAddressLength)
            }
            
            if recvfromResult > 0 {
                // Get client information
                let clientIP = String(cString: inet_ntoa(clientAddress.sin_addr))
                let clientPort = Int(clientAddress.sin_port.byteSwapped) // Convert from network byte order
                print("Datagram received from: \(clientIP):\(clientPort)")
                
                // Null-terminate the received data
                buffer[recvfromResult] = 0
                if let request = String(cString: buffer, encoding: .utf8) {
                    print("Received from client: \(request)")
                    
                    // Echo the message back to the client
                    let response = "UDP Echo: \(request)"
                    let sendtoResult = withUnsafePointer(to: &clientAddress) {
                        sendto(serverSocketFD, response, response.count, 0, UnsafePointer<sockaddr>(OpaquePointer($0)), clientAddressLength)
                    }
                    if sendtoResult == -1 {
                        print("Error sending response to client.")
                    }
                }
            } else {
                print("Error receiving datagram.")
            }
        }
        
    } catch {
        print("UDP Server Error: \(error)")
    }
    
    // 5. Close the server socket
    if serverSocketFD != -1 {
        close(serverSocketFD)
        print("UDP Server Socket closed.")
    }
}

// Define custom errors for better error handling (reusing from TCP example)
// enum SocketError: Error { ... } // Already defined in the TCP example

// Start the UDP server
// To run this server, create a Swift command line tool project and replace its main.swift with this code.
// Then run the project. The server will start listening on port 8080.
// createUDPServerNative(port: 8080)

UDP 服务器代码解析:

1. 创建 Socket: 与 TCP 服务器不同，UDP 服务器创建的是数据报 Socket，使用 SOCK_DGRAM 和 IPPROTO_UDP。
2. 绑定地址: 与 TCP 服务器相同，UDP 服务器也需要绑定到一个特定的 IP 地址和端口号。
3. 接收数据报: UDP 是无连接的，服务器不需要 listen() 和 accept()。它直接使用 recvfrom() 函数来接收来自任意客户端的数据报。recvfrom() 不仅能接收到数据，还能获取发送方的地址信息。
4. 发送响应: 服务器使用 sendto() 函数将响应数据报发送回客户端，需要提供客户端的地址信息。
5. 循环监听: UDP 服务器同样在一个无限循环中运行，持续接收和处理数据报。

在运行 UDP 客户端示例之前，请先启动这个 UDP 服务器。服务器启动后，它会监听 8080 端口，等待 UDP 数据报。

使用原生 BSD Socket API

下面是一个使用 Swift 原生 API 创建 UDP 客户端的示例。

import Foundation

// Import the necessary BSD Socket library
#if os(Linux)
import Glibc
#else
import Darwin
#endif

func createUDPClientNative(host: String, port: Int) {
    var socketFD: Int32 = -1
    var serverAddress = sockaddr_in()

    do {
        // 1. Create a UDP socket (SOCK_DGRAM)
        // PF_INET specifies the IPv4 protocol family.
        // SOCK_DGRAM indicates a datagram socket (UDP).
        // IPPROTO_UDP specifies the UDP protocol.
        socketFD = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)
        guard socketFD != -1 else {
            throw SocketError.socketCreationFailed
        }
        print("UDP Socket created successfully.")

        // 2. Prepare the server address structure
        // Clear the serverAddress struct by filling it with zeros.
        bzero(&serverAddress, MemoryLayout<sockaddr_in>.size)
        // Set the address family to IPv4.
        serverAddress.sin_family = sa_family_t(AF_INET)
        // Set the port number (convert to network byte order).
        serverAddress.sin_port = in_port_t(port).bigEndian
        // Convert the IP address string to a network address structure.
        if host == "localhost" || host == "127.0.0.1" {
            serverAddress.sin_addr.s_addr = in_addr_t(INADDR_LOOPBACK).bigEndian
        } else {
            // For other hosts, convert the string IP address.
            guard inet_pton(AF_INET, host, &serverAddress.sin_addr) == 1 else {
                throw SocketError.invalidAddress
            }
        }

        // 3. Send a message to the server
        let message = "Hello from Swift UDP Client (Native)!"
        let sendResult = withUnsafePointer(to: &serverAddress) {
            sendto(socketFD, message, message.count, 0, UnsafePointer<sockaddr>(OpaquePointer($0)), socklen_t(MemoryLayout<sockaddr_in>.size))
        }
        guard sendResult != -1 else {
            throw SocketError.sendFailed
        }
        print("UDP Message sent: \(message)")

        // 4. Receive a response from the server (Optional, as UDP is connectionless)
        // Allocate a buffer to store the incoming data.
        let bufferSize = 1024
        var buffer = [CChar](repeating: 0, count: bufferSize)
        // For recvfrom, we also need to provide the address of the sender.
        var senderAddress = sockaddr_in()
        var senderAddressLength = socklen_t(MemoryLayout<sockaddr_in>.size)
        
        let recvfromResult = withUnsafeMutablePointer(to: &senderAddress) {
            recvfrom(socketFD, &buffer, bufferSize - 1, 0, UnsafeMutablePointer<sockaddr>(OpaquePointer($0)), &senderAddressLength)
        }
        
        guard recvfromResult > 0 else {
            if recvfromResult == 0 {
                print("No data received or server closed (though uncommon for UDP).")
            } else {
                // Receiving might fail if nothing is sent back, which is normal for simple tests.
                // We can treat this as a non-fatal outcome for a basic example.
                print("No response received (expected for simple 'nc' tests).")
                // throw SocketError.receiveFailed
            }
        }
        
        if recvfromResult > 0 {
            // Null-terminate the received data to safely convert to a String.
            buffer[recvfromResult] = 0
            if let response = String(cString: buffer, encoding: .utf8) {
                print("UDP Received response: \(response)")
            }
        }

    } catch {
        print("UDP Error: \(error)")
    }

    // 5. Close the socket
    // It's crucial to close the socket to free up resources.
    if socketFD != -1 {
        close(socketFD)
        print("UDP Socket closed.")
    }
}

// Define custom errors for better error handling (reusing from TCP example)
// enum SocketError: Error { ... } // Already defined in the TCP example

// Example usage:
// To test this, first start the UDP server provided in this article.
// Then run this client code in a Swift Playground or iOS project.
// createUDPClientNative(host: "127.0.0.1", port: 8080)

代码解析:

1. 创建 Socket: 与 TCP 不同，这里使用 SOCK_DGRAM 和 IPPROTO_UDP 来创建 UDP Socket。
2. 配置地址: 地址配置与 TCP 相同。
3. 发送数据: 使用 sendto() 函数发送数据报到指定的目标地址。与 TCP 的 send() 不同，sendto() 需要显式提供目标地址。
4. 接收数据: 使用 recvfrom() 函数接收数据报。它可以获取发送方的地址信息。
5. 关闭连接: 同样使用 close() 关闭 Socket。

使用 Network 框架

下面的示例展示了如何使用 Network 框架实现一个 UDP 客户端。

import Foundation
import Network

func createUDPClientWithNetworkFramework(host: String, port: Int) {
    // 1. Define the server endpoint
    guard let serverHost = NWEndpoint.Host(host), let serverPort = NWEndpoint.Port(rawValue: port) else {
        print("Invalid host or port")
        return
    }
    
    // 2. Create a UDP connection using NWUDPSession
    // NWUDPSession is specifically designed for UDP communication.
    let udpSession = NWUDPSession(using: .udp, to: NWEndpoint.hostPort(host: serverHost, port: serverPort))
    
    // 3. Set up the state update handler
    udpSession.stateUpdateHandler = { newState in
        switch newState {
        case .ready:
            print("UDP Session ready.")
            // Session is ready, now we can send data.
            let message = "Hello from Swift UDP Client (Network Framework)!"
            let messageData = message.data(using: .utf8)!
            udpSession.send(content: messageData) { error in
                if let error = error {
                    print("UDP Send error: \(error)")
                } else {
                    print("UDP Message sent: \(message)")
                }
            }
            
        case .waiting(let error):
            print("UDP Session waiting with error: \(error)")
        case .failed(let error):
            print("UDP Session failed with error: \(error)")
            udpSession.cancel()
        case .cancelled:
             print("UDP Session cancelled.")
        case .preparing:
             print("UDP Session is preparing.")
        case .setup:
             print("UDP Session is being set up.")
        @unknown default:
            print("Unknown UDP session state.")
            udpSession.cancel()
        }
    }
    
    // 4. Set up the receive handler
    func receive() {
        // For UDP, we listen for incoming datagrams.
        udpSession.receive { data, endpoint, error in
            if let data = data, !data.isEmpty {
                if let response = String(data: data, encoding: .utf8) {
                    print("UDP Received response: \(response)")
                    // Optionally, print the sender's endpoint
                    print("From endpoint: \(endpoint?.debugDescription ?? "Unknown")")
                }
            }
            
            if let error = error {
                print("UDP Receive error: \(error)")
                // For UDP, not receiving data is often not an error, just no data.
                // We might not cancel here unless it's a real error.
            } else {
                // Continue to receive data.
                receive()
            }
        }
    }
    
    // 5. Start the session
    udpSession.start(queue: .main)
    
    // 6. Schedule a cancel after some time to end the test
    DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
        if udpSession.state == .ready {
            print("UDP Test duration over, closing session.")
            udpSession.cancel()
        }
    }
}

// Example usage:
// To test this, first start the UDP server provided in this article.
// Then run this client code in a Swift Playground or iOS project.
// createUDPClientWithNetworkFramework(host: "127.0.0.1", port: 8080)

代码解析:

1. 创建会话: 使用 NWUDPSession 类来创建 UDP 会话，指定协议为 .udp 并提供目标端点。
2. 状态管理: 与 TCP 连接类似，通过 stateUpdateHandler 监听会话状态。
3. 发送数据: 使用 udpSession.send(content:completion:) 方法发送数据报。
4. 接收数据: 通过 udpSession.receive(completion:) 方法监听来自服务器的数据报。
5. 启动与关闭: 使用 udpSession.start(queue:) 启动会话，使用 udpSession.cancel() 关闭会话。

对比与选择

通过上面的示例，我们可以看到使用原生 BSD Socket API 和 Network 框架实现 TCP/UDP 通信的异同。

原生 BSD Socket API

优点:

• 控制力强: 可以直接访问底层 Socket API，对网络通信的每个细节都有完全的控制权。
• 性能: 由于没有额外的抽象层，理论上可能有更优的性能表现。
• 兼容性: 代码可以在支持 BSD Socket 的各种平台上运行（需要处理平台差异）。

缺点:

• 复杂性高: 需要手动管理内存、处理 C 风格的 API、处理平台差异（如 Darwin vs Glibc）。
• 易错性: 手动管理资源（如 close Socket）容易出错，导致资源泄露。
• 异步支持: 原生 API 的异步支持相对较弱，需要开发者自行实现或使用其他库（如 GCD）。

Network 框架

优点:

• 现代化: 为 Swift 量身打造，API 设计更符合 Swift 的编程范式。
• 异步支持: 内置强大的异步支持，与 Swift Concurrency (async/await) 集成良好。
• 安全性: 内置对 TLS/SSL 的支持，易于实现安全通信。
• 跨平台: 是 Apple 平台的统一网络框架，支持 iOS, macOS, watchOS, tvOS, catalyst。
• 错误处理: 提供了更清晰的错误处理机制。

缺点:

• 平台限制: 仅限于 Apple 平台。
• 学习曲线: 对于习惯了 C 风格 API 的开发者来说，可能需要一些时间来适应其声明式的编程模型。

如何选择?

• 如果你需要在 Apple 平台上进行网络开发，并且希望获得现代化、易用且强大的异步支持，那么 Network 框架是首选。
• 如果你需要在多个平台（包括 Linux）上运行代码，或者需要对底层网络通信进行精细控制，那么原生 BSD Socket API 可能更合适。
• 对于学习目的，了解原生 API 有助于深入理解网络通信的本质，而 Network 框架则更适合快速开发高质量的应用。

无论选择哪种方式，本文提供的完整示例代码都可以帮助你在 macOS 上快速搭建测试环境，并在 iOS 模拟器或真机上运行客户端代码，从而完整地体验 Socket 编程的全过程。

总结

Socket 是网络编程的基础，它为应用程序提供了与传输层协议（TCP/UDP）交互的接口。通过本文的实践，我们不仅学习了 Socket 的核心概念，还通过 Swift 代码亲身体验了如何使用原生 BSD Socket API 和 Apple 的 Network 框架来实现 TCP 和 UDP 通信。

TCP 作为一种面向连接、可靠的协议，其 Socket 编程涉及连接的建立、维护和释放，提供了有序的数据流传输。而 UDP 作为一种无连接、尽力而为的协议，其 Socket 编程更简单直接，适用于对实时性要求高、可以容忍少量数据丢失的场景。

Network 框架作为 Apple 推出的现代化网络库，以其简洁的 API、强大的异步支持和跨平台兼容性，正在成为 Apple 平台网络开发的首选工具。

理解 Socket 编程不仅是掌握网络通信技术的关键一步，也为进一步学习 HTTP、WebSocket、实时通信等高级网络技术打下了坚实的基础。希望本文能帮助你建立起对 Socket 编程的全面认识，并激发你在网络编程领域的进一步探索。