Permintaan http Golang mengambil masa

Golang adalah bahasa pengaturcaraan yang sangat sesuai untuk pengaturcaraan rangkaian. Golang menyediakan perpustakaan standard yang sangat mudah digunakan, seperti net/http, yang menyediakan fungsi mencipta dan menghantar permintaan HTTP dan menerima respons. Dalam projek sebenar, kadangkala kami perlu mengira penggunaan masa permintaan HTTP, supaya kami boleh melaksanakan penilaian dan pengoptimuman prestasi dengan lebih baik. Artikel ini akan memperkenalkan cara mengira penggunaan masa permintaan HTTP di Golang.

Pengiraan permintaan HTTP memakan masa

Sebelum mengira masa permintaan HTTP yang memakan masa, kita perlu memahami kitaran hayat permintaan HTTP. Kitaran hayat permintaan HTTP terutamanya dibahagikan kepada empat peringkat berikut.

1. Resolusi DNS: selesaikan nama domain kepada alamat IP
2. Sambungan TCP: wujudkan sambungan TCP melalui alamat IP
3. Pelayan mengendalikan permintaan: pelayan mengendalikan permintaan HTTP untuk pemprosesan Operasi seperti mencari sumber
4. Penghantaran kandungan respons: Pelayan menghantar teks respons kepada klien

Di Golang, kami boleh merakamnya melalui fungsi time perpustakaan standard Now() Masa pada titik masa tertentu, dan kemudian gunakan perbezaan masa untuk mengira masa yang diambil oleh permintaan HTTP. Di bawah ini kami akan memperkenalkan pula kaedah pengiraan masa permintaan HTTP dalam empat peringkat di atas.

1. Resolusi DNS mengambil masa

Di Golang, kami boleh melaksanakan resolusi DNS melalui fungsi net.LookupIP(). Fungsi ini menerima nama hos sebagai parameter dan mengembalikan senarai alamat IP yang sepadan. Kami boleh merekodkan titik masa sebelum resolusi DNS dan selepas resolusi DNS, dan kemudian mengira perbezaan masa untuk mendapatkan masa resolusi DNS. Berikut ialah contoh kod yang mengambil masa untuk menyelesaikan 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. Sambungan TCP mengambil masa

Di Golang, kami boleh mewujudkan sambungan TCP melalui net.Dial() fungsi. Fungsi ini menerima dua parameter, parameter pertama ialah protokol ("tcp" atau "tcp4" atau "tcp6"), dan parameter kedua ialah nama hos sasaran atau alamat IP serta nombor port (contohnya: "example.com: 80" "). Kita boleh merekodkan titik masa sebelum dan selepas sambungan TCP diwujudkan, dan kemudian mengira perbezaan masa untuk mendapatkan masa sambungan TCP. Berikut ialah contoh kod yang mengambil masa untuk sambungan 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. Pelayan mengambil masa untuk memproses permintaan

Di Golang, anda boleh menggunakan http.Client fungsi jenis Do() Hantar permintaan HTTP dan kembalikan jawapan. Kami boleh merekodkan titik masa sebelum menghantar permintaan, dan kemudian merekodkan titik masa selepas menerima respons Dengan mengira perbezaan masa, kami boleh mendapatkan masa yang diperlukan untuk pelayan memproses permintaan. Berikut ialah contoh kod yang mengambil masa untuk pelayan memproses permintaan:

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. Memerlukan masa untuk menyampaikan kandungan respons

Di Golang, melalui http.Client fungsi jenis Do() Boleh menghantar permintaan HTTP dan membalas respons. Kita boleh merekodkan titik masa selepas mendapat respons, dan kemudian merekodkan titik masa selepas penghantaran kandungan respons selesai Dengan mengira perbezaan masa, kita boleh mendapatkan masa berlalu masa penghantaran kandungan respons. Berikut ialah kod sampel yang menunjukkan masa yang diambil untuk menghantar kandungan respons:

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)

Jumlah masa yang dibelanjakan dalam empat peringkat di atas ialah jumlah masa yang diambil oleh permintaan HTTP. Kami boleh meletakkan coretan kod di atas bersama-sama untuk mengira jumlah masa yang dibelanjakan untuk permintaan HTTP. Berikut ialah contoh kod untuk mengira jumlah masa yang dibelanjakan untuk permintaan HTTP:

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)

Ringkasan

Di atas ialah cara mengira masa yang dibelanjakan untuk permintaan HTTP di Golang. Dengan mengira secara berasingan masa resolusi DNS, masa sambungan TCP, masa permintaan pemprosesan pelayan dan masa penghantaran kandungan respons, kami boleh menilai dan mengoptimumkan prestasi permintaan rangkaian dengan lebih baik.

Atas ialah kandungan terperinci Permintaan http Golang mengambil masa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!