La requête http Golang prend du temps

Golang est un langage de programmation très adapté à la programmation web. Golang fournit des bibliothèques standards très utiles, telles que net/http. Cette bibliothèque fournit la fonction de créer et d'envoyer des requêtes HTTP et de recevoir des réponses. Dans les projets réels, nous devons parfois calculer la consommation de temps des requêtes HTTP, afin de pouvoir mieux évaluer et optimiser les performances. Cet article expliquera comment calculer la consommation de temps des requêtes HTTP dans Golang. net/http，这个库提供了创建和发送HTTP请求和接收响应的功能。在实际项目中，我们有时候需要对HTTP请求的耗时进行计算，这样可以更好的进行性能评估和优化。本文将介绍如何在Golang中计算HTTP请求的耗时。

HTTP请求耗时的计算

在计算HTTP请求请求耗时之前，我们需要了解HTTP请求的生命周期。HTTP请求的生命周期主要分为以下四个阶段。

1. DNS解析：将域名解析为IP地址
2. TCP连接：通过IP地址建立TCP连接
3. 服务器处理请求：服务器处理HTTP请求，进行处理查找资源等操作
4. 响应内容传送：服务器将响应文本传送给客户端

在Golang中，我们可以通过time标准库的Now()函数来记录某个时间点的时间，然后通过时间差来计算HTTP请求的耗时。下面我们将依次介绍以上四个阶段的HTTP请求耗时的计算方法。

1. DNS解析耗时

在Golang中，我们可以通过net.LookupIP()函数来进行DNS解析。这个函数接收一个主机名作为参数，并返回其对应的IP地址列表。我们可以分别记录DNS解析前和DNS解析后的时间点，然后计算时间差即可得到DNS解析时间的耗时。下面是一个DNS解析耗时的示例代码：

start := time.Now()
ips, err := net.LookupIP("www.example.com")
end := time.Now()
if err != nil {
    fmt.Println("Failed to resolve DNS:", err)
    return
}
dnsTime := end.Sub(start)
fmt.Println("DNS resolution time:", dnsTime)

2. TCP连接耗时

在Golang中，我们可以通过net.Dial()函数来建立TCP连接。这个函数接收两个参数，第一个参数是协议（"tcp"或"tcp4"或"tcp6"），第二个参数是目标主机名或IP地址加端口号（例如："example.com:80"）。我们可以分别记录TCP连接建立前和建立后的时间点，然后计算时间差即可得到TCP连接时间的耗时。下面是一个TCP连接耗时的示例代码：

start := time.Now()
conn, err := net.Dial("tcp", "www.example.com:80")
end := time.Now()
if err != nil {
    fmt.Println("Failed to connect to server:", err)
    return
}
connTime := end.Sub(start)
fmt.Println("TCP connection time:", connTime)

3. 服务器处理请求耗时

在Golang中，通过http.Client类型的Do()函数可以发送HTTP请求并返回响应。我们可以在发送请求前记录时间点，然后在接收到响应后记录时间点，计算时间差即可得到服务器处理请求时间的耗时。下面是一个服务器处理请求耗时的示例代码：

start := time.Now()
resp, err := http.Get("http://www.example.com")
end := time.Now()
if err != nil {
    fmt.Println("Failed to get response:", err)
    return
}
body, _ := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
serverTime := end.Sub(start)
fmt.Println("Server response time:", serverTime)

4. 响应内容传送耗时

在Golang中，通过http.Client类型的Do()

Calcul chronophage de la requête HTTP

Avant de calculer la requête HTTP qui prend du temps, nous devons comprendre le cycle de vie de la requête HTTP. Le cycle de vie d'une requête HTTP est principalement divisé en quatre étapes suivantes.

1. Résolution DNS : résoudre le nom de domaine en adresse IP
2. Connexion TCP : établir une connexion TCP via l'adresse IP
3. Requête de traitement du serveur : le serveur traite la requête HTTP et la traite Recherche de ressources et autres opérations
4. Transmission du contenu de la réponse : le serveur transmet le texte de la réponse au client

Dans Golang, on peut passer le time La fonction Now() enregistre l'heure à un certain moment dans le temps, puis calcule la consommation de temps de la requête HTTP à travers le décalage horaire. Ci-dessous, nous présenterons tour à tour la méthode de calcul du temps de requête HTTP dans les quatre étapes ci-dessus.

1. La résolution DNS prend du temps

Dans Golang, nous pouvons effectuer la résolution DNS via la fonction net.LookupIP(). Cette fonction reçoit un nom d'hôte en paramètre et renvoie une liste de ses adresses IP correspondantes. Nous pouvons enregistrer les points temporels avant et après la résolution DNS, puis calculer le décalage horaire pour obtenir le temps de résolution DNS. Voici un exemple de code qui prend du temps pour résoudre DNS : 🎜

start := time.Now()
resp, err := http.Get("http://www.example.com")
end := time.Now()
if err != nil {
    fmt.Println("Failed to get response:", err)
    return
}
body, _ := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
transferTime := end.Sub(start)
fmt.Println("Server response time:", transferTime)

2. La connexion TCP prend du temps

🎜Dans Golang, nous pouvons passer net. Fonction Dial () pour établir une connexion TCP. Cette fonction reçoit deux paramètres, le premier paramètre est le protocole ("tcp" ou "tcp4" ou "tcp6") et le deuxième paramètre est le nom d'hôte cible ou l'adresse IP plus le numéro de port (par exemple : "example.com : 80" "). Nous pouvons enregistrer les moments avant et après l'établissement de la connexion TCP, puis calculer le décalage horaire pour obtenir l'heure de connexion TCP. Voici un exemple de code qui prend du temps pour une connexion TCP : 🎜

start := time.Now()
ips, err := net.LookupIP("www.example.com")
if err != nil {
    fmt.Println("Failed to resolve DNS:", err)
    return
}

conn, err := net.Dial("tcp", ips[0].String()+":80")
if err != nil {
    fmt.Println("Failed to connect to server:", err)
    return
}
connTime := time.Now().Sub(start)

req, err := http.NewRequest("GET", "http://www.example.com", nil)
if err != nil {
    fmt.Println("Failed to create HTTP request:", err)
    return
}

start = time.Now()
resp, err := http.DefaultClient.Do(req)
if err != nil {
    fmt.Println("Failed to get response:", err)
    return
}
body, _ := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
serverTime := time.Now().Sub(start)

transferTime := time.Now().Sub(start)
totalTime := connTime + serverTime + transferTime
fmt.Println("HTTP request total time:", totalTime)

3. Il faut du temps au serveur pour traiter la requête

🎜Dans Golang, via http.ClientDo() de type /code> peut envoyer une requête HTTP et renvoyer une réponse. Nous pouvons enregistrer le moment avant d'envoyer la demande, puis enregistrer le moment après avoir reçu la réponse. En calculant le décalage horaire, nous pouvons obtenir le temps nécessaire au serveur pour traiter la demande. Voici un exemple de code qui met du temps au serveur pour traiter la requête : 🎜rrreee

4. Il faut du temps pour fournir le contenu de la réponse

🎜Dans Golang, via http.Client La fonction <code>Do() de type peut envoyer une requête HTTP et renvoyer une réponse. Nous pouvons enregistrer le moment après avoir obtenu la réponse, puis enregistrer le moment après la fin de la transmission du contenu de la réponse. En calculant la différence de temps, nous pouvons obtenir le temps écoulé pour la transmission du contenu de la réponse. Voici un exemple de code qui prend du temps pour transmettre le contenu de la réponse : 🎜rrreee🎜Le temps total passé dans les quatre étapes ci-dessus est le temps total passé sur la requête HTTP. Nous pouvons rassembler les extraits de code ci-dessus pour calculer le temps total passé sur les requêtes HTTP. Voici un exemple de code pour calculer le temps total passé sur les requêtes HTTP : 🎜rrreee🎜Résumé🎜🎜Ce qui précède explique comment calculer le temps passé sur les requêtes HTTP dans Golang. En calculant séparément le temps de résolution DNS, le temps de connexion TCP, le temps de traitement des requêtes du serveur et le délai de livraison du contenu de réponse, nous pouvons mieux évaluer et optimiser les performances des requêtes 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!