Bekerja dengan AddrPort dalam net/netip: Panduan Lengkap

Meneruskan penerokaan pakej net/netip, kami kini menumpukan pada AddrPort, struktur yang menggabungkan alamat IP dan nombor port dengan elegan. Gandingan ini adalah asas dalam pengaturcaraan rangkaian, penting untuk pelayan web, sambungan pangkalan data dan hampir mana-mana perkhidmatan rangkaian.

Mengapa Gunakan AddrPort?

Sebelum net/netip, mengurus gabungan IP:port selalunya melibatkan manipulasi rentetan, yang membawa kepada kerumitan penghuraian dan kemungkinan ralat. AddrPort menyediakan alternatif yang diperkemas, selamat jenis.

Bermula dengan AddrPort

Mari kita mulakan dengan asas:

<code class="language-go">package main

import (
    "fmt"
    "net/netip"
)

func main() {
    // Create from a string
    ap1, err := netip.ParseAddrPort("192.168.1.1:8080")
    if err != nil {
        panic(err)
    }

    // Create from Addr and port
    addr := netip.MustParseAddr("192.168.1.1")
    ap2 := netip.AddrPortFrom(addr, 8080)

    fmt.Printf("From string: %v\nFrom components: %v\n", ap1, ap2)
}</code>

Perkara penting mengenai nombor port:

• Mestilah dalam julat 0-65535.
• Disimpan sebagai uint16.
• Sifar pendahuluan dibenarkan semasa menghurai ("8080" dan "08080" adalah bersamaan).

Meneroka Kaedah AddrPort

Mari kita periksa kaedah yang tersedia untuk AddrPort dan aplikasinya.

Mengakses Alamat dan Komponen Pelabuhan

<code class="language-go">func examineAddrPort(ap netip.AddrPort) {
    // Retrieve the address component
    addr := ap.Addr()
    fmt.Printf("Address: %v\n", addr)

    // Retrieve the port number
    port := ap.Port()
    fmt.Printf("Port: %d\n", port)

    // Obtain the string representation ("<addr>:<port>")
    str := ap.String()
    fmt.Printf("String representation: %s\n", str)
}</code>

Mengendalikan Alamat IPv4 dan IPv6

AddrPort menyokong kedua-dua IPv4 dan IPv6 dengan lancar:

<code class="language-go">func handleBothIPVersions() {
    // IPv4 with port
    ap4 := netip.MustParseAddrPort("192.168.1.1:80")

    // IPv6 with port
    ap6 := netip.MustParseAddrPort("[2001:db8::1]:80")

    // Note: Brackets are required for IPv6 addresses.  "2001:db8::1:80" would fail.

    // IPv6 with zone and port
    apZone := netip.MustParseAddrPort("[fe80::1%eth0]:80")

    fmt.Printf("IPv4: %v\n", ap4)
    fmt.Printf("IPv6: %v\n", ap6)
    fmt.Printf("IPv6 with zone: %v\n", apZone)
}</code>

Aplikasi Dunia Sebenar AddrPort

Mari kita terokai senario praktikal di mana AddrPort cemerlang.

1. Pelayan TCP yang Mudah

<code class="language-go">func runServer(ap netip.AddrPort) error {
    listener, err := net.Listen("tcp", ap.String())
    if err != nil {
        return fmt.Errorf("failed to start server: %w", err)
    }
    defer listener.Close()

    fmt.Printf("Server listening on %v\n", ap)

    for {
        conn, err := listener.Accept()
        if err != nil {
            return fmt.Errorf("accept failed: %w", err)
        }

        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()

    // Handle the connection...
}</code>

2. Pendaftaran Perkhidmatan

Contoh ini menunjukkan pendaftaran perkhidmatan mengurus perkhidmatan dan titik akhirnya:

<code class="language-go">// ... (ServiceRegistry struct and methods as in the original example) ...</code>

3. Konfigurasi Pengimbang Beban

Begini caranya AddrPort boleh digunakan dalam konfigurasi pengimbang beban:

<code class="language-go">// ... (LoadBalancer struct and methods as in the original example) ...</code>

Corak Biasa dan Amalan Terbaik

1. Pengesahan Input: Sentiasa sahkan input yang diberikan pengguna:

<code class="language-go">func validateEndpoint(input string) error {
    _, err := netip.ParseAddrPort(input)
    if err != nil {
        return fmt.Errorf("invalid endpoint %q: %w", input, err)
    }
    return nil
}</code>

2. Pengendalian Nilai Sifar: Nilai sifar AddrPort adalah tidak sah:

<code class="language-go">func isValidEndpoint(ap netip.AddrPort) bool {
    return ap.IsValid()
}</code>

3. Perwakilan Rentetan: Apabila menyimpan AddrPort sebagai rentetan (cth., dalam fail konfigurasi):

<code class="language-go">func saveConfig(endpoints []netip.AddrPort) map[string]string {
    config := make(map[string]string)
    for i, ep := range endpoints {
        key := fmt.Sprintf("endpoint_%d", i)
        config[key] = ep.String()
    }
    return config
}</code>

Integrasi dengan Perpustakaan Standard

AddrPort disepadukan dengan lancar dengan perpustakaan standard:

<code class="language-go">func dialService(endpoint netip.AddrPort) (net.Conn, error) {
    return net.Dial("tcp", endpoint.String())
}

func listenAndServe(endpoint netip.AddrPort, handler http.Handler) error {
    return http.ListenAndServe(endpoint.String(), handler)
}</code>

Pertimbangan Prestasi

1. Lebih suka AddrPortFrom: Apabila anda sudah mempunyai Addr yang sah, gunakan AddrPortFrom dan bukannya penghuraian rentetan untuk kecekapan yang lebih baik:

<code class="language-go">addr := netip.MustParseAddr("192.168.1.1")
ap := netip.AddrPortFrom(addr, 8080) // More efficient than parsing "192.168.1.1:8080"</code>

2. Minimumkan Penukaran Rentetan: Simpan alamat dalam format AddrPort sebanyak mungkin, tukar kepada rentetan hanya apabila perlu.

Apa Seterusnya?

Artikel seterusnya kami akan merangkumi jenis Prefix, memfokuskan pada tatatanda CIDR dan operasi subnet, melengkapkan penerokaan jenis net/netip teras kami. Sehingga itu, manfaatkan kuasa dan kecekapan AddrPort dalam aplikasi rangkaian anda!

Atas ialah kandungan terperinci Bekerja dengan AddrPort dalam net/netip: Panduan Lengkap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!