golang dekat httpclient

Dalam bahasa Go, http Client ialah perpustakaan permintaan rangkaian yang sangat biasa digunakan. Semasa permintaan rangkaian, untuk mengoptimumkan prestasi dan mengeluarkan sumber, kami selalunya perlu menutup Klien http tepat pada masanya selepas permintaan selesai. Jadi, bagaimana untuk menutup http Client dalam bahasa Go? Artikel ini akan memperkenalkan cara menutup http Client dan beberapa langkah berjaga-jaga.

Kaedah untuk menutup Klien Http

Dalam bahasa Go, menutup Klien http dicapai dengan memanggil kaedah Tutup http Klien. Kaedah Tutup http Client akan melepaskan semua sambungan, termasuk sambungan tidak tertutup. Secara umumnya, kami harus memanggil kaedah Tutup Pelanggan http dengan segera selepas permintaan selesai untuk mengeluarkan sumber.

Kod sampel adalah seperti berikut:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    client := http.Client{}
    req, _ := http.NewRequest("GET", "http://www.example.com", nil)

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
    }

    defer resp.Body.Close()
    defer client.Close()

    fmt.Println(resp.Body)
}

Dalam kod sampel di atas, kami menggunakan Klien http untuk menghantar permintaan GET, dan memanggil kaedah Tutup Pelanggan http selepas permintaan selesai.

Nota

Apabila menggunakan http Client, kita perlu memberi perhatian kepada perkara berikut:

1. Reuse http Client: Dalam sesetengah kes, kita perlu menggunakan semula http Pelanggan, ini boleh mengelak daripada membuat Klien http baharu untuk setiap permintaan. Kami boleh menghantar http.Client yang digunakan semula apabila memanggil kaedah Do.

package main

import (
    "fmt"
    "net/http"
)

func main() {
    transport := http.DefaultTransport.(*http.Transport).Clone()
    client := http.Client{Transport: transport}

    req1, _ := http.NewRequest("GET", "http://www.example.com", nil)
    resp1, err := client.Do(req1)
    if err != nil {
        fmt.Println("Error:", err)
    }

    req2, _ := http.NewRequest("GET", "http://www.example.com", nil)
    resp2, err := client.Do(req2)
    if err != nil {
        fmt.Println("Error:", err)
    }

    defer resp1.Body.Close()
    defer resp2.Body.Close()

    fmt.Println(resp1.Body)
    fmt.Println(resp2.Body)
}

Dalam kod contoh di atas, kami mula-mula menyalin http.DefaultTransport dan kemudian mencipta Klien http baharu. Kemudian kami menghantar dua permintaan GET masing-masing dan membaca Badan dari respons masing-masing.

2. Permintaan serentak: Apabila membuat permintaan serentak, kami juga perlu memberi perhatian kepada penggunaan http Client. Jika berbilang permintaan dihantar pada masa yang sama, adalah tidak bijak untuk mencipta Klien http baharu untuk setiap permintaan. Ini akan membawa kepada pembaziran sumber sistem dan kemungkinan kebuntuan. Oleh itu, kita harus menggunakan semula Klien http sedia ada.

package main

import (
    "fmt"
    "net/http"
)

func main() {
    client := &http.Client{}

    respChan := make(chan *http.Response)

    get := func(url string) {
        req, _ := http.NewRequest("GET", url, nil)
        resp, _ := client.Do(req)
        defer resp.Body.Close()

        respChan <- resp
    }

    urls := []string{"http://www.example.com", "http://www.example.org", "http://www.example.net"}
    for _, url := range urls {
        go get(url)
    }

    for range urls {
        resp := <-respChan
        fmt.Println(resp.Body)
    }

    client.Close()
}

Dalam kod contoh di atas, kami menghantar tiga permintaan GET secara serentak. Kami menggunakan saluran respChan untuk menerima respons bagi setiap permintaan. Dalam gelung, kami membaca setiap respons daripada saluran respChan dan mengeluarkan Badan respons.

Kesimpulan

Amat penting untuk menutup Klien http Jika ia tidak ditutup dalam masa, ia akan menyebabkan pembaziran sumber sistem dan mungkin menyebabkan masalah yang serius. Apabila menggunakan Klien http, kita perlu memberi perhatian kepada beberapa isu seperti permintaan serentak dan menggunakan semula Klien http untuk mengoptimumkan prestasi dan mengeluarkan sumber. Dalam bahasa Go, untuk menutup Klien http, anda hanya perlu memanggil kaedah Tutup.

Atas ialah kandungan terperinci golang dekat httpclient. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!