golang menghantar permintaan

Go ialah bahasa pengaturcaraan sumber terbuka yang sangat sesuai untuk menulis aplikasi rangkaian yang cekap, boleh dipercayai dan serentak. Disebabkan prestasi cemerlang dan kemudahan penulisannya, Go telah menjadi bahasa pengaturcaraan pilihan untuk banyak aplikasi. Dalam artikel ini, kami akan membincangkan cara menghantar permintaan HTTP menggunakan Go.

1. Mula-mula perkenalkan pakej net/http

Langkah pertama untuk menghantar permintaan HTTP dalam Go ialah memperkenalkan pakej net/http. Ia menyediakan banyak ciri, termasuk mencipta klien dan pelayan HTTP, dsb.

import "net/http"

2. Mencipta klien HTTP

Untuk mencipta klien HTTP, kita perlu menggunakan struktur http.Client. Boleh dibuat menggunakan:

klien := &http.Client{}

Terdapat juga banyak pilihan dalam klien untuk diubah suai. Contohnya, anda boleh menetapkan tamat masa, menggunakan pelayan proksi, dsb. Berikut ialah contoh dengan tamat masa dan pelayan proksi.

tamat masa := masa.Tempoh(5 * masa.Kedua)
pengangkutan := &http.Pengangkutan{

Proxy: http.ProxyURL(proxyUrl),

}
pelanggan := &http.Pelanggan{

Timeout:   timeout,
Transport: transport,

}

Sila ambil perhatian bahawa pelayan proksi adalah pilihan. Jika anda tidak perlu menggunakan pelayan proksi, anda boleh terus menggunakan URL proksi kosong:

proxyUrl, err := url.Parse("")

3. Hantar HTTP GET permintaan

Sekarang kami telah mencipta klien HTTP, kami boleh mula menghantar permintaan. Permintaan paling mudah ialah permintaan HTTP GET, kami menggunakan fungsi Get untuk menghantar permintaan GET.

resp, err := client.Get("https://www.example.com/path/to/resource")

func main() {

resp, err := http.Get("https://www.example.com/path/to/resource")
if err != nil {
        // handle error
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
        // handle error
}
fmt.Println(string(body))

}

Jika permintaan berjaya, pelayan akan mengembalikan respons. Kandungan, seperti kod status respons dan badan respons, boleh dibaca daripada respons. Nota: Kaedah resp.Body.Close() mesti dipanggil selepas membaca badan tindak balas untuk melepaskan sumber badan tindak balas.

4. Hantar permintaan HTTP POST

Selain permintaan GET, anda juga boleh menghantar permintaan HTTP POST. Permintaan POST biasanya digunakan untuk menyerahkan data ke pelayan. Kita boleh menggunakan fungsi Post untuk membuat permintaan POST seperti berikut:

values ​​​​ := map[string]string{"username": "Administrator", "password": "Password"}
jsonValue , _ := json.Marshal(values)
url := "http://example.com/login"
req, err := http.NewRequest("POST", url, bytes.NewBuffer( jsonValue ))
req.Header.Set("Content-Type", "application/json")

func main() {

values := map[string]string{"username": "管理员", "password": "密码"}
jsonValue, _ := json.Marshal(values)
resp, err := http.Post("http://example.com/login", "application/json", bytes.NewBuffer(jsonValue))
if err != nil {
        // handle error
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
        // handle error
}
fmt.Println(string(body))

}

di atas Dalam kod, kami menggunakan fungsi NewRequest untuk membuat permintaan POST. Kami menghantar badan permintaan kepada fungsi bait.NewBuffer, di mana badan dikodkan menggunakan format JSON. Kami kemudian menetapkan pengepala Jenis Kandungan kepada "aplikasi/json" supaya pelayan mengetahui bahawa kandungan permintaan adalah dalam format JSON.

5. Hantar jenis permintaan HTTP yang lain

Dalam Go, anda boleh menghantar jenis permintaan HTTP yang lain, seperti PUT, DELETE, PATCH, OPTIONS, HEAD, dsb. Untuk menghantar permintaan ini, kami boleh menggunakan fungsi http.NewRequest. Berikut ialah contoh menghantar fail JSON menggunakan permintaan PUT:

values ​​​​ := map[string]string{"name": "John Doe", "age": "29"}
jsonValue, _ := json.Marshal(values)
req, err := http.NewRequest("PUT", "http://example.com/users/123", bytes.NewBuffer(jsonValue))
req. Header.Set("Content-Type", "application/json")

func main() {

values := map[string]string{"name": "John Doe", "age": "29"}
jsonValue, _ := json.Marshal(values)
req, err := http.NewRequest("PUT", "http://example.com/users/123", bytes.NewBuffer(jsonValue))
if err != nil {
        // handle error
}
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
        // handle error
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
        // handle error
}
fmt.Println(string(body))

}

Untuk menghantar DELETE, PATCH , OPTIONS dan permintaan HEAD, cuma tukar parameter pertama dalam fungsi http.NewRequest kepada kaedah HTTP yang berkaitan. Contohnya, untuk menghantar permintaan DELETE, tukar parameter pertama kepada "DELETE".

6. Kesimpulan

Dalam artikel ini, kami memperkenalkan cara menghantar permintaan HTTP menggunakan Go. Kami mencipta klien HTTP dan menghantar permintaan HTTP GET dan POST ke pelayan. Kami juga membincangkan cara menghantar jenis permintaan HTTP yang lain, seperti PUT, DELETE, PATCH, OPTIONS, HEAD, dsb.

Dalam pembangunan sebenar, biasanya perlu menggunakan lebih banyak pilihan dan fungsi. Ini boleh dicapai dengan menetapkan sifat yang berbeza bagi struktur http.Client. Menggunakan kaedah ini, anda boleh menghantar permintaan HTTP dengan mudah dalam Go dan mengendalikan respons. Sama ada anda sedang membina aplikasi web, sistem teragih, perkhidmatan hujung belakang atau sebarang aplikasi rangkaian lain, anda boleh menyelesaikan tugas dengan mudah dengan Go.

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