Créer des API RESTful avec Go

Bienvenue dans la deuxième partie de notre série Ingénierie backend pour les développeurs Full Stack ! ? Aujourd'hui, nous abordons l'un des sujets les plus fondamentaux : Créer des API RESTful avec Go. Que vous construisiez un outil interne ou une API publique, il est essentiel de comprendre comment structurer et implémenter des points de terminaison RESTful.

Dans cet article, nous aborderons :

• Qu'est-ce qui rend une API RESTful (et pourquoi c'est important).
• Comment concevoir des points de terminaison et gérer les méthodes HTTP.
• Création d'une API CRUD simple avec le package net/http de Go et Gorilla Mux.
• Gestion des demandes et réponses JSON.

À la fin, vous saurez parfaitement comment concevoir et implémenter des API RESTful évolutives dans Go. Commençons ! ?

Qu'est-ce qui rend une API RESTful ? ?

Avant de plonger dans le code, examinons rapidement ce qui constitue une API RESTful. REST (Representational State Transfer) est un style architectural permettant de créer des API qui suivent ces principes :

1. Apatride : Chaque demande du client doit contenir toutes les informations nécessaires à son traitement. Le serveur ne stocke pas les informations de session.
2. Orienté ressources : les URL représentent des ressources, comme /users, /products ou /orders, et les méthodes HTTP définissent les actions.
3. Méthodes HTTP : les API RESTful utilisent des méthodes HTTP pour spécifier des actions :
   • GET : Récupérer des données.
   • POST : Créez de nouvelles ressources.
   • PUT : Mettre à jour les ressources existantes.
   • SUPPRIMER : supprimer des ressources.
4. Utilisation des codes d'état HTTP : les API RESTful font bon usage des codes d'état HTTP (200 pour succès, 404 pour introuvable, etc.).

Configuration de votre projet Go

Créons une API CRUD de base pour gérer les utilisateurs utilisant Go et le routeur Gorilla Mux. Notre API aura les points de terminaison suivants :

Schritt 1: Abhängigkeiten installieren

Installieren Sie zunächst den Gorilla Mux-Router für das Routing:

go get -u github.com/gorilla/mux

Erstellen Sie zunächst eine einfache main.go-Datei:

package main

import (
    "log"
    "net/http"
    "github.com/gorilla/mux"
)

func main() {
    r := mux.NewRouter()

    // Define routes here
    http.Handle("/", r)

    log.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Schritt 2: Definieren Sie die Handler

Jetzt definieren wir unsere API-Handler. Diese werden unseren CRUD-Aktionen entsprechen. Für dieses Beispiel verwenden wir eine einfache In-Memory-Map zum Speichern von Benutzerdaten.

In-Memory-Datenspeicher

type User struct {
    ID   string `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age"`
}

var users = make(map[string]User)

Schritt 3: Implementieren Sie CRUD-Handler

Wir implementieren jede CRUD-Operation: Erstellen, Lesen, Aktualisieren und Löschen Benutzer.

GET /users – Alle Benutzer abrufen

func getUsers(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    var userList []User
    for _, user := range users {
        userList = append(userList, user)
    }
    json.NewEncoder(w).Encode(userList)
}

GET /users/{id} – Einen bestimmten Benutzer abrufen

func getUser(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    user, found := users[params["id"]]
    if !found {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

POST /users – Erstellen Sie einen neuen Benutzer

func createUser(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    var user User
    _ = json.NewDecoder(r.Body).Decode(&user)
    users[user.ID] = user
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

PUT /users/{id} – Einen vorhandenen Benutzer aktualisieren

func updateUser(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    user, found := users[params["id"]]
    if !found {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }
    _ = json.NewDecoder(r.Body).Decode(&user)
    user.ID = params["id"]  // Ensure the ID stays the same
    users[params["id"]] = user
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

DELETE /users/{id} – Einen Benutzer löschen

func deleteUser(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    _, found := users[params["id"]]
    if !found {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }
    delete(users, params["id"])
    w.WriteHeader(http.StatusNoContent)
}

Schritt 4: Routen registrieren

Da wir nun unsere Handler definiert haben, fügen wir die Routen zu unserem Router in der Hauptfunktion hinzu:

func main() {
    r := mux.NewRouter()

    r.HandleFunc("/users", getUsers).Methods("GET")
    r.HandleFunc("/users/{id}", getUser).Methods("GET")
    r.HandleFunc("/users", createUser).Methods("POST")
    r.HandleFunc("/users/{id}", updateUser).Methods("PUT")
    r.HandleFunc("/users/{id}", deleteUser).Methods("DELETE")

    http.Handle("/", r)

    log.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Schritt 5: Testen der API

Sie können Ihre API mit Postman oder Curl-Befehlen testen. So können Sie einen neuen Benutzer erstellen und Benutzer abrufen:

1. Neuen Benutzer erstellen:

   curl -X POST http://localhost:8080/users \
   -H "Content-Type: application/json" \
   -d '{"id":"1", "name":"John Doe", "age":30}'

1. Alle Benutzer abrufen:

   curl -X GET http://localhost:8080/users

1. Suchen Sie einen bestimmten Benutzer:

   curl -X GET http://localhost:8080/users/1

1. Benutzer aktualisieren:

   curl -X PUT http://localhost:8080/users/1 \
   -H "Content-Type: application/json" \
   -d '{"name":"John Smith", "age":31}'

1. Benutzer löschen:

   curl -X DELETE http://localhost:8080/users/1

Best Practices zum Erstellen von RESTful-APIs

1. Verwenden Sie die richtigen HTTP-Methoden: Befolgen Sie die RESTful-Prinzipien, indem Sie GET zum Lesen, POST zum Erstellen, PUT zum Aktualisieren und DELETE zum Löschen verwenden.
2. Geeignete Statuscodes zurückgeben: Verwenden Sie immer die richtigen HTTP-Statuscodes (z. B. 201 Erstellt für erfolgreiche Ressourcenerstellung, 404 Nicht gefunden für fehlende Ressourcen).
3. Gehen Sie ordnungsgemäß mit Fehlern um: Machen Sie den Benutzern keine internen Fehler zugänglich. Verwenden Sie allgemeine Nachrichten wie „Benutzer nicht gefunden“ oder „Ungültige Anfrage“.
4. Verwenden Sie Paginierung für große Datensätze: Wenn Sie große Listen (wie /users) zurückgeben, implementieren Sie Paginierung, um ein übermäßiges Laden von Daten zu verhindern.
5. Sichern Sie Ihre API: Verwenden Sie Authentifizierungsmethoden wie JWT oder OAuth2, um sensible Endpunkte zu sichern.

Was kommt als nächstes?

Da wir nun eine grundlegende RESTful-API erstellt haben, ist es an der Zeit, Datenbankunterstützung zu integrieren, damit wir unsere Daten beibehalten können. Im nächsten Beitrag werden wir uns mit der Verwendung eines ORM befassen, um unsere Go-API mit einer Datenbank zu verbinden. Seien Sie gespannt auf Teil 3! ?

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!