Golang net库TCP/UDP网络编程基础

P粉602998670

发布时间：2025-09-17 09:41:01

403人浏览过

来源于php中文网

原创

Go的net库提供TCP/UDP网络编程核心功能，通过net.Listen、net.Dial、net.Conn和net.PacketConn实现；其优势在于goroutine并发模型、简洁API、强制错误处理和高性能；实践中需注意资源管理、超时设置、错误处理、并发安全及TLS加密，避免常见陷阱。

golang net库tcp/udp网络编程基础

Go语言的

net

库是其进行网络编程的核心，它提供了一套强大且直观的API，用于构建基于TCP（传输控制协议）和UDP（用户数据报协议）的应用程序。简单来说，如果你想用Go来让你的程序在网络上“说话”，无论是可靠地传输数据还是快速地发送消息，

net

库就是你的起点。它抽象了底层套接字编程的复杂性，让你能更专注于业务逻辑，而非繁琐的网络细节。

解决方案

使用Go的

net

库进行TCP/UDP网络编程，核心在于理解

net.Listen

、

net.Dial

、

net.Conn

和

net.PacketConn

这几个关键组件。

TCP 服务器端

构建一个TCP服务器通常涉及监听端口、接受连接和处理数据流。

立即学习“go语言免费学习笔记（深入）”；

package main

import (
    "fmt"
    "net"
    "io"
    "time"
)

func handleConnection(conn net.Conn) {
    defer conn.Close() // 确保连接关闭

    fmt.Printf("新连接来自: %s\n", conn.RemoteAddr().String())

    // 设置读取超时，防止长时间阻塞
    conn.SetReadDeadline(time.Now().Add(5 * time.Second))

    buffer := make([]byte, 1024)
    for {
        n, err := conn.Read(buffer)
        if err != nil {
            if err == io.EOF {
                fmt.Println("客户端关闭连接")
            } else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                fmt.Println("读取超时，关闭连接")
            } else {
                fmt.Printf("读取错误: %v\n", err)
            }
            break
        }

        message := string(buffer[:n])
        fmt.Printf("收到消息: %s\n", message)

        // 回复客户端
        _, err = conn.Write([]byte("服务器已收到: " + message + "\n"))
        if err != nil {
            fmt.Printf("写入错误: %v\n", err)
            break
        }
    }
}

func main() {
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Printf("监听失败: %v\n", err)
        return
    }
    defer listener.Close() // 确保监听器关闭
    fmt.Println("TCP服务器正在监听 :8080")

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Printf("接受连接失败: %v\n", err)
            continue
        }
        go handleConnection(conn) // 为每个连接启动一个goroutine
    }
}

TCP 客户端

TCP客户端则需要拨号连接到服务器，然后进行读写操作。

package main

import (
    "fmt"
    "net"
    "time"
    "io"
)

func main() {
    conn, err := net.Dial("tcp", "localhost:8080")
    if err != nil {
        fmt.Printf("连接服务器失败: %v\n", err)
        return
    }
    defer conn.Close()

    fmt.Println("已连接到服务器")

    messages := []string{"Hello Server!", "How are you?", "Goodbye!"}

    for _, msg := range messages {
        // 发送消息
        _, err := conn.Write([]byte(msg + "\n"))
        if err != nil {
            fmt.Printf("发送消息失败: %v\n", err)
            return
        }
        fmt.Printf("发送: %s\n", msg)

        // 接收服务器回复
        buffer := make([]byte, 1024)
        conn.SetReadDeadline(time.Now().Add(2 * time.Second)) // 设置读取超时
        n, err := conn.Read(buffer)
        if err != nil {
            if err == io.EOF {
                fmt.Println("服务器关闭连接")
            } else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                fmt.Println("读取服务器回复超时")
            } else {
                fmt.Printf("读取回复失败: %v\n", err)
            }
            return
        }
        fmt.Printf("收到回复: %s", string(buffer[:n]))
        time.Sleep(1 * time.Second) // 模拟间隔
    }
}

UDP 服务器端

UDP服务器使用

net.ListenPacket

监听，并通过

ReadFrom

和

WriteTo

处理数据报。

package main

import (
    "fmt"
    "net"
    "time"
)

func main() {
    conn, err := net.ListenPacket("udp", ":8081")
    if err != nil {
        fmt.Printf("监听UDP失败: %v\n", err)
        return
    }
    defer conn.Close()
    fmt.Println("UDP服务器正在监听 :8081")

    buffer := make([]byte, 1024)
    for {
        conn.SetReadDeadline(time.Now().Add(10 * time.Second)) // 设置读取超时
        n, addr, err := conn.ReadFrom(buffer)
        if err != nil {
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                fmt.Println("UDP读取超时，继续等待...")
                continue
            }
            fmt.Printf("读取UDP数据失败: %v\n", err)
            break
        }

        message := string(buffer[:n])
        fmt.Printf("收到来自 %s 的消息: %s\n", addr.String(), message)

        // 回复客户端
        response := []byte("服务器已收到UDP: " + message)
        _, err = conn.WriteTo(response, addr)
        if err != nil {
            fmt.Printf("回复UDP数据失败: %v\n", err)
        }
    }
}

UDP 客户端

UDP客户端可以直接向目标地址发送数据报，并从服务器接收回复。

package main

import (
    "fmt"
    "net"
    "time"
)

func main() {
    serverAddr, err := net.ResolveUDPAddr("udp", "localhost:8081")
    if err != nil {
        fmt.Printf("解析服务器地址失败: %v\n", err)
        return
    }

    // UDP客户端通常不需要Dial，直接用ListenPacket来收发，或者用DialUDP来建立一个“连接”
    // 这里我们用DialUDP来简化收发，它会绑定一个本地端口，并设置远程地址
    conn, err := net.DialUDP("udp", nil, serverAddr)
    if err != nil {
        fmt.Printf("连接UDP服务器失败: %v\n", err)
        return
    }
    defer conn.Close()

    fmt.Println("UDP客户端已启动")

    message := "Hello UDP Server!"
    _, err = conn.Write([]byte(message))
    if err != nil {
        fmt.Printf("发送UDP消息失败: %v\n", err)
        return
    }
    fmt.Printf("发送: %s\n", message)

    // 接收服务器回复
    buffer := make([]byte, 1024)
    conn.SetReadDeadline(time.Now().Add(2 * time.Second)) // 设置读取超时
    n, _, err := conn.ReadFromUDP(buffer) // ReadFromUDP会返回发送者的地址，这里我们不关心
    if err != nil {
        if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
            fmt.Println("读取UDP回复超时")
        } else {
            fmt.Printf("读取UDP回复失败: %v\n", err)
        }
        return
    }
    fmt.Printf("收到回复: %s\n", string(buffer[:n]))
}

Golang在网络编程方面有哪些独特优势？

在我看来，Go在网络编程方面简直是如鱼得水。它最显著的优势，也是我个人最欣赏的一点，就是其原生的并发模型——goroutine和channel。你可以非常轻松地为每一个新进来的网络连接启动一个轻量级的goroutine去处理，而不用担心传统线程模型带来的巨大开销和复杂性。这种“写同步代码，跑并发逻辑”的体验，让网络服务的开发效率提升了一大截。

阿里妈妈·创意中心

阿里妈妈营销创意中心

下载

另外，

net

库的设计也相当简洁直观。它提供的是低层级的抽象，但又不至于让你直接面对操作系统的API，恰到好处。错误处理在Go中是强制性的，这在网络编程中尤其重要，因为网络环境充满了不确定性。Go的错误处理模式促使开发者在每一步都考虑潜在的问题，这对于构建健壮的网络服务至关重要。最后，Go作为一门编译型语言，其性能表现自然不用多说，对于需要高吞吐量和低延迟的网络应用来说，这是一个巨大的加分项。

TCP和UDP在Go应用中如何选择和实践？

选择TCP还是UDP，这真的是一个老生常谈的问题，但在实际的Go应用中，它关乎到你服务的核心特性。简单来说，TCP（

net.Conn

）提供的是可靠的、面向连接的、有序的数据流传输。这意味着你发送的每一个字节，TCP都会确保它能到达目的地，并且按照发送的顺序到达。如果数据包丢失，TCP会负责重传。

TCP的典型应用场景：

HTTP/HTTPS服务：网页浏览、API调用。
文件传输：FTP、SFTP。
数据库连接：MySQL、PostgreSQL。
聊天应用：消息的完整性和顺序性至关重要。

在Go中实现TCP，你拿到的是一个

net.Conn

接口，你可以把它看作是一个双向的数据管道，像读写文件一样操作它。你需要处理连接的建立、关闭，以及持续的数据流读写。

而UDP（

net.PacketConn

）则提供的是不可靠的、无连接的、无序的数据报传输。它更像是一个“发完就忘”的模式，不保证数据能到达，也不保证顺序，但它的优势在于低延迟和高效率，因为省去了连接管理和重传的开销。

UDP的典型应用场景：

DNS查询：快速查询域名。
实时音视频流：对延迟敏感，允许少量丢包。
在线游戏：快速更新玩家位置等信息。
IoT设备数据采集：传感器数据通常量大且允许偶尔丢失。

在Go中实现UDP，你通常会使用

net.ListenPacket

或者

net.DialUDP

。你处理的是一个个独立的数据报，每次发送都需要指定目标地址，每次接收也需要知道数据来自哪里。

我的经验是，很多初学者在不确定的时候会倾向于选择TCP，因为它“可靠”。但如果你在构建一个对延迟极度敏感、且能容忍少量数据丢失的系统（比如一个游戏服务器），盲目使用TCP可能会引入不必要的开销，导致性能瓶颈。反之，如果你的应用对数据完整性有严格要求，比如金融交易系统，那么TCP的可靠性是不可替代的。选择的关键在于你对“可靠性”和“实时性”的需求权衡。