Natuurlijk! Hier is een overzicht en een voorbeeld van hoe je een RESTful API in Go kunt ontwerpen en implementeren met de standaard `net/http` bibliotheek: 1. Endpoints definiëren: - Gebruik `http.HandleFunc()` om URL-paden te koppelen aan handler functies. - Elke handler fungeert als endpoint voor een specifieke resource of actie. 2. JSON payloads parsen en valideren: - Lees de HTTP request body met `json.NewDecoder()`. - Decodeer naar een struct die je hebt gedefinieerd. - Valideer de velden (bijvoorbeeld op leegte of formaat). 3. Antwoorden met JSON: - Stel de juiste headers in (`Content-Type: application/json`). - Gebruik `json.NewEncoder(w).Encode()` om JSON te sturen. ### Voorbeeld ```go package main import ( "encoding/json" "log" "net/http" ) // Defineer een struct voor de JSON payload type User struct { Naam string `json:"naam"` Email string `json:"email"` } // Handler voor het ontvangen van gebruikersgegevens func userHandler(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodPost { http.Error(w, "Method niet toegestaan", http.StatusMethodNotAllowed) return } // Parseer JSON payload var user User decoder := json.NewDecoder(r.Body) err := decoder.Decode(&user) if err != nil { http.Error(w, "Ongeldige JSON", http.StatusBadRequest) return } // Valideer data if user.Naam == "" || user.Email == "" { http.Error(w, "Naam en email zijn verplicht", http.StatusBadRequest) return } // Verwerk data (bijvoorbeeld opslaan in database) // ... // Stuur een JSON antwoord terug w.Header().Set("Content-Type", "application/json") response := map[string]string{ "status": "success", "bericht": "Gebruiker ontvangen", } json.NewEncoder(w).Encode(response) } func main() { // Defineer endpoint http.HandleFunc("/api/gebruiker", userHandler) // Start de server log.Println("Server gestart op :8080") err := http.ListenAndServe(":8080", nil) if err != nil { log.Fatal(err) } } ``` ### Samenvatting - **Endpoints definiëren:** met `http.HandleFunc()` en URL-paden. - **JSON parsen:** met `json.NewDecoder()` en `Decode()`. - **Valideren:** controleer verplichte velden en formaat. - **Antwoord sturen:** met `json.NewEncoder(w).Encode()` en juiste headers. Wil je hulp bij meer endpoints, authenticatie of geavanceerdere validatie?

Zeker, ik help je stap voor stap met het bouwen van een RESTful API in Go met het `net/http` package. ## 1. Basisopzet en HTTP Server ```go package main import ( "encoding/json" "log" "net/http" "strconv" "github.com/gorilla/mux" // Optioneel: voor routing ) type User struct { ID int `json:"id"` Name string `json:"name"` Email string `json:"email"` } var users []User func main() { // Basis routing met net/http http.HandleFunc("/users", usersHandler) http.HandleFunc("/users/", userHandler) log.Println("Server gestart op poort 8080") log.Fatal(http.ListenAndServe(":8080", nil)) } ``` ## 2. Endpoints Definiëren ### Basis endpoints zonder external packages: ```go func usersHandler(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") switch r.Method { case "GET": getUsers(w, r) case "POST": createUser(w, r) default: http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) } } func userHandler(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") switch r.Method { case "GET": getUser(w, r) case "PUT": updateUser(w, r) case "DELETE": deleteUser(w, r) default: http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) } } ``` ### Met gorilla/mux (aanbevolen voor betere routing): ```go import "github.com/gorilla/mux" func main() { router := mux.NewRouter() router.HandleFunc("/users", getUsers).Methods("GET") router.HandleFunc("/users", createUser).Methods("POST") router.HandleFunc("/users/{id}", getUser).Methods("GET") router.HandleFunc("/users/{id}", updateUser).Methods("PUT") router.HandleFunc("/users/{id}", deleteUser).Methods("DELETE") log.Fatal(http.ListenAndServe(":8080", router)) } ``` ## 3. JSON Parsen en Valideren ```go func createUser(w http.ResponseWriter, r *http.Request) { var user User // JSON body parsen decoder := json.NewDecoder(r.Body) if err := decoder.Decode(&user); err != nil { http.Error(w, "Ongeldig JSON formaat", http.StatusBadRequest) return } defer r.Body.Close() // Validatie if user.Name == "" { http.Error(w, "Naam is verplicht", http.StatusBadRequest) return } if user.Email == "" { http.Error(w, "Email is verplicht", http.StatusBadRequest) return } // Business logica user.ID = len(users) + 1 users = append(users, user) // Response sturen w.WriteHeader(http.StatusCreated) json.NewEncoder(w).Encode(user) } ``` ## 4. Complete CRUD Operations ```go func getUsers(w http.ResponseWriter, r *http.Request) { json.NewEncoder(w).Encode(users) } func getUser(w http.ResponseWriter, r *http.Request) { // ID uit URL halen id, err := strconv.Atoi(mux.Vars(r)["id"]) if err != nil { http.Error(w, "Ongeldig ID", http.StatusBadRequest) return } // User zoeken for _, user := range users { if user.ID == id { json.NewEncoder(w).Encode(user) return } } http.Error(w, "User niet gevonden", http.StatusNotFound) } func updateUser(w http.ResponseWriter, r *http.Request) { id, err := strconv.Atoi(mux.Vars(r)["id"]) if err != nil { http.Error(w, "Ongeldig ID", http.StatusBadRequest) return } var updatedUser User decoder := json.NewDecoder(r.Body) if err := decoder.Decode(&updatedUser); err != nil { http.Error(w, "Ongeldig JSON formaat", http.StatusBadRequest) return } defer r.Body.Close() // User zoeken en updaten for i, user := range users { if user.ID == id { users[i].Name = updatedUser.Name users[i].Email = updatedUser.Email json.NewEncoder(w).Encode(users[i]) return } } http.Error(w, "User niet gevonden", http.StatusNotFound) } func deleteUser(w http.ResponseWriter, r *http.Request) { id, err := strconv.Atoi(mux.Vars(r)["id"]) if err != nil { http.Error(w, "Ongeldig ID", http.StatusBadRequest) return } for i, user := range users { if user.ID == id { users = append(users[:i], users[i+1:]...) w.WriteHeader(http.StatusNoContent) return } } http.Error(w, "User niet gevonden", http.StatusNotFound) } ``` ## 5. Verbeterde Validatie met Custom Struct ```go type CreateUserRequest struct { Name string `json:"name" validate:"required,min=2"` Email string `json:"email" validate:"required,email"` } func validateUserRequest(w http.ResponseWriter, r *http.Request) (*CreateUserRequest, error) { var req CreateUserRequest decoder := json.NewDecoder(r.Body) if err := decoder.Decode(&req); err != nil { return nil, err } defer r.Body.Close() // Simpele validatie if req.Name == "" || len(req.Name) < 2 { return nil, fmt.Errorf("Naam moet minimaal 2 karakters bevatten") } if req.Email == "" || !strings.Contains(req.Email, "@") { return nil, fmt.Errorf("Ongeldig email formaat") } return &req, nil } ``` ## 6. Middleware voor Error Handling ```go func jsonResponse(next http.HandlerFunc) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") next(w, r) } } func main() { router := mux.NewRouter() // Middleware toepassen router.HandleFunc("/users", jsonResponse(getUsers)).Methods("GET") router.HandleFunc("/users", jsonResponse(createUser)).Methods("POST") log.Fatal(http.ListenAndServe(":8080", router)) } ``` ## 7. go.mod Bestand ```mod module mijn-api go 1.21 require github.com/gorilla/mux v1.8.0 ``` ## Gebruiksvoorbeeld: **POST /users** ```json { "name": "Jan Jansen", "email": "jan@voorbeeld.nl" } ``` **Response:** ```json { "id": 1, "name": "Jan Jansen", "email": "jan@voorbeeld.nl" } ``` Dit geeft je een solide basis voor een RESTful API in Go. Voor productie gebruik zou je overwegen: - Database integratie (PostgreSQL, MySQL) - JWT authenticatie - Betere validatie library (zoals go-playground/validator) - Logging middleware - Error handling verbeteringen