Fonction Golang Méthodes de traitement TCP, UDP, http et websocket

Avec le développement continu de la technologie Internet, la communication en réseau est devenue une compétence essentielle des temps modernes. Dans ce processus, la fonction (Function), en tant que méthode de programmation efficace et flexible, est devenue un outil privilégié par de plus en plus de programmeurs. Parmi ces fonctions, les méthodes de traitement basées sur les protocoles TCP, UDP, HTTP et WebSocket sont particulièrement importantes. Aujourd'hui, cet article se concentrera sur les méthodes de traitement des fonctions Golang sous ces quatre protocoles.

1. Méthode de traitement des fonctions basée sur le protocole TCP

TCP (Transmission Control Protocol) est un protocole de couche de transport fiable, orienté connexion et basé sur un flux d'octets. Dans Golang, nous pouvons créer un simple serveur TCP via le code suivant :

package main

import (
    "fmt"
    "net"
)

func main() {
    listener, err := net.Listen("tcp", "127.0.0.1:8080")
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        return
    }

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accepting:", err.Error())
            return
        }
        go handleRequest(conn)
    }
}

func handleRequest(conn net.Conn) {
    buf := make([]byte, 1024)
    for {
        _, err := conn.Read(buf)
        if err != nil {
            fmt.Println("Error reading:", err.Error())
            return
        }
        conn.Write([]byte("Hello, world!"))
    }
}

Dans le code ci-dessus, nous utilisons le package net pour créer un écouteur TCP, puis utilisons la méthode Accept() pour attendre pour la connexion client. Ensuite, nous gérons la connexion dans la fonction handleRequest() et envoyons notre réponse dans la connexion.

2. Méthode de traitement des fonctions basée sur le protocole UDP

UDP (User Datagram Protocol) est un protocole de couche de transport sans connexion et peu fiable. Dans Golang, on peut aussi facilement créer un simple serveur UDP. Le code est le suivant :

package main

import (
    "fmt"
    "net"
)

func main() {
    udpAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8080")
    if err != nil {
        fmt.Println("Error Resolving UDP address:", err.Error())
        return
    }

    conn, err := net.ListenUDP("udp", udpAddr)
    if err != nil {
        fmt.Println("Error Listening:", err.Error())
        return
    }
    defer conn.Close()

    for {
        buf := make([]byte, 1024)
        _, remoteAddr, err := conn.ReadFromUDP(buf)
        if err != nil {
            fmt.Println("Error Reading:", err.Error())
            continue
        }
        conn.WriteToUDP([]byte("Hello, world!"), remoteAddr)
    }
}

3. Méthode de traitement des fonctions basée sur le protocole HTTP

HTTP (Hypertext Transport Protocol. ) est un protocole de couche application utilisé pour transférer des données entre les navigateurs Web et les serveurs Web. Dans Golang, nous pouvons utiliser le package net/http de la bibliothèque standard pour créer un simple serveur HTTP. Le code est le suivant :

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, world!")
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

Dans le code ci-dessus, nous définissons une fonction handler() pour. Gérez les requêtes HTTP et utilisez http.HandleFunc() dans la fonction main() pour spécifier notre gestionnaire. Enfin, nous utilisons la méthode http.ListenAndServe() pour démarrer notre serveur.

4. Méthode de traitement des fonctions basée sur le protocole WebSocket

WebSocket est un protocole full-duplex, généralement utilisé pour implémenter des fonctions de communication instantanée, telles que les jeux en ligne, le chat instantané, etc. . Dans Golang, nous pouvons utiliser le package gorilla/websocket pour créer un serveur WebSocket. Le code est le suivant :

package main

import (
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func handler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        return
    }
    defer conn.Close()

    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            return
        }
        conn.WriteMessage(websocket.TextMessage, []byte("Hello, world!"))
    }
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

Dans le code ci-dessus, nous utilisons le package gorilla/websocket pour créer un serveur WebSocket et définir La fonction handler() gère les connexions WebSocket. Enfin, nous utilisons les méthodes http.HandleFunc() et http.ListenAndServe() pour démarrer notre serveur.

Résumé

Qu'il s'agisse du protocole TCP, UDP, HTTP ou WebSocket, Golang fournit une riche bibliothèque de fonctions pour nous aider à construire rapidement des serveurs et à gérer diverses communications réseau. En apprenant les quatre protocoles ci-dessus et les méthodes de traitement de Golang, je pense que vous serez en mesure de mieux comprendre la programmation fonctionnelle et d'utiliser Golang de manière plus flexible pour implémenter diverses 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!