Het opzetten van een robuuste gegevensvalidatielaag in je Go-toepassing is essentieel om invoer nauwkeurig en veilig te maken. Hier volgt een gestructureerde aanpak inclusief strategieën en praktische tips, toegespitst op e-mailadressen zoals gebruiker@voorbeeld.com: 1. Scheid validatie van businesslogica - Creëer een aparte validatielaag of -pakket dat zich uitsluitend bezighoudt met invoercontrole. - Zorg dat deze laag onafhankelijk is van de kernfunctionaliteit, zodat je deze eenvoudig kunt testen en hergebruiken. 2. Gebruik bestaande validatiebibliotheken - Maak gebruik van betrouwbare libraries zoals [go-playground/validator](https://github.com/go-playground/validator) voor veelvoorkomende validaties. - Voor e-mailadressen kun je bijvoorbeeld de ingebouwde validator gebruiken of regexen. 3. Valideer verschillende gegevens types - **E-mailadressen**: - Gebruik een regex of de validator's email-tag, bijvoorbeeld: ```go validate := validator.New() err := validate.Var(email, "required,email") ``` - Of met regex: ```go var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`) if !emailRegex.MatchString(email) { // Fout afhandelen } ``` - **Andere types**: - Numeriek: controleer op bereik, type - Tekst: lengte, verboden tekens - Datum: formaat, logisch (bijv. niet in de toekomst) 4. Graceful foutafhandeling - Geef duidelijke foutmeldingen terug naar de gebruiker, zonder dat technische details worden blootgesteld. - Log fouten voor debugging, maar houd gebruikersinterface vriendelijk. - Voorbeeld: ```go if err != nil { return fmt.Errorf("Ongeldig e-mailadres: %v", err) } ``` 5. Integratie met bestaande code - Valideer invoer direct bij het ontvangen (bijvoorbeeld in API-handlers). - Gebruik middleware of wrappers om validatie centraal te regelen. - Maak gebruik van struct tags voor automatische validatie, bijvoorbeeld: ```go type Gebruiker struct { Email string `validate:"required,email"` } ``` - Valideer de struct met: ```go var gebruiker Gebruiker err := validator.New().Struct(&gebruiker) if err != nil { // Fouten afhandelen } ``` 6. Aanvullende strategieën - **Sanitatie**: verwijder of escaleer gevaarlijke tekens. - **Rate limiting**: voorkom brute-force aanvallen. - **Validatie op serverzijde**: vertrouw niet op client-side validatie alleen. Kort samengevat: - Scheid validatie van core-logica - Gebruik betrouwbare libraries en regexen - Geef duidelijke, vriendelijke foutmeldingen - Valideer direct na invoer, gebruik struct tags en middleware - Combineer validatie met sanitatie en beveiligingsmaatregelen Door deze aanpak zorg je dat gebruikersinvoer correct, veilig en consistent wordt verwerkt in je Go-toepassing.

Hier is een uitgebreide uitleg voor het bouwen van een robuuste gegevensvalidatielaag in Go: ## 1. Basisstructuur en Package Organisatie ```go // validatie/validatie.go package validatie import ( "net/mail" "regexp" "strings" "unicode" ) // Validator interface voor herbruikbaarheid type Validator interface { Validate() error } // Foutafhandeling type ValidatieFout struct { Veld string `json:"veld"` Bericht string `json:"bericht"` Code string `json:"code"` } func (v ValidatieFout) Error() string { return v.Veld + ": " + v.Bericht } ``` ## 2. Email Validatie Implementatie ```go // validatie/email.go package validatie import ( "errors" "net/mail" "regexp" "strings" ) type Email string func (e Email) Validate() error { email := strings.TrimSpace(string(e)) if email == "" { return ValidatieFout{ Veld: "email", Bericht: "Email is verplicht", Code: "EMAIL_VERPLICHT", } } // Basis email formaat validatie if len(email) > 254 { return ValidatieFout{ Veld: "email", Bericht: "Email mag niet langer zijn dan 254 karakters", Code: "EMAIL_TE_LANG", } } // Gebruik Go's ingebouwde email parser addr, err := mail.ParseAddress(email) if err != nil { return ValidatieFout{ Veld: "email", Bericht: "Ongeldig email formaat", Code: "EMAIL_FORMAT", } } // DNS validatie voor domein if !valideerEmailDomein(addr.Address) { return ValidatieFout{ Veld: "email", Bericht: "Email domein is niet geldig", Code: "EMAIL_DOMEIN", } } return nil } func valideerEmailDomein(email string) bool { delen := strings.Split(email, "@") if len(delen) != 2 { return false } domein := delen[1] // Simpele domein validatie - in productie zou je DNS lookups doen domeinRegex := regexp.MustCompile(`^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`) return domeinRegex.MatchString(domein) } ``` ## 3. Gebruikersinput Struct met Validatie ```go // models/gebruiker.go package models import ( "your-app/validatie" "time" ) type GebruikerInput struct { Email string `json:"email" binding:"required"` Naam string `json:"naam" binding:"required"` Leeftijd int `json:"leeftijd"` Geboortedatum time.Time `json:"geboortedatum"` } func (g GebruikerInput) Validate() error { // Email validatie if err := validatie.Email(g.Email).Validate(); err != nil { return err } // Naam validatie if strings.TrimSpace(g.Naam) == "" { return validatie.ValidatieFout{ Veld: "naam", Bericht: "Naam is verplicht", Code: "NAAM_VERPLICHT", } } if len(g.Naam) > 100 { return validatie.ValidatieFout{ Veld: "naam", Bericht: "Naam mag niet langer zijn dan 100 karakters", Code: "NAAM_TE_LANG", } } // Leeftijd validatie if g.Leeftijd < 0 || g.Leeftijd > 150 { return validatie.ValidatieFout{ Veld: "leeftijd", Bericht: "Leeftijd moet tussen 0 en 150 zijn", Code: "LEEFTIJD_ONGELDIG", } } return nil } ``` ## 4. HTTP Handler met Graceful Error Afhandeling ```go // handlers/gebruiker.go package handlers import ( "encoding/json" "net/http" "your-app/models" "your-app/validatie" ) type Response struct { Success bool `json:"success"` Data interface{} `json:"data,omitempty"` Fouten []validatie.ValidatieFout `json:"fouten,omitempty"` Bericht string `json:"bericht,omitempty"` } func RegistreerGebruikerHandler(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") var input models.GebruikerInput // JSON parsing if err := json.NewDecoder(r.Body).Decode(&input); err != nil { w.WriteHeader(http.StatusBadRequest) json.NewEncoder(w).Encode(Response{ Success: false, Bericht: "Ongeldig JSON formaat", }) return } // Validatie if err := input.Validate(); err != nil { w.WriteHeader(http.StatusUnprocessableEntity) // Type assertion voor validatiefouten if validatieFout, ok := err.(validatie.ValidatieFout); ok { json.NewEncoder(w).Encode(Response{ Success: false, Fouten: []validatie.ValidatieFout{validatieFout}, }) } else { json.NewEncoder(w).Encode(Response{ Success: false, Bericht: err.Error(), }) } return } // Verwerk succesvolle input w.WriteHeader(http.StatusCreated) json.NewEncoder(w).Encode(Response{ Success: true, Bericht: "Gebruiker succesvol geregistreerd", Data: input, }) } ``` ## 5. Geavanceerde Validatie Helpers ```go // validatie/helpers.go package validatie import ( "net/url" "regexp" "strings" "unicode/utf8" ) // String validatie func ValideerString(waarde, veldnaam string, min, max int, verplicht bool) error { trimmed := strings.TrimSpace(waarde) if verplicht && trimmed == "" { return ValidatieFout{ Veld: veldnaam, Bericht: veldnaam + " is verplicht", Code: strings.ToUpper(veldnaam) + "_VERPLICHT", } } if utf8.RuneCountInString(trimmed) < min { return ValidatieFout{ Veld: veldnaam, Bericht: veldnaam + " moet minimaal " + string(min) + " karakters bevatten", Code: strings.ToUpper(veldnaam) + "_TE_KORT", } } if utf8.RuneCountInString(trimmed) > max { return ValidatieFout{ Veld: veldnaam, Bericht: veldnaam + " mag niet langer zijn dan " + string(max) + " karakters", Code: strings.ToUpper(veldnaam) + "_TE_LANG", } } return nil } // URL validatie func ValideerURL(waarde, veldnaam string) error { if waarde == "" { return nil // Optioneel veld } u, err := url.Parse(waarde) if err != nil || u.Scheme == "" || u.Host == "" { return ValidatieFout{ Veld: veldnaam, Bericht: "Ongeldige URL", Code: "URL_ONGELDIG", } } return nil } ``` ## 6. Middleware voor Input Sanitisatie ```go // middleware/sanitisatie.go package middleware import ( "net/http" "strings" "unicode" ) func SanitisatieMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { // Sanitiseer query parameters query := r.URL.Query() for key, values := range query { for i, value := range values { query[key][i] = strings.TrimSpace(value) } } r.URL.RawQuery = query.Encode() next.ServeHTTP(w, r) }) } // Helper functie voor string sanitisatie func SanitiseerString(s string) string { return strings.Map(func(r rune) rune { if unicode.IsControl(r) && r != '\n' && r != '\t' { return -1 } return r }, strings.TrimSpace(s)) } ``` ## 7. Gebruik in Bestaande Code ```go // main.go package main import ( "log" "net/http" "your-app/handlers" "your-app/middleware" ) func main() { mux := http.NewServeMux() // Routes mux.HandleFunc("/gebruiker/registreer", handlers.RegistreerGebruikerHandler) // Middleware chain handler := middleware.SanitisatieMiddleware(mux) log.Println("Server gestart op :8080") log.Fatal(http.ListenAndServe(":8080", handler)) } ``` ## Belangrijkste Strategieën: 1. **Layered Validatie**: Begin met syntactische validatie, dan semantische 2. **Consistente Error Handling**: Gebruik gestandaardiseerde foutstructuren 3. **Input Sanitisatie**: Verwijder onnodige whitespace en control characters 4. **Defensief Programmeren**: Ga uit van ongeldige input 5. **Herbruikbare Validators**: Maak generieke validatiecomponenten 6. **Duidelijke Foutmeldingen**: Geef specifieke, actiegerichte foutberichten Deze aanpak zorgt voor een veilige, onderhoudbare en gebruiksvriendelijke validatielaag die eenvoudig is uit te breiden met nieuwe validatieregels.