So implementieren Sie die Anforderungsweiterleitung und fügen eine Verzögerungsfunktion in Golang hinzu

Bei der Entwicklung von Webanwendungen müssen wir häufig Anforderungen zur Verarbeitung an einen anderen Server weiterleiten, z. B. zur Implementierung von Lastausgleich, Anforderungs-Caching usw. Golang ist eine effiziente Sprache und das Paket net/http in seiner Standardbibliothek bietet verschiedene Möglichkeiten zur Weiterleitung von Anfragen. Lassen Sie uns hier besprechen, wie Sie die Anforderungsweiterleitung implementieren und Verzögerungsfunktionen in Golang hinzufügen.

Zuerst müssen wir einen HTTP-Server erstellen, um Benutzeranfragen zu empfangen. Zur einfacheren Demonstration werde ich die Anforderungsweiterleitung simulieren, indem ich zwei HTTP-Server lokal starte. Einer der Ports des Servers ist 8081 und der andere ist 8082.

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Printf("request from: %s\n", r.RemoteAddr)
        resp, err := http.Get("http://127.0.0.1:8081")
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        defer resp.Body.Close()

        _, err = w.Write([]byte(fmt.Sprintf("[%s]: %s", r.RemoteAddr, resp.Status)))
        if err != nil {
            log.Printf("failed to write response: %s", err.Error())
        }
    })

    addr := ":8080"
    log.Printf("listening on %s...\n", addr)
    log.Fatal(http.ListenAndServe(addr, nil))
}

Als nächstes müssen wir den Code ändern, um die Anforderungsweiterleitung zu implementieren und Verzögerungsfunktionen hinzuzufügen. Da Golang asynchrone Vorgänge gut unterstützt, können wir Verzögerungen über Goroutine und Kanäle implementieren.

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Printf("request from: %s\n", r.RemoteAddr)

        // 使用channel来实现延时
        done := make(chan bool)
        go func() {
            time.Sleep(1 * time.Second)
            done <- true
        }()

        // 请求转发
        resp, err := http.Get("http://127.0.0.1:8081")
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        defer resp.Body.Close()

        _, err = w.Write([]byte(fmt.Sprintf("[%s]: %s", r.RemoteAddr, resp.Status)))
        if err != nil {
            log.Printf("failed to write response: %s", err.Error())
        }

        // 等待延时完成
        <-done
    })

    addr := ":8080"
    log.Printf("listening on %s...\n", addr)
    log.Fatal(http.ListenAndServe(addr, nil))
}

Im obigen Code haben wir einen Kanal erstellt, mit Goroutine eine Verzögerung von 1 Sekunde implementiert, dann http.Get() zum Weiterleiten der Anfrage verwendet und schließlich darauf gewartet, dass der Kanal ein Signal sendet, d. h. nach dem Die Verzögerung ist abgeschlossen. Erst dann wird die Antwort an den Benutzer zurückgegeben. Auf diese Weise wird die Funktion des Hinzufügens einer Verzögerung beim Weiterleiten der Anfrage realisiert.

Zusätzlich zur Verwendung von Goroutine und Kanal zum Implementieren von Verzögerungen können wir auch die im Zeitpaket bereitgestellte Methode time.Sleep () verwenden, wie unten gezeigt:

time.Sleep(1 * time.Second)

Es sollte beachtet werden, dass wir in der tatsächlichen Produktionsumgebung Folgendes benötigen Beachten Sie die Verzögerungszeit, um eine Verschlechterung der Anwendungsleistung durch zu lange Verzögerungen zu vermeiden.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Anforderungsweiterleitung und fügen eine Verzögerungsfunktion in Golang hinzu. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!