golang http permintaan tak segerak

Pemprosesan tak segerak ialah salah satu ciri terpenting dalam banyak aplikasi web moden. Dalam bahasa Go, ia menyediakan cara yang mudah tetapi berkuasa untuk menyelesaikan permintaan tak segerak - menggunakan pakej http. Artikel ini akan memperkenalkan cara menggunakan pakej http golang untuk membuat permintaan tak segerak.

1. Pengenalan

Pakej http dalam bahasa Go ialah pakej yang sangat berkuasa yang boleh digunakan untuk menghantar GET, POST dan pelbagai permintaan HTTP yang lain. Ia juga menyediakan pelanggan untuk berinteraksi dengan pelayan HTTP. Dalam kes asas, pakej http menyediakan cara yang sangat mudah untuk menghantar permintaan segerak, tetapi kami biasanya memerlukan penyelesaian tak segerak. Nasib baik, pakej http menyediakan beberapa fungsi yang mudah tetapi berkuasa untuk mengendalikan permintaan tak segerak. "Dalam Go, kami melaksanakan permintaan tak segerak melalui goroutine, yang membolehkan Go mengendalikan dengan mudah sejumlah besar permintaan tak segerak yang sangat serentak.

2. Penggunaan

1. Cipta pelanggan

Dalam Go, objek klien dalam pakej http boleh digunakan untuk melaksanakan permintaan HTTP tak segerak Kami boleh mencipta klien lalai dengan kod berikut:

package main

import (
    "net/http"
)

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

Dalam contoh di atas, kami Objek klien HTTP lalai. dicipta dan diberikan kepada pembolehubah "klien" 2. Hantar permintaan

Selepas penciptaan klien HTTP selesai, kita boleh menggunakan fungsi http.NewRequest Buat objek permintaan HTTP dan menerima respons untuk membuat permintaan tidak segerak Berikut ialah kod contoh:

package main

import (
    "fmt"
    "net/http"
)

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

    req, err := http.NewRequest("GET", "https://www.google.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    go func() {
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println(err)
            return
        }
        defer resp.Body.Close()
        fmt.Println("Async response status:", resp.Status)
    }()

    fmt.Println("Request sent asynchronously.")
    //等待goroutine结束
    //time.Sleep(5 * time.Second)
}

Dalam kod di atas, kami mula-mula mencipta Pelanggan HTTP kemudian mencipta objek permintaan GET menggunakan fungsi http.NewRequest() . Kami kemudian menggunakan goroutine untuk membina permintaan tak segerak Kod yang menghantar permintaan berada di luar goroutine dan mengeluarkan "Permintaan dihantar secara tidak segerak." Sila ambil perhatian bahawa kami memanggil resp. ) dalam pernyataan penangguhan untuk menutup badan tindak balas Pelbagai ralat mungkin berlaku

1 ralat tamat masa

Klien mungkin berlaku apabila pelayan bertindak balas terlalu perlahan atau disebabkan oleh masalah rangkaian untuk maklum balas. Untuk menyelesaikan masalah ini, kami boleh mengawal masa tamat dan pembatalan permintaan melalui fungsi SetTimeout dan CancelRequest Berikut ialah kod sampel:

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

func main() {
    client := &http.Client{
        Timeout: 5 * time.Second,
    }

    req, err := http.NewRequest("GET", "https://www.google.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

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

    req = req.WithContext(ctx)

    go func() {
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println(err)
            return
        }
        defer resp.Body.Close()
        fmt.Println("Async response status:", resp.Status)
    }()

    fmt.Println("Request sent asynchronously.")
}

Dalam contoh di atas, kami mula-mula menetapkan tamat masa. klien. selama 5 saat Kemudian, konteks baharu dan objek permintaan dibuat menggunakan fungsi WithTimeout dalam pakej konteks fungsi selesai ( Jika ia masih wujud). untuk menyelesaikan masalah sambungan rangkaian. Tamat masa sambungan boleh ditetapkan menggunakan fungsi Dialer yang disediakan dalam http.Transport Berikut ialah kod contoh:

package main

import (
    "context"
    "fmt"
    "net"
    "net/http"
    "time"
)

func main() {
    dialer := &net.Dialer{
        Timeout: 5 * time.Second,
    }

    transport := &http.Transport{
        DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
            return dialer.DialContext(ctx, network, addr)
        },
    }

    client := &http.Client{
        Transport: transport,
    }

    req, err := http.NewRequest("GET", "https://www.google.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    go func() {
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println(err)
            return
        }
        defer resp.Body.Close()
        fmt.Println("Async response status:", resp.Status)
    }()

    fmt.Println("Request sent asynchronously.")
}

Menggunakan kaedah di atas sekali lagi, kami menetapkan tamat masa pendail kepada 5. saat. Kemudian, pelanggan menggunakan http Fungsi DialContext yang disediakan dalam .Transport membuat permintaan. Fungsi ini akan menggunakan Dialer yang kami tetapkan untuk sambungan rangkaian dan menutup sambungan selepas tamat masa. Ambil perhatian bahawa kita perlu memastikan kita menutup badan tindak balas selepas menerima respons.

4. Kesimpulan

Dalam artikel ini, kami memperkenalkan kaedah menggunakan pakej http untuk membuat permintaan HTTP tak segerak dalam bahasa Go. Kami mencipta goroutine untuk menghantar permintaan secara tidak segerak dan memperkenalkan kaedah pengendalian ralat biasa. Pendekatan ini sangat mudah tetapi berkuasa dan boleh mengendalikan situasi konkurensi tinggi yang mungkin timbul dalam aplikasi web, menjadikannya lebih fleksibel daripada kebanyakan perpustakaan rangkaian tradisional. Kini anda boleh menggunakan teknik ini pada kod anda, menjimatkan masa dan sumber yang berharga.

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