Développement web avec Go

a. Définition de la structure du serveur

Un serveur HTTP doit être capable de répondre aux requêtes tout en gérant les erreurs éventuelles. Pour cela, il est recommandé de structurer le code en plusieurs fonctions distinctes.

package main  
 
import (  
    "fmt"  
    "log"  
    "net/http"  
)  
 
// handler racine, affiche un message de bienvenue  
func homeHandler(w http.ResponseWriter, r *http.Request) {  
    if _, err := fmt.Fprintln(w, "Bienvenue sur le serveur!"); 
err != nil{ 
        log.Printf("Erreur lors de l'écriture de la réponse 
dans homeHandler : %v", err)  
    Http.Error(w, "Erreur interne du serveur", 
http.StatusInternalServerError)  
        return  
    }  
    }  
 
// handler pour une page d'information  
func infoHandler(w http.ResponseWriter, r *http.Request) {  
    fmt.Fprintln(w, "Informations sur le serveur HTTP en Go.")  
 
// fonction d'initialisation du serveur  
func startServer() {  
    http.HandleFunc("/", homeHandler)  
    http.HandleFunc("/info", infoHandler)  
 
    port := ":8080" 
    log.Println("Le serveur démarre sur http://localhost"...

a. Lire la méthode HTTP

La méthode HTTP (GET, POST, PUT, DELETE, etc.) indique l’intention de la requête. Le serveur doit identifier cette méthode pour traiter correctement la requête.

package main  
 
import (  
    "fmt"  
    "log"  
    "net/http"  
)  
 
// Handler qui affiche la méthode HTTP utilisée  
func methodHandler(w http.ResponseWriter, r *http.Request) {  
    fmt.Fprintf(w, "Méthode HTTP reçue : %s", r.Method)  
}  
 
func main() {  
    http.HandleFunc("/method", methodHandler)  
 
    port := ":8080"  
    log.Println("Serveur démarré sur http://localhost" + port)  
    if err := http.ListenAndServe(port, nil); err != nil {  
        log.Fatalf("Erreur serveur : %v", err)  
}  
} 

Test avec curl :

curl -X GET http://localhost:8080/method  
curl -X POST http://localhost:8080/method 

b. Lire les en-têtes de requête

Les en-têtes HTTP contiennent des métadonnées sur la requête, comme le type de contenu, l’agent utilisateur ou des informations d’authentification....

a. Sérialisation d’une structure simple

Le package encoding/json fournit json.Marshal() pour convertir une structure Go en JSON.

package main  
 
import (  
    "encoding/json"  
    "fmt"  
    "log"  
)  
 
// Définition d'une structure utilisateur  
type User struct {  
    Name  string `json:"name"`  
    Age   int    `json:"age"`  
    Email string `json:"email"`  
}  
 
func main() {  
    user := User{Name: "Alice", Age: 30, Email: "alice@example.com"} 
 
    jsonData, err := json.Marshal(user)  
    if err != nil {  
        log.Fatalf("Erreur de sérialisation JSON : %v", err)  
    }  
 
    fmt.Println("Données JSON :", string(jsonData))  
} 

b. Formatage du JSON pour la lisibilité

Par défaut, json.Marshal() génère une sortie compacte. Pour un format lisible, on utilise json.MarshalIndent().

jsonPretty, err := json.MarshalIndent(user, "", "  ")  
if err != nil {  
    log.Fatalf("Erreur de sérialisation JSON : %v", err)  
}  
fmt.Println("Données JSON formatées :\n", string(jsonPretty)) 

c. Ignorer des champs lors de la conversion

Certains champs peuvent être exclus du JSON en utilisant l’option...

a. Installation de Gin

L’installation du framework se fait avec la commande suivante :

go get -u github.com/gin-gonic/gin 

b. Création d’un serveur avec Gin

Voici un exemple de serveur HTTP minimal utilisant Gin :

package main  
 
import (  
    "github.com/gin-gonic/gin"  
    "net/http"  
)  
 
func main() {  
    router := gin.Default()  
 
    // Définition d'une route GET sur la racine  
    router.GET("/", func(c *gin.Context) {  
        c.JSON(http.StatusOK, gin.H{"message": "Bienvenue sur Gin!"}) 
    })  
 
    router.Run(":8080") // Démarre le serveur sur le port 8080  
} 

c. Gestion des routes avec des paramètres

Gin permet de récupérer facilement des paramètres passés dans l’URL.

func userHandler(c *gin.Context) {  
    username := c.Param("username")...