Golang optimise les requêtes http

Avec le développement des applications web, l'optimisation des requêtes HTTP est devenue un sujet important. Non seulement optimise les performances des applications Web, mais améliore également l'expérience utilisateur. Dans le langage Go, nous pouvons utiliser certaines techniques pour optimiser les requêtes HTTP, notamment : les requêtes simultanées et l'optimisation des performances.

1. Demande simultanée

Le langage Go prend en charge la fonction de requête simultanée, ce qui nous permet de traiter plusieurs requêtes HTTP simultanément dans un seul programme , cela peut donc grandement améliorer les performances et la vitesse de réponse du programme. Nous pouvons utiliser des requêtes asynchrones et des requêtes simultanées pour réaliser cette fonction.

Demande asynchrone :

Une requête asynchrone signifie que lors du traitement d'une requête, vous n'attendez pas le retour de la réponse, mais passez directement à la requête suivante. Les requêtes asynchrones sont généralement. implémenté à l'aide de goroutine, exemple de code comme suit :

func request(url string) {
    resp, err := http.Get(url)
    if err != nil {
        // handle error
        return
    }
    defer resp.Body.Close()

    // handle response
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        // handle error
        return
    }

    fmt.Println(string(body))
}

func main() {
    urls := []string{"http://example.com", "http://example.net", "http://example.org"}

    for _, url := range urls {
        go request(url)
    }

    // Wait for all goroutines to finish
    time.Sleep(time.Second)
}

Dans le code ci-dessus, nous définissons la fonction de requête pour envoyer des requêtes HTTP et traiter les réponses, puis utilisons une boucle for pour demander simultanément plusieurs liens URL, chacun Le lien URL est traité séparément Exécuté dans goroutine.

Demandes simultanées :

Les requêtes simultanées font référence au traitement de plusieurs requêtes en même temps, mais en attendant que toutes les requêtes reviennent avant de traiter les résultats. Dans ce cas, vous devez utiliser goroutine et go canal pour atteindre l'objectif. L'exemple de code est le suivant :

func request(url string, ch chan<- string) {
    resp, err := http.Get(url)
    if err != nil {
        // handle error
        ch <- fmt.Sprintf("Error: %s", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        // handle error
        ch <- fmt.Sprintf("Error: %s", err)
        return
    }

    ch <- string(body)
}

func main() {
    urls := []string{"http://example.com", "http://example.net", "http://example.org"}

    ch := make(chan string)

    for _, url := range urls {
        go request(url, ch)
    }

    for range urls {
        fmt.Println(<-ch)
    }
}

Dans le code ci-dessus, nous définissons la fonction de requête pour envoyer des requêtes HTTP et traiter les réponses. , puis utilisez La boucle for demande simultanément plusieurs liens URL. Chaque lien URL est exécuté dans une goroutine distincte et les résultats du traitement sont transmis à la fonction principale via le canal go une fois les réponses à toutes les demandes reçues dans la fonction principale. , les résultats sont affichés.

2. Optimisation des performances

En plus des requêtes simultanées, nous pouvons également accélérer le traitement des requêtes HTTP grâce à certaines techniques d'optimisation des performances.

Utiliser le pool de connexions :

En langage Go, chaque requête HTTP doit créer une connexion TCP, ce qui entraînera un nombre excessif de connexions lors du traitement d'un grand nombre de requêtes . beaucoup. Si nous utilisons un pool de connexions, nous pouvons réutiliser ces connexions et réduire la consommation des ressources système. L'exemple de code est le suivant :

// Create a new client with a connection pool
client := &http.Client{
    Transport: &http.Transport{
        MaxIdleConnsPerHost: 10,
    },
}

// Send a http request
resp, err := client.Get("http://example.com")
if err != nil {
    // handle error
    return
}
defer resp.Body.Close()

// handle response
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
    // handle error
    return
}

fmt.Println(string(body))

Dans le code ci-dessus, nous avons créé un objet http.Client et défini. la connexion. La taille du pool est de 10, puis la requête HTTP est envoyée à l'aide de la méthode client.Get.

Utiliser Keep-Alive :

Dans le protocole HTTP/1.1, Keep-Alive est activé par défaut, ce qui permet au client et au serveur de traiter une requête après avoir maintenu la connexion état, puis utilisez cet état de connexion pour gérer les demandes ultérieures. Dans le langage Go, Keep-Alive est également activé par défaut.

Utiliser la compression gzip :

Lors du traitement d'un grand nombre de requêtes HTTP, si les données renvoyées par le serveur sont volumineuses, l'acceptation du client peut mettre beaucoup de temps les données. Dans ce cas, nous pouvons demander au serveur d'utiliser la compression gzip lors de la transmission des données, ce qui peut réduire le temps de transmission des données. Dans le langage Go, vous pouvez activer la compression gzip en définissant l'en-tête de la requête. L'exemple de code est le suivant :

// Create a new client with a gzip transport
client := &http.Client{
    Transport: &http.Transport{
        DisableCompression: false,
    },
}

// Create a new request with gzip header
req, err := http.NewRequest("GET", "http://example.com", nil)
if err != nil {
    // handle error
    return
}
req.Header.Add("Accept-Encoding", "gzip")

// Send a http request
resp, err := client.Do(req)
if err != nil {
    // handle error
    return
}
defer resp.Body.Close()

// handle response
if resp.Header.Get("Content-Encoding") == "gzip" {
    gzr, err := gzip.NewReader(resp.Body)
    if err != nil {
        // handle error
        return
    }
    defer gzr.Close()

    body, err := ioutil.ReadAll(gzr)
    if err != nil {
        // handle error
        return
    }

    fmt.Println(string(body))
} else {
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        // handle error
        return
    }

    fmt.Println(string(body))
}

Dans le code ci-dessus, nous avons créé un objet http.Client et défini le paramètre DisableCompression. de l'attribut Transport est faux, ce qui permet au langage Go de traiter automatiquement les données compressées gzip. Nous avons également créé un nouvel objet de requête et ajouté la balise de support gzip dans l'en-tête de la requête, puis avons demandé aux données renvoyées par le serveur de faire preuve de jugement pour gérer les différentes situations de données compressées gzip et de données non compressées.

Résumé :

Le langage Go prend en charge les requêtes simultanées et l'optimisation des performances. L'utilisation de ces technologies peut considérablement améliorer les performances et la vitesse de réponse du programme. Nous pouvons utiliser des requêtes asynchrones et des requêtes simultanées pour implémenter des requêtes simultanées, et utiliser le pooling de connexions, Keep-Alive, la compression gzip et d'autres technologies pour optimiser les performances des requêtes HTTP.

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!