HTTP and REST APIs

Un serveur web en 6 lignes

La bibliothèque standard de Go inclut tout ce qu'il faut pour créer un serveur web. Pas besoin de framework externe :

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Bonjour depuis Go !")
    })
    http.ListenAndServe(":8080", nil)
}

Lancez avec go run main.go et ouvrez http://localhost:8080. Votre serveur est en ligne.

En Python, il faudrait Flask ou Django. En JavaScript, Express. En Go, la bibliothèque standard suffit. Et ce serveur gère chaque requête dans sa propre goroutine : concurrence gratuite.

Plusieurs routes

Ajoutez autant de routes que nécessaire avec http.HandleFunc :

func main() {
    http.HandleFunc("/", handleHome)
    http.HandleFunc("/api/health", handleHealth)
    http.HandleFunc("/api/users", handleUsers)

    fmt.Println("Serveur démarré sur :8080")
    http.ListenAndServe(":8080", nil)
}

func handleHome(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Page d'accueil")
}

func handleHealth(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    fmt.Fprintf(w, `{"status": "ok"}`)
}

func handleUsers(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    fmt.Fprintf(w, `[{"name": "Alice"}, {"name": "Bob"}]`)
}

Chaque handler reçoit deux paramètres :

• w http.ResponseWriter : pour écrire la réponse
• r *http.Request : la requête entrante (méthode, URL, body, headers)

JSON : encoding/json

Le package encoding/json convertit les structs Go en JSON et inversement :

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
    Age   int    `json:"age"`
}

// Struct → JSON (Marshal)
func handleGetUser(w http.ResponseWriter, r *http.Request) {
    user := User{Name: "Alice", Email: "alice@example.com", Age: 30}
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

// JSON → Struct (Unmarshal)
func handleCreateUser(w http.ResponseWriter, r *http.Request) {
    var user User
    err := json.NewDecoder(r.Body).Decode(&user)
    if err != nil {
        http.Error(w, "JSON invalide", http.StatusBadRequest)
        return
    }
    fmt.Fprintf(w, "Utilisateur créé : %s", user.Name)
}

Les tags `json:"name"` après chaque champ contrôlent le nom dans le JSON. Sans eux, Go utiliserait Name avec une majuscule.

{"name":"Alice","email":"alice@example.com","age":30}

Une API REST complète

Combinons tout pour créer une API de gestion de tâches :

type Task struct {
    ID    int    `json:"id"`
    Title string `json:"title"`
    Done  bool   `json:"done"`
}

var tasks = []Task{
    {ID: 1, Title: "Apprendre Go", Done: false},
    {ID: 2, Title: "Créer une API", Done: false},
}

func handleTasks(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")

    switch r.Method {
    case "GET":
        json.NewEncoder(w).Encode(tasks)
    case "POST":
        var task Task
        json.NewDecoder(r.Body).Decode(&task)
        task.ID = len(tasks) + 1
        tasks = append(tasks, task)
        w.WriteHeader(http.StatusCreated)
        json.NewEncoder(w).Encode(task)
    default:
        http.Error(w, "Méthode non autorisée", http.StatusMethodNotAllowed)
    }
}

Cette API gère GET /api/tasks pour lister et POST /api/tasks pour créer. Testez-la avec curl :

# Lister les tâches
curl http://localhost:8080/api/tasks

# Créer une tâche
curl -X POST -d '{"title":"Tester l'API"}' http://localhost:8080/api/tasks

À vous d'essayer (le serveur HTTP ne tourne pas ici, mais l'encodage JSON oui) :

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
    Age   int    `json:"age"`
}

func main() {
    user := User{Name: "Alice", Email: "alice@example.com", Age: 30}
    data, _ := json.Marshal(user)
    fmt.Println(string(data))
}