Golang envoie une demande

Go est un langage de programmation open source très adapté à l'écriture d'applications réseau efficaces, fiables et simultanées. En raison de ses excellentes performances et de sa facilité d’écriture, Go est devenu le langage de programmation de choix pour de nombreuses applications. Dans cet article, nous expliquerons comment envoyer des requêtes HTTP à l'aide de Go.

1. Introduisez d'abord le package net/http

La première étape pour envoyer des requêtes HTTP dans Go est d'introduire le package net/http. Il offre de nombreuses fonctionnalités, notamment la création de clients et de serveurs HTTP, etc.

importer "net/http"

2. Créer un client HTTP

Pour créer un client HTTP, nous devons utiliser la structure http.Client. Peut être créé en utilisant :

client := &http.Client{}

Il existe également de nombreuses options à modifier dans le client. Par exemple, vous pouvez définir des délais d'attente, utiliser des serveurs proxy, etc. Voici un exemple avec des délais d'attente et un serveur proxy.

timeout := time.Duration(5 * time.Second)
transport := &http.Transport{

Proxy: http.ProxyURL(proxyUrl),

}
client := &http.Client{

Timeout:   timeout,
Transport: transport,

}

Veuillez noter que le serveur proxy est facultatif. Si vous n'avez pas besoin d'utiliser un serveur proxy, vous pouvez utiliser directement une URL de proxy vide :

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

3. Envoyer une requête HTTP GET

Maintenant que nous avons créé le Client HTTP, nous pouvons commencer à envoyer Demandé. La requête la plus simple est la requête HTTP GET, nous utilisons la fonction Get pour envoyer la requête 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))

}

Si la requête réussit, le serveur renverra une réponse. Le contenu peut être lu à partir de la réponse, tel que le code d'état de la réponse et le corps de la réponse. Remarque : La méthode resp.Body.Close() doit être appelée après avoir lu le corps de la réponse pour libérer les ressources du corps de la réponse.

4. Envoyer une requête HTTP POST

En plus des requêtes GET, vous pouvez également envoyer des requêtes HTTP POST. Les requêtes POST sont généralement utilisées pour soumettre des données au serveur. Nous pouvons utiliser la fonction Post pour créer une requête POST comme suit :

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))

}

Dans le code ci-dessus, nous créons une requête POST à ​​l'aide de la fonction NewRequest. Nous transmettons le corps de la requête à la fonction bytes.NewBuffer, où le corps est codé au format JSON. Nous définissons ensuite l'en-tête Content-Type sur "application/json" afin que le serveur sache que le corps de la requête est au format JSON.

5. Envoyer d'autres types de requêtes HTTP

Dans Go, vous pouvez envoyer d'autres types de requêtes HTTP, telles que PUT, DELETE, PATCH, OPTIONS, HEAD, etc. Pour envoyer ces requêtes, nous pouvons utiliser la fonction http.NewRequest. Voici un exemple d'envoi d'un fichier JSON à l'aide d'une requête 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))

}

Pour envoyer des requêtes DELETE, PATCH, OPTIONS et HEAD, modifiez simplement le premier paramètre de la fonction http.NewRequest par la méthode HTTP appropriée . Par exemple, pour envoyer une requête DELETE, remplacez le premier paramètre par "DELETE".

6. Conclusion

Dans cet article, nous avons expliqué comment envoyer des requêtes HTTP à l'aide de Go. Nous avons créé un client HTTP et envoyé des requêtes HTTP GET et POST au serveur. Nous avons également expliqué comment envoyer d'autres types de requêtes HTTP, telles que PUT, DELETE, PATCH, OPTIONS, HEAD, etc.

Dans le développement réel, il est généralement nécessaire d'utiliser plus d'options et de fonctions. Ceci peut être réalisé en définissant différentes propriétés de la structure http.Client. En utilisant ces méthodes, vous pouvez facilement envoyer des requêtes HTTP dans Go et gérer les réponses. Que vous créiez une application Web, un système distribué, un service backend ou toute autre application réseau, vous pouvez facilement faire le travail avec Go.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!