Permintaan HTTP tak segerak dalam bahasa Go

Dalam era Internet hari ini, banyak aplikasi perlu membuat permintaan rangkaian untuk mendapatkan atau menghantar data. Permintaan HTTP adalah salah satu kaedah permintaan rangkaian yang paling biasa digunakan. Dalam bahasa Go, kita boleh menggunakan pakej net/http dalam pustaka standard untuk memulakan permintaan HTTP, tetapi ini akan menyekat coroutine semasa. Jadi bagaimana untuk melaksanakan permintaan HTTP tak segerak dalam bahasa Go? Artikel ini akan memperkenalkan dua kaedah untuk melaksanakan permintaan HTTP tak segerak dalam bahasa Go.

Kaedah 1: Gunakan goroutine dan saluran

Goroutine membolehkan kami melaksanakan pengaturcaraan tak segerak dengan mudah, dan saluran boleh memudahkan komunikasi antara coroutine. Oleh itu, kami boleh memulakan permintaan HTTP dalam goroutine dan kemudian menggunakan saluran untuk menghantar semula respons kepada goroutine utama. Berikut ialah contoh mudah:

func asyncHTTP(url string, ch chan<- []byte) {
    resp, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }

    ch <- body
}

func main() {
    ch := make(chan []byte)
    url := "https://www.example.com"
    go asyncHTTP(url, ch)

    fmt.Println("Waiting for response...")
    responseBody := <-ch
    fmt.Println("Received response:", string(responseBody))
}

Dalam contoh di atas, kita mula-mula mencipta ch (taip chan []bait) untuk menghantar hasil respons kembali ke coroutine utama. Kemudian kami memanggil fungsi asyncHTTP untuk memulakan permintaan HTTP, yang akan menulis hasil respons ke dalam ch. Akhir sekali, kami membaca hasil respons daripada ch dengan menggunakan operator <-ch.

Perlu diambil perhatian bahawa jika permintaan HTTP tidak dimulakan melalui goroutine, operasi membaca hasil respons <-ch akan menyebabkan coroutine semasa disekat. Menggunakan goroutine dan saluran membolehkan kami melaksanakan permintaan HTTP tak segerak dengan mudah.

Kaedah 2: Gunakan konteks dan http.Do

Dalam bahasa Go, kita boleh menggunakan pakej konteks untuk mengawal masa pelaksanaan dan kebolehbatalan fungsi. Menggunakan konteks bersama-sama dengan fungsi http.Do, kami boleh melaksanakan permintaan HTTP tak segerak yang boleh dibatalkan. Berikut ialah contoh mudah:

func asyncHTTPWithCtx(ctx context.Context, url string) ([]byte, error) {
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        return nil, err
    }

    client := http.DefaultClient
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

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

    return body, nil
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    url := "https://www.example.com"
    resp, err := asyncHTTPWithCtx(ctx, url)

    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Response:", string(resp))
}

Dalam contoh di atas, kami menggunakan fungsi context.WithTimeout untuk mencipta konteks yang boleh dibatalkan. Kemudian kami memanggil fungsi asyncHTTPWithCtx, yang menggunakan fungsi http.Do untuk memulakan permintaan HTTP. Fungsi http.Do boleh menerima parameter konteks Apabila konteks dibatalkan, fungsi http.Do akan membatalkan permintaan HTTP yang dilaksanakan.

Perlu diingatkan bahawa apabila menggunakan fungsi http.Do, kita mesti menutup badan tindak balas secara manual. Jika tidak, ini boleh menyebabkan kebocoran sumber atau keletihan kolam sambungan. Oleh itu, dalam fungsi asyncHTTPWithCtx, kami menggunakan pernyataan tangguh untuk memastikan badan tindak balas ditutup apabila fungsi itu kembali.

Ringkasan

Artikel ini memperkenalkan dua kaedah untuk melaksanakan permintaan HTTP tak segerak dalam bahasa Go: menggunakan goroutine dan saluran serta menggunakan konteks dan fungsi http.Do. Kaedah menggunakan goroutine dan saluran ialah kaedah yang lebih umum dan boleh digunakan untuk meminta sebarang jenis sumber rangkaian secara tidak segerak. Kaedah menggunakan konteks dan fungsi http.Do lebih sesuai untuk senario di mana pembatalan permintaan perlu dikawal. Dengan menggunakan teknologi ini, kami boleh melaksanakan permintaan HTTP tak segerak dengan mudah, meningkatkan prestasi aplikasi dan responsif.

Atas ialah kandungan terperinci Permintaan HTTP tak segerak dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!