Bagaimana untuk menutup sambungan di golang http

Apabila Golang menjadi lebih popular, begitu juga perpustakaan HTTPnya. Walau bagaimanapun, kadangkala kita perlu menutup sambungan semasa permintaan HTTP. Apa yang perlu kita lakukan pada masa ini?

Pertama, mari kita lihat kitaran hayat sambungan HTTP. Apabila pelanggan menghantar permintaan HTTP ke pelayan, ia mewujudkan sambungan TCP. Selepas pelayan menerima permintaan ini, ia akan mengembalikan respons HTTP. Pada penghujung respons HTTP, ia menghantar pengepala "Sambungan: tutup". Ini memberitahu pelanggan bahawa sambungan telah ditutup dan ia harus menutup sambungan selepas membaca respons. Proses ini dipanggil "sambungan pendek".

Jika pelanggan tidak membaca keseluruhan respons, ia akan kekal berhubung dan terus membaca respons. Ini dipanggil "sambungan panjang". Dalam kes ini, pelanggan perlu menutup sambungan secara eksplisit selepas membaca respons.

Jadi bagaimana untuk menutup sambungan di Golang?

Pertama, kita boleh menggunakan http.Client untuk menutup sambungan. Ini boleh dicapai dengan menetapkan tamat masa dalam permintaan. Untuk sambungan pendek, kami boleh menetapkan tamat masa kepada 0 saat. Ini akan menyebabkan pelanggan menutup sambungan serta-merta selepas membaca respons.

Sebagai contoh, kod berikut boleh digunakan untuk menutup sambungan:

import (
    "net/http"
    "time"
)

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

    req, err := http.NewRequest("GET", "http://example.com", nil)
    if err != nil {
        // handle error
    }

    resp, err := client.Do(req)
    if err != nil {
        // handle error
    }
    defer resp.Body.Close()

    // read response
}

Jika anda mahu sambungan yang panjang, anda perlu menetapkan nilainya kepada nilai yang sangat besar apabila menetapkan tamat masa. Contohnya, kod berikut boleh digunakan untuk memastikan sambungan hidup:

import (
    "net/http"
    "time"
)

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

    req, err := http.NewRequest("GET", "http://example.com", nil)
    if err != nil {
        // handle error
    }

    resp, err := client.Do(req)
    if err != nil {
        // handle error
    }
    defer resp.Body.Close()

    // read response
}

Cara lain untuk menutup sambungan ialah menggunakan konteks.Konteks. Pendekatan ini membolehkan maklumat konteks dikongsi merentas berbilang permintaan HTTP dan boleh digunakan untuk membatalkan atau permintaan tamat masa.

Berikut ialah contoh kod untuk menutup sambungan menggunakan konteks.Konteks:

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

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

    req, err := http.NewRequestWithContext(ctx, "GET", "http://example.com", nil)
    if err != nil {
        // handle error
    }

    client := http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        // handle error
    }
    defer resp.Body.Close()

    // read response
}

Dalam kod di atas, kami menggunakan kaedah WithTimeout untuk mencipta konteks dengan tamat masa satu saat . Seterusnya, kami menggunakan kaedah NewRequestWithContext untuk menetapkan konteks kepada permintaan. Kami kemudian menggunakan http.Client untuk melaksanakan permintaan dan menutup badan respons pada penghujungnya.

Ringkasan

Dalam artikel ini, kami memperkenalkan cara untuk menutup sambungan HTTP di Golang. Kami membincangkan kitaran hayat sambungan HTTP dan cara menggunakan http.Client dan context.Context untuk mencapai penutupan sambungan. Sama ada sambungan pendek atau sambungan panjang, kami boleh mencapai penutupan sambungan HTTP sebenar di Golang.

Atas ialah kandungan terperinci Bagaimana untuk menutup sambungan di golang http. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!