Travailler avec AddrPort dans net/netip : Guide complet

Poursuivant notre exploration du package net/netip, nous nous concentrons désormais sur AddrPort, une structure combinant élégamment adresses IP et numéros de port. Ce couplage est fondamental dans la programmation réseau, crucial pour les serveurs Web, les connexions aux bases de données et pratiquement tous les services réseau.

Pourquoi utiliser AddrPort ?

Avant net/netip, la gestion des combinaisons IP:port impliquait souvent une manipulation de chaînes, ce qui entraînait des complexités d'analyse et des erreurs potentielles. AddrPort fournit une alternative simplifiée et sécurisée.

Démarrez avec AddrPort

Commençons par les bases :

<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>

Points clés concernant le numéro de port :

• Doit être compris entre 0 et 65535.
• Stocké en tant que uint16.
• Les zéros non significatifs sont autorisés lors de l'analyse ("8080" et "08080" sont équivalents).

Exploration des méthodes AddrPort

Examinons les méthodes disponibles pour AddrPort et leurs applications.

Accès aux composants d'adresse et de port

<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>

Gestion des adresses IPv4 et IPv6

AddrPort prend en charge de manière transparente IPv4 et IPv6 :

<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>

Applications réelles d'AddrPort

Explorons des scénarios pratiques dans lesquels AddrPort excelle.

1. Un simple serveur TCP

<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. Un registre de services

Cet exemple illustre un registre de services gérant les services et leurs points de terminaison :

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

3. Configuration de l'équilibreur de charge

Voici comment AddrPort peut être utilisé dans une configuration d'équilibreur de charge :

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

Modèles courants et meilleures pratiques

1. Validation des entrées : Validez toujours les entrées fournies par l'utilisateur :

<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. Gestion de la valeur zéro : La valeur zéro de AddrPort n'est pas valide :

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

3. Représentation sous forme de chaîne : Lors du stockage de AddrPort sous forme de chaînes (par exemple, dans des fichiers de configuration) :

<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>

Intégration avec la bibliothèque standard

AddrPort s'intègre parfaitement à la bibliothèque 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>

Considérations relatives aux performances

1. Préférez AddrPortFrom : Lorsque vous disposez déjà d'un Addr valide, utilisez AddrPortFrom au lieu de l'analyse de chaîne pour une efficacité améliorée :

<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. Minimiser les conversions de chaînes : Conservez les adresses au format AddrPort autant que possible, en les convertissant en chaînes uniquement lorsque cela est nécessaire.

Quelle est la prochaine étape ?

Notre prochain article couvrira le type Prefix, en se concentrant sur la notation CIDR et les opérations de sous-réseau, complétant ainsi notre exploration des types net/netip principaux. D'ici là, exploitez la puissance et l'efficacité de AddrPort dans vos applications réseau !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!