Comment implémenter le transfert de requêtes et ajouter une fonction de retard dans Golang

Lors du développement d'applications Web, nous devons souvent transférer les requêtes vers un autre serveur pour traitement, comme la mise en œuvre de l'équilibrage de charge, la mise en cache des requêtes, etc. Golang est un langage efficace et le package net/http de sa bibliothèque standard offre diverses façons de transmettre les requêtes. Voyons ici comment implémenter le transfert de requêtes et ajouter des fonctions de retard dans Golang.

Tout d'abord, nous devons créer un serveur HTTP pour recevoir les demandes des utilisateurs. Pour faciliter la démonstration, je vais simuler le transfert de requêtes en démarrant deux serveurs HTTP localement. L'un des ports du serveur est le 8081 et l'autre le 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))
}

Ensuite, nous devons modifier le code pour implémenter le transfert de requête et ajouter des fonctions de retard. Étant donné que Golang prend en charge les opérations asynchrones, nous pouvons implémenter des retards via goroutine et canaux.

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

Dans le code ci-dessus, nous avons créé un canal, utilisé goroutine pour implémenter un délai d'une seconde, puis utilisé http.Get() pour transmettre la demande, et enfin attendu que le canal envoie un signal, c'est-à-dire après le le délai est terminé, ce n'est qu'alors que la réponse sera renvoyée à l'utilisateur. De cette manière, la fonction d'ajout de délai lors du transfert de la demande est réalisée.

En plus d'utiliser goroutine et canal pour implémenter le délai, nous pouvons également utiliser la méthode time.Sleep() fournie dans le package time, comme indiqué ci-dessous :

time.Sleep(1 * time.Second)

Il convient de noter que dans l'environnement de production réel, nous avons besoin faire attention Temps de retard pour éviter la dégradation des performances de l'application causée par un délai trop long.

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!