Wie man in 30 Minuten eine REST API in Go schreibt: Praxisnah

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Einführung: Warum Go die ideale Wahl für REST APIs ist

Go (Golang) ist eine kompilierte Programmiersprache, die bei Google für hochlastige Systeme entwickelt wurde. Sie kombiniert die Geschwindigkeit von C, die Einfachheit von Python und eine integrierte Unterstützung für Parallelität. Für die Erstellung von REST APIs bietet Go eine leistungsstarke Standardbibliothek net/http und beliebte Frameworks wie gorilla/mux und gin.

In diesem Leitfaden erstellen wir in 30 Minuten eine vollständige REST API zur Verwaltung einer Aufgabenliste (Todo List) in reinem Go ohne externe Frameworks. Sie lernen:

Routing und Handler einzurichten
Mit JSON zu arbeiten (Serialisierung/Deserialisierung)
CRUD-Operationen (Create, Read, Update, Delete) zu implementieren
Middleware für Logging und CORS hinzuzufügen

Der gesamte Code wird der Einfachheit halber in einer einzigen Datei main.go geschrieben. Los geht's!

Schritt 1: Grundlegende Struktur und Start des HTTP-Servers

Erstellen Sie eine Datei main.go und fügen Sie den folgenden Code hinzu. Wir deklarieren eine Datenstruktur für die Aufgabe und starten einen einfachen Server.

package main

import (    "encoding/json"    "log"    "net/http"    "strconv"    "strings"    "sync"    "time")

// Task — Aufgabenstrukturtype Task struct {    ID        int       `json:"id"`    Title     string    `json:"title"`    Completed bool      `json:"completed"`    CreatedAt time.Time `json:"created_at"`}

// Aufgabenspeicher (in-memory)var (    tasks   = make(map[int]Task)    nextID  = 1    mu      sync.Mutex)

func main() {    // Routen    http.HandleFunc("/api/tasks", tasksHandler)    http.HandleFunc("/api/tasks/", taskByIDHandler)

    log.Println("Server gestartet auf :8080")    log.Fatal(http.ListenAndServe(":8080", nil))}

Erklärung:

Task — Struktur mit JSON-Tags für korrekte Serialisierung.
tasks — Map zum Speichern von Aufgaben im Speicher (ohne Datenbank).
mu — Mutex für sicheren Zugriff aus Goroutinen.
Zwei Routen: /api/tasks (Liste und Erstellung) und /api/tasks/ (Arbeit mit einer einzelnen Aufgabe nach ID).

Schritt 2: Handler für die Aufgabenliste (GET und POST)

Wir implementieren die Funktion tasksHandler, die GET (Abrufen aller Aufgaben) und POST (Erstellen einer neuen Aufgabe) verarbeitet.

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

    switch r.Method {    case http.MethodGet:        mu.Lock()        taskList := make([]Task, 0, len(tasks))        for _, task := range tasks {            taskList = append(taskList, task)        }        mu.Unlock()        json.NewEncoder(w).Encode(taskList)

    case http.MethodPost:        var newTask Task        if err := json.NewDecoder(r.Body).Decode(&newTask); err != nil {            http.Error(w, `{"error":"Ungültiges JSON"}`, http.StatusBadRequest)            return        }        mu.Lock()        newTask.ID = nextID        nextID++        newTask.CreatedAt = time.Now()        tasks[newTask.ID] = newTask        mu.Unlock()

        w.WriteHeader(http.StatusCreated)        json.NewEncoder(w).Encode(newTask)

    default:        http.Error(w, `{"error":"Methode nicht unterstützt"}`, http.StatusMethodNotAllowed)    }}

Wichtige Punkte:

Wir verwenden json.NewEncoder und json.NewDecoder für die Arbeit mit JSON.
Bei POST prüfen wir die Gültigkeit von JSON, weisen eine ID zu und geben 201 Created zurück.
Der Mutex schützt die Daten bei gleichzeitigem Zugriff.