操操操
目录

TCP、UDP协议和Socket编程

2019-04-07
4分钟阅读时长
开发技术 , 编程语言 , Golang
Golang入门：从零开始学习Golang语言

Golang 中 TCP、UDP 协议和 Socket 编程详解

在网络编程中，TCP 和 UDP 是两种最常用的协议。Golang 提供了丰富的标准库和第三方包来支持这两种协议以及 Socket 编程。本文将深入探讨 Golang 中 TCP、UDP 协议和 Socket 编程的实现方式，并提供完整的代码示例。

1. TCP 协议

TCP（Transmission Control Protocol）是面向连接的协议，它提供可靠的数据传输服务，并保证数据按顺序到达。Golang 标准库中的 net 包提供了 TCP 协议的相关支持。

1.1 TCP 客户端

下面是一个简单的 TCP 客户端示例：

package main

import (
    "fmt"
    "net"
)

func main() {
    // 连接服务器
    conn, err := net.Dial("tcp", "localhost:8000")
    if err != nil {
        fmt.Println("Error connecting:", err)
        return
    }
    defer conn.Close()

    // 发送数据
    message := "Hello, server!"
    _, err = conn.Write([]byte(message))
    if err != nil {
        fmt.Println("Error sending data:", err)
        return
    }

    // 接收数据
    buffer := make([]byte, 1024)
    n, err := conn.Read(buffer)
    if err != nil {
        fmt.Println("Error receiving data:", err)
        return
    }
    fmt.Println("Received message:", string(buffer[:n]))
}

这个客户端程序首先通过 net.Dial() 函数连接到本地的 8000 端口。然后，它将一个字符串发送到服务器，并等待服务器的响应。最后，它输出接收到的数据。

1.2 TCP 服务器

下面是一个简单的 TCP 服务器示例：

package main

import (
    "fmt"
    "net"
)

func main() {
    // 创建监听器
    listener, err := net.Listen("tcp", ":8000")
    if err != nil {
        fmt.Println("Error listening:", err)
        return
    }
    defer listener.Close()

    fmt.Println("Listening on :8000")

    for {
        // 接受连接请求
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accepting connection:", err)
            return
        }

        // 处理连接
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    // 接收数据
    buffer := make([]byte, 1024)
    n, err := conn.Read(buffer)
    if err != nil {
        fmt.Println("Error receiving data:", err)
        conn.Close()
        return
    }
    fmt.Println("Received message:", string(buffer[:n]))

    // 发送数据
    message := "Hello, client!"
    _, err = conn.Write([]byte(message))
    if err != nil {
        fmt.Println("Error sending data:", err)
        conn.Close()
        return
    }

    conn.Close()
}

这个服务器程序使用 net.Listen() 函数创建一个监听器，并在本地 8000 端口上开始监听。当有新的连接请求时，它会调用 listener.Accept() 函数来接受连接。然后，它将连接交给一个独立的 Goroutine 来处理，并继续监听其他连接请求。

在连接的处理函数 handleConnection() 中，服务器首先接收客户端发送的数据，并输出到控制台。然后，它向客户端发送一条问候消息，并关闭连接。

2. UDP 协议

UDP（User Datagram Protocol）是无连接的协议，它提供不可靠的数据传输服务，并没有保证数据按顺序到达。Golang 标准库中的 net 包同样支持 UDP 协议。

2.1 UDP 客户端

下面是一个简单的 UDP 客户端示例：

package main

import (
    "fmt"
    "net"
)

func main() {
    // 解析地址
    serverAddr, err := net.ResolveUDPAddr("udp", "localhost:8000")
    if err != nil {
        fmt.Println("Error resolving server address:", err)
        return
    }

    // 创建连接
    conn, err := net.DialUDP("udp", nil, serverAddr)
    if err != nil {
        fmt.Println("Error connecting:", err)
        return
    }
    defer conn.Close()

    // 发送数据
    message := "Hello, server!"
    _, err = conn.Write([]byte(message))
    if err != nil {
        fmt.Println("Error sending data:", err)
        return
    }

    // 接收数据
    buffer := make([]byte, 1024)
    n, err := conn.Read(buffer)
    if err != nil {
        fmt.Println("Error receiving data:", err)
        return
    }
    fmt.Println("Received message:", string(buffer[:n]))
}

这个客户端程序首先通过 net.ResolveUDPAddr() 函数解析服务器的地址。然后，它通过 net.DialUDP() 函数创建一个 UDP 连接。接着，它将一个字符串发送到服务器，并等待服务器的响应。最后，它输出接收到的数据。

2.2 UDP 服务器

下面是一个简单的 UDP 服务器示例：

package main

import (
    "fmt"
    "net"
)

func main() {
    // 解析地址
    serverAddr, err := net.ResolveUDPAddr("udp", ":8000")
    if err != nil {
        fmt.Println("Error resolving address:", err)
        return
    }

    // 创建连接
    conn, err := net.ListenUDP("udp", serverAddr)
    if err != nil {
        fmt.Println("Error listening:", err)
        return
    }
    defer conn.Close()

    fmt.Println("Listening on :8000")

    // 接收数据
    buffer := make([]byte, 1024)
    n, addr, err := conn.ReadFromUDP(buffer)
    if err != nil {
        fmt.Println("Error receiving data:", err)
        return
    }
    fmt.Println("Received message:", string(buffer[:n]))

    // 发送数据
    message := "Hello, client!"
    _, err = conn.WriteToUDP([]byte(message), addr)
    if err != nil {
        fmt.Println("Error sending data:", err)
        return
    }
}

这个服务器程序通过 net.ResolveUDPAddr() 函数解析本地的地址，并通过 net.ListenUDP() 函数创建一个 UDP 连接。当有数据到达时，它会调用 conn.ReadFromUDP() 函数来接收数据，并输出到控制台。

在接收到数据后，服务器向客户端发送一条问候消息，并关闭连接。

3. Socket 编程

Socket 是一种用于网络通信的 API，它是 TCP 和 UDP 协议的抽象实现。Golang 标准库中的 net 包提供了 Socket 编程的支持，包括 TCP 和 UDP 协议。

3.1 创建 Socket

下面是一个简单的 Socket 客户端示例：

package main

import (
    "fmt"
    "net"
    "syscall"
)

func main() {
    // 创建 socket
    fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, 0)
    if err != nil {
        fmt.Println("Error creating socket:", err)
        return
    }
    defer syscall.Close(fd)

    // 连接服务器
    addr := syscall.SockaddrInet4{Port: 8000}
    copy(addr.Addr[:], net.ParseIP("localhost").To4())
    err = syscall.Connect(fd, &addr)
    if err != nil {
        fmt.Println("Error connecting:", err)
        return
    }

    // 发送数据
    message := "Hello, server!"
    _, err = syscall.Write(fd, []byte(message))
    if err != nil {
        fmt.Println("Error sending data:", err)
        return
    }

    // 接收数据
    buffer := make([]byte, 1024)
    n, err := syscall.Read(fd, buffer)
    if err != nil {
        fmt.Println("Error receiving data:", err)
        return
    }
    fmt.Println("Received message:", string(buffer[:n]))
}

这个客户端程序首先通过 syscall.Socket() 函数创建一个 Socket 文件描述符。然后，它使用 syscall.Connect() 函数连接到本地的 8000 端口。接着，它将一个字符串发送到服务器，并等待服务器的响应。最后，它输出接收到的数据。

下面是一个简单的 Socket 服务器示例：

package main

import (
    "fmt"
    "net"
    "syscall"
)

func main() {
    // 创建 socket
    fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, 0)
    if err != nil {
        fmt.Println("Error creating socket:", err)
        return
    }
    defer syscall.Close(fd)

    // 绑定地址
    addr := syscall.SockaddrInet4{Port: 8000}
    copy(addr.Addr[:], net.ParseIP("localhost").To4())
    err = syscall.Bind(fd, &addr)
    if err != nil {
        fmt.Println("Error binding address:", err)
        return
    }

    // 监听连接请求
    err = syscall.Listen(fd, syscall.SOMAXCONN)
    if err != nil {
        fmt.Println("Error listening:", err)
        return
    }

    fmt.Println("Listening on :8000")

    for {
        // 接受连接请求
        connFd, _, err := syscall.Accept(fd)
        if err != nil {
            fmt.Println("Error accepting connection:", err)
            return
        }
        defer syscall.Close(connFd)

        // 处理连接
        go handleConnection(connFd)
    }
}

func handleConnection(fd int) {
    // 接收数据
    buffer := make([]byte, 1024)
    n, err := syscall.Read(fd, buffer)
    if err != nil {
        fmt.Println("Error receiving data:", err)
        return
    }
    fmt.Println("Received message:", string(buffer[:n]))

    // 发送数据
    message := "Hello, client!"
    _, err = syscall.Write(fd, []byte(message))
    if err != nil {
        fmt.Println("Error sending data:", err)
        return
    }
}

这个服务器程序通过 syscall.Socket() 函数创建一个 Socket 文件描述符，并使用 syscall.Bind() 函数绑定到本地的 8000 端口。然后，它使用 syscall.Listen() 函数开始监听连接请求。

当有新的连接请求时，服务器会调用 syscall.Accept() 函数接受连接，并将连接交给一个独立的 Goroutine 来处理。

在连接的处理函数 handleConnection() 中，服务器首先接收客户端发送的数据，并输出到控制台。然后，它向客户端发送一条问候消息，并关闭连接。

4. 结论

本文深入探讨了 Golang 中 TCP、UDP 协议和 Socket 编程的实现方式，并提供了完整的代码示例。我们学习了如何使用 Golang 标准库和系统调用来创建 TCP 和 UDP 客户端和服务器，以及如何进行 Socket 编程。这些知识对于开发网络应用程序非常重要，希望读者能够从中受益。

#Golang #Go语言 #Go语言学习 #Go语言技巧
Avatar

Aisen

 Be water,my friend.
下一页 DNS解析和HTTP代理