Golang mengoptimumkan permintaan http

Dengan pembangunan aplikasi web, pengoptimuman permintaan HTTP telah menjadi topik penting. Bukan sahaja mengoptimumkan prestasi aplikasi web, tetapi juga meningkatkan pengalaman pengguna. Dalam bahasa Go, kami boleh menggunakan beberapa teknik untuk mengoptimumkan permintaan HTTP, termasuk: permintaan serentak dan pengoptimuman prestasi.

1. Permintaan serentak

Bahasa Go mempunyai sokongan terbina dalam untuk permintaan serentak, yang membolehkan kami memproses berbilang permintaan HTTP serentak dalam program, yang boleh meningkatkan prestasi program dan kelajuan tindak balas. Kita boleh menggunakan permintaan tak segerak dan permintaan serentak untuk mencapai fungsi ini.

Permintaan tak segerak:

Permintaan tak segerak bermaksud semasa memproses permintaan, anda tidak menunggu respons untuk dikembalikan, tetapi terus ke permintaan tak segerak biasanya dilaksanakan menggunakan goroutine. Kod sampel adalah seperti berikut:

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

Dalam kod di atas, kami mentakrifkan fungsi permintaan untuk menghantar permintaan HTTP dan memproses respons, dan kemudian menggunakan gelung for untuk meminta berbilang pautan URL secara serentak dalam goroutine yang berasingan.

Permintaan serentak:

Permintaan serentak merujuk kepada pemprosesan berbilang permintaan pada masa yang sama, tetapi menunggu semua permintaan dikembalikan sebelum memproses keputusan. Dalam kes ini, anda perlu menggunakan saluran goroutine dan pergi untuk mencapai matlamat Kod sampel adalah seperti berikut:

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

Dalam kod di atas, kami mentakrifkan fungsi permintaan untuk menghantar permintaan HTTP dan memproses respons, dan kemudian gunakan untuk gelung Berbilang pautan URL diminta secara serentak Setiap pautan URL dilaksanakan dalam goroutine yang berasingan, dan hasil pemprosesan dihantar ke fungsi utama melalui saluran pergi. hasilnya adalah output.

2. Pengoptimuman Prestasi

Selain permintaan serentak, kami juga boleh mempercepatkan pemprosesan permintaan HTTP melalui beberapa teknik pengoptimuman prestasi.

Gunakan kumpulan sambungan:

Dalam bahasa Go, setiap permintaan HTTP perlu membuat sambungan TCP, yang akan membawa kepada terlalu banyak sambungan apabila memproses sejumlah besar permintaan. Jika kami menggunakan kumpulan sambungan, kami boleh menggunakan semula sambungan ini dan mengurangkan penggunaan sumber sistem Kod sampel adalah seperti berikut:

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

Dalam kod di atas, kami mencipta objek http.Client dan menetapkan sambungan. pool Saiznya ialah 10 dan kemudian permintaan HTTP dihantar menggunakan kaedah klien.Get.

Gunakan Keep-Alive:

Dalam protokol HTTP/1.1, Keep-Alive didayakan secara lalai, yang membolehkan klien dan pelayan mengekalkan sambungan selepas memproses permintaan Kemudian gunakan ini status sambungan untuk mengendalikan permintaan seterusnya. Dalam bahasa Go, Keep-Alive juga dihidupkan secara lalai.

Gunakan pemampatan gzip:

Apabila memproses sejumlah besar permintaan HTTP, jika data yang dikembalikan oleh pelayan adalah besar, ia mungkin mengambil masa yang lama untuk pelanggan menerima data. Dalam kes ini, kami boleh meminta pelayan untuk menggunakan pemampatan gzip semasa menghantar data, yang boleh mengurangkan masa penghantaran data. Dalam bahasa Go, anda boleh mendayakan pemampatan gzip dengan menetapkan pengepala permintaan Kod sampel adalah seperti berikut:

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

Dalam kod di atas, kami mencipta objek http.Client dan menetapkan DisableCompression bagi. Transport atribut ke false , supaya bahasa Go boleh memproses data mampat gzip secara automatik. Kami juga mencipta objek permintaan baharu dan menambahkan teg sokongan gzip dalam pengepala permintaan, dan kemudian meminta data yang dikembalikan oleh pelayan untuk menggunakan pertimbangan untuk mengendalikan situasi berbeza bagi data mampat gzip dan data tidak termampat.

Ringkasan:

Bahasa Go mempunyai sokongan terbina dalam untuk permintaan serentak dan pengoptimuman prestasi Penggunaan teknologi ini boleh meningkatkan prestasi dan kelajuan tindak balas program. Kami boleh menggunakan permintaan tak segerak dan permintaan serentak untuk melaksanakan permintaan serentak, dan menggunakan pengumpulan sambungan, Keep-Alive, mampatan gzip dan teknologi lain untuk mengoptimumkan prestasi permintaan HTTP.

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