Comment faire des requêtes HTTP dans Go

L'un des principes fondamentaux qui régissent le fonctionnement du World Wide Web est l'échange de demandes et de réponses. Lorsque vous envoyez une demande d'accès à une page Web, le serveur répond avec les données appropriées.

Les protocoles populaires qui régissent les différents types de communication Internet incluent HTTP (Protocole de transfert hypertexte), FTP (Protocole de transfert de fichiers), et SMTP (Protocole de transfert de courrier simple).

HTTP est le protocole que vous utiliserez généralement lorsque vous consultez un site Web ou utilisez une application Web. Vous pouvez également travailler avec des requêtes HTTP provenant de nombreux langages de programmation, y compris Go.

Qu'est-ce qu'une requête HTTP?

HTTP définit la manière dont les clients, comme les navigateurs Web, envoient des requêtes aux serveurs qui renvoient ensuite une réponse. Une requête HTTP contient des informations sur une ressource à laquelle le client tente d'accéder. Le message de demande comprend généralement une URL qui identifie la ressource et d'autres données facultatives telles que des en-têtes et des paramètres de requête.

Il y a plusieurs types de requête HTTP, y compris GET, POST, PUT, DELETE, HEAD, OPTIONS et CONNECT. Les quatre premiers types de méthodes sont les plus courants; ils reflètent respectivement les opérations CRUD de lecture, de création, de mise à jour et de suppression.

Le type de requête PUT est souvent utilisé de manière interchangeable avec le type de requête PATCH. Ils atteignent le même objectif, ils diffèrent simplement par les données qu'ils s'attendent à ce que la demande inclue.

Envoi de requêtes à l'aide de méthodes HTTP courantes

Go est intégré http emballer fournit un ensemble de fonctions et de structures que vous pouvez utiliser pour créer des serveurs Web et gérer les requêtes HTTP. C'est un package très robuste et tous les frameworks Web Go s'appuient dessus d'une manière ou d'une autre. C'est un sous-package de Go filet emballer.

Pour créer une requête HTTP dans Go, vous pouvez utiliser le http. Nouvelle requête() fonction et définissez la méthode, l'URL, les en-têtes et le corps de la requête appropriés. Après avoir créé la demande, vous pouvez utiliser le Go réseau/http paquets http. Client{} structure pour l'exécuter et recevoir la réponse.

Les exemples de code suivants utilisent reqres.in, une API accessible au public pour tester les requêtes HTTP. Vous pouvez l'utiliser pour tester les requêtes GET, POST, PUT et DELETE dans vos programmes Go.

Demande POST

Le code ci-dessous est une fonction qui envoie une requête POST au /api/users endpoint de reqres.in pour créer un nouvel utilisateur avec un nom et un travail.

emballer principal
importer (
"octets"
"encodage/json"
"fmt"
"io"
"net/http"
)
fonctionCréer un utilisateur(nom, poste chaîne) {
 fmt. Imprimerln("Création d'un utilisateur...")
 apiUrl := " https://reqres.in/api/users"
 userData := []octet(`{"nom":"` + nom + `","travail":"` + travail + `"}`)
// crée une nouvelle requête http
 requête, erreur := http. Nouvelle requête("POSTE", apiUrl, octets. NouveauBuffer (userData))
 demande. Entête. Ensemble("Type de contenu", "application/json; jeu de caractères=utf-8")
// envoie la requête
 client := & http. Client{}
 réponse, erreur := client. Faire (demander)
si erreur != néant {
 fmt. Println (erreur)
 }
 responseBody, erreur := io. Lire tout (réponse. Corps)
si erreur != néant {
 fmt. Println (erreur)
 }
 formattedData := formatJSON(responseBody)
 fmt. Imprimerln("Statut: ", réponse. Statut)
 fmt. Imprimerln("Corps de la réponse: ", formattedData)
// nettoie la mémoire après exécution
reporter réponse. Corps. Fermer()
}

formatJSON est une fonction personnalisée que vous pouvez écrire pour formater les données de sortie. Voici comment vous pouvez l'implémenter :

// fonction pour formater les données JSON
fonctionformatJSON(données []octet)chaîne {
var octets sortants. Amortir
 erreur := json. Retrait(&out, données, "", " ")
si erreur != néant {
 fmt. Println (erreur)
 }
 d := sortie. Octets()
retourchaîne(d)
}

Vous pouvez appeler le Créer un utilisateur() fonctionner dans un programme comme celui-ci :

fonctionprincipal() {
 fmt. Imprimerln("Faire une requête POST...")
 Créer un utilisateur("Tim Omolana", "Écrivain")
}

Lorsque vous exécutez le programme dans un terminal, en utilisant le aller courir commande, vous verrez une sortie comme celle-ci :

OBTENIR la requête

Le code suivant est une fonction qui envoie une requête GET pour récupérer un utilisateur du serveur reqres.in à l'aide de son ID unique.

// main.go
fonctiongetUser(identifiant chaîne) {
 fmt. Imprimerln("Obtenir l'utilisateur par ID...")
// faire une requête GET à l'API pour obtenir l'utilisateur par ID
 apiUrl := " https://reqres.in/api/users/" + identifiant
 requête, erreur := http. Nouvelle requête("OBTENIR", URL API, néant)
si erreur != néant {
 fmt. Println (erreur)
 }
 demande. Entête. Ensemble("Type de contenu", "application/json; jeu de caractères=utf-8")
 client := & http. Client{}
 réponse, erreur := client. Faire (demander)
si erreur != néant {
 fmt. Println (erreur)
 }
 responseBody, erreur := io. Lire tout (réponse. Corps)
si erreur != néant {
 fmt. Println (erreur)
 }
 formattedData := formatJSON(responseBody)
 fmt. Imprimerln("Statut: ", réponse. Statut)
 fmt. Imprimerln("Corps de la réponse: ", formattedData)
// nettoie la mémoire après exécution
reporter réponse. Corps. Fermer()
}

Une requête GET n'envoie pas de données au serveur, elle n'accepte donc pas ou n'envoie pas de corps de requête au serveur lorsqu'elle est effectuée. Voici à quoi ressemblera un exemple d'appel à la fonction ci-dessus :

fonctionprincipal() {
 fmt. Imprimerln("Faire une requête GET...")
 getUser("2")
}

Sortir:

Requête PUT

La requête PUT est très similaire à une requête POST car elle envoie également des données au serveur. La principale différence est que POST crée une nouvelle ressource tandis que PUT met à jour une ressource existante.

Voici une implémentation d'une requête PUT :

// main.go
fonctionmettre à jour l'utilisateur(nom, poste, identifiant chaîne) {
 fmt. Imprimerln("Mise à jour de l'utilisateur...")
// faire une demande PUT à l'API pour mettre à jour l'utilisateur
 apiUrl := " https://reqres.in/api/users/" + identifiant
 userData := []octet(`{"nom":"` + nom + `","travail":"` + travail + `"}`)
// crée une nouvelle requête http PUT
 requête, erreur := http. Nouvelle requête("METTRE", apiUrl, octets. NouveauBuffer (userData))
 demande. Entête. Ensemble("Type de contenu", "application/json; jeu de caractères=utf-8")
// Corps de fonction restant de la fonction createUser...
// Faire une requête, obtenir une réponse et effacer la mémoire...
}

À partir de ce code, vous pouvez voir que les seules différences entre la requête PUT et la requête POST ci-dessus sont le nom de la méthode et l'URL. Lorsque vous utilisez un PUT pour mettre à jour des données existantes, vous devez ajouter l'identifiant à l'URL de la demande. Un exemple d'appel à cette fonction ressemblerait à ceci :

fonction principale() {
// met à jour l'entrée avec l'ID 2.
 mettre à jour l'utilisateur("Tim Nouveaunom", « Écrivain personnel », "2")
}

Le code ci-dessus met à jour l'utilisateur et produit le résultat suivant :

Supprimer la demande

Utilisez la méthode de requête DELETE pour effectuer une opération de suppression sur un serveur Web. Une demande de suppression supprime la ressource identifiée par l'URI. Une requête DELETE dans Go ressemble à ceci :

fonctionSupprimer l'utilisateur(identifiant chaîne) {
 fmt. Imprimerln("Suppression de l'utilisateur...")
// faire une requête DELETE à l'API pour supprimer l'utilisateur
 apiUrl := " https://reqres.in/api/users/" + identifiant
// crée une nouvelle requête http
 requête, erreur := http. Nouvelle requête("SUPPRIMER", URL API, néant)
 demande. Entête. Ensemble("Type de contenu", "application/json; jeu de caractères=utf-8")
 client := & http. Client{}
 réponse, erreur := client. Faire (demander)
si erreur != néant {
 fmt. Println (erreur)
 }
 fmt. Imprimerln("Statut: ", réponse. Statut)
}

Une requête DELETE n'accepte ni ne renvoie de corps, d'où la raison pour laquelle il n'est pas nécessaire d'analyser ou de formater le corps de la requête et de la réponse JSON. La réponse ne renvoie qu'un statut pour indiquer le succès ou l'échec. Voici à quoi ressemble un exemple d'appel à la fonction avec sa sortie :

fonctionprincipal() {
 fmt. Imprimerln("Demande SUPPRIMER en cours...")
 Supprimer l'utilisateur("2")
}

Sortir:

Gagnez du temps en utilisant le http. Poste() et http. Obtenir() les méthodes de la réseau/http colis à faire POSTE et OBTENIR demandes directement, sans avoir à utiliser le Nouvelle requête() fonction et la Client{} structure pour créer et faire la demande séparément. Vérifiez documentation net/http pour plus d'informations.

Faire des requêtes HTTP dans les applications Go

Le http package dans Go fournit tout ce dont vous avez besoin pour effectuer des requêtes HTTP et gérer les réponses dans les applications Go. Les fonctions et structures fournies par le package vous permettent de créer et d'envoyer différents types de requêtes telles que GET, POST, PUT, DELETE et bien d'autres.

Cela facilite la création d'applications Web dans Go qui peuvent interagir avec d'autres services Web et API. Un bon moyen d'obtenir plus familier avec les requêtes HTTP dans Go consiste à créer une application qui envoie des requêtes à une autre API REST de le vôtre.