Bagaimana untuk memprogramkan dengan TCP dalam Go?

Bahasa Go ialah bahasa pengaturcaraan berkuasa yang menyediakan banyak perpustakaan pengaturcaraan rangkaian, termasuk soket TCP/IP. Artikel ini terutamanya memperkenalkan cara menggunakan bahasa Go untuk pengaturcaraan TCP.

1. TCP/IP

TCP/IP ialah suite protokol, yang merupakan asas komunikasi rangkaian dan protokol teras Internet rangkaian. Ia termasuk dua protokol, TCP dan IP TCP menyediakan kebolehpercayaan penghantaran datagram, dan IP bertanggungjawab untuk penghantaran datagram.

2. Pengaturcaraan TCP dalam Go

Pakej bersih dalam bahasa Go menyediakan API yang berkaitan dengan pengaturcaraan TCP, terutamanya termasuk fungsi berikut:

1. net .DialTCP( ): Buat sambungan TCP;
2. net.ListenTCP(): Dengar port TCP;
3. net.TCPConn(): Mewakili sambungan TCP.

Di bawah ini kami akan memperkenalkan cara menggunakan fungsi ini untuk pengaturcaraan TCP.

1. Mewujudkan sambungan TCP

Pelanggan boleh menggunakan fungsi net.DialTCP() untuk mewujudkan sambungan TCP ke pelayan. Berikut ialah kod sampel:

package main

import (
    "fmt"
    "net"
)

func main() {
    conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
        IP:   net.IPv4(127, 0, 0, 1),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    fmt.Println("Connected!")
}

Dalam kod di atas, parameter pertama fungsi DialTCP() ialah rentetan "tcp" yang mewakili jenis protokol rangkaian, dan parameter kedua ialah struktur alamat, menggunakan ke destinasi sambungan yang ditentukan. Di sini kami menentukan sambungan ke port 9999 pada alamat IP tempatan 127.0.0.1. Jika sambungan berjaya, "Disambungkan!"

2. Mendengarkan port TCP

Pelayan boleh menggunakan fungsi net.ListenTCP() untuk mendengar port TCP tertentu. Berikut ialah kod sampel:

package main

import (
    "fmt"
    "net"
)

func main() {
    tcpListener, err := net.ListenTCP("tcp", &net.TCPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer tcpListener.Close()

    fmt.Println("Listening on port", 9999)
    for {
        conn, err := tcpListener.AcceptTCP()
        if err != nil {
            fmt.Println(err)
            continue
        }

        fmt.Println("New client connected.")
        go handleClient(conn)
    }
}

func handleClient(conn *net.TCPConn) {
    defer conn.Close()
    // TODO: 处理客户端请求
}

Dalam kod di atas, parameter pertama fungsi ListenTCP() ialah rentetan "tcp" yang mewakili jenis protokol rangkaian dan parameter kedua ialah struktur alamat, menggunakan Untuk menentukan alamat IP mendengar dan nombor port. Di sini kami menentukan port 9999 untuk mendengar pada semua alamat IP. Jika pendengaran berjaya, "Mendengar pada port 9999" akan dikeluarkan.

Kemudian, kami memanggil fungsi AcceptTCP() dalam gelung tak terhingga untuk menunggu klien menyambung. Apabila pelanggan disambungkan, goroutine baharu akan dibuat untuk mengendalikan permintaan pelanggan, dan "Pelanggan baharu disambungkan akan dikeluarkan ke konsol.

3. Pemprosesan sambungan TCP

Kod untuk memproses sambungan TCP selalunya lebih kompleks. Secara umumnya, kita perlu menggunakan fungsi bufio.NewReader() untuk membaca data permintaan pelanggan, dan kemudian menggunakan fungsi bufio.NewWriter() untuk menulis data respons.

Berikut ialah contoh kod untuk mengendalikan sambungan TCP:

func handleClient(conn *net.TCPConn) {
    defer conn.Close()

    // 读取客户端请求
    reader := bufio.NewReader(conn)
    req, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received request:", req)

    // 发送响应数据
    writer := bufio.NewWriter(conn)
    resp := "Hello, client!
"
    _, err = writer.WriteString(resp)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()
}

Dalam kod di atas, kami mula-mula mencipta objek bufio.NewReader() untuk membaca permintaan pelanggan. Selepas membaca data, kami mencipta objek bufio.NewWriter() untuk menulis data respons. Ambil perhatian bahawa menggunakan fungsi bufio.NewWriter() untuk mencipta penulis boleh cache data output dan meningkatkan prestasi.

Akhir sekali, kami menggunakan fungsi WriteString() untuk menulis data tindak balas ke dalam penulis, dan memanggil fungsi Flush() untuk menghantar data penimbal keluar.

3. Contoh lengkap

Akhir sekali, kami menunjukkan contoh pengaturcaraan TCP yang lengkap, termasuk klien dan pelayan:

Kod pelayan:

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    tcpListener, err := net.ListenTCP("tcp", &net.TCPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer tcpListener.Close()

    fmt.Println("Listening on port", 9999)
    for {
        conn, err := tcpListener.AcceptTCP()
        if err != nil {
            fmt.Println(err)
            continue
        }

        fmt.Println("New client connected.")
        go handleClient(conn)
    }
}

func handleClient(conn *net.TCPConn) {
    defer conn.Close()

    // 读取客户端请求
    reader := bufio.NewReader(conn)
    req, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received request:", req)

    // 发送响应数据
    writer := bufio.NewWriter(conn)
    resp := "Hello, client!
"
    _, err = writer.WriteString(resp)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()
}

Kod pelanggan:

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
        IP:   net.IPv4(127, 0, 0, 1),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    // 发送请求数据
    writer := bufio.NewWriter(conn)
    req := "Hello, server!
"
    _, err = writer.WriteString(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()

    // 接收响应数据
    reader := bufio.NewReader(conn)
    resp, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received response:", resp)
}

Dalam kod di atas, pelayan mula-mula mendengar port 9999, dan kemudian menunggu klien menyambung. Apabila klien menyambung, pelayan membaca permintaan klien dan kemudian menghantar data tindak balas.

Pelanggan mula-mula mewujudkan sambungan TCP ke pelayan, dan kemudian menghantar data permintaan ke pelayan. Selepas menghantar permintaan, pelanggan menunggu untuk menerima data respons daripada pelayan.

4. Ringkasan

Artikel ini memperkenalkan cara menggunakan bahasa Go untuk pengaturcaraan TCP. Kami mempelajari asas protokol TCP/IP, dan kemudian memperkenalkan kaedah melaksanakan pengaturcaraan TCP dalam bahasa Go menggunakan API yang disediakan oleh pakej bersih. Pada masa yang sama, artikel ini memberikan contoh yang lengkap, saya harap ia dapat membantu pembaca.

Atas ialah kandungan terperinci Bagaimana untuk memprogramkan dengan TCP dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!