1. Projektstruktur

Organisieren Sie Ihren Code so, dass er leicht zu verstehen und zu erweitern ist. Eine übliche Struktur umfasst die Aufteilung Ihres Codes in Ordner wie Modelle, Handler, Routen, Middlewares, Dienstprogramme und Konfiguration.

Beispielstruktur:

go-rest-api/
|-- main.go
|-- config/
|   |-- config.go
|-- handlers/
|   |-- user.go
|-- models/
|   |-- user.go
|-- routes/
|   |-- routes.go
|-- middlewares/
|   |-- logging.go
|-- utils/
|   |-- helpers.go

2. Umgebungskonfiguration

Speichern Sie Konfigurationseinstellungen (wie Datenbankanmeldeinformationen, Portnummern usw.) in Umgebungsvariablen oder Konfigurationsdateien. Verwenden Sie ein Paket wie viper, um Konfigurationen zu verwalten.

config/config.go:

package config

import (
    "github.com/spf13/viper"
    "log"
)

type Config struct {
    Port string
    DB   struct {
        Host     string
        Port     string
        User     string
        Password string
        Name     string
    }
}

var AppConfig Config

func LoadConfig() {
    viper.SetConfigName("config")
    viper.AddConfigPath(".")
    viper.AutomaticEnv()

    if err := viper.ReadInConfig(); err != nil {
        log.Fatalf("Error reading config file, %s", err)
    }

    err := viper.Unmarshal(&AppConfig)
    if err != nil {
        log.Fatalf("Unable to decode into struct, %v", err)
    }
}

3. Fehlerbehandlung

Behandeln Sie Fehler immer angemessen. Geben Sie aussagekräftige Fehlermeldungen und HTTP-Statuscodes zurück.

handlers/user.go:

func GetUserHandler(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    id, err := strconv.Atoi(params["id"])
    if err != nil {
        http.Error(w, "Invalid user ID", http.StatusBadRequest)
        return
    }

    user, err := findUserByID(id)
    if err != nil {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

4. Middleware

Verwenden Sie Middleware für Protokollierung, Authentifizierung und andere übergreifende Anliegen.

middlewares/logging.go:

package middlewares

import (
    "log"
    "net/http"
    "time"
)

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %s", r.Method, r.RequestURI, time.Since(start))
    })
}

In main.go oderroutes/routes.go:

r.Use(middlewares.LoggingMiddleware)

5. JSON-Handhabung

Verwenden Sie die richtige JSON-Kodierung und -Dekodierung. Validieren Sie eingehende JSON-Daten, um sicherzustellen, dass sie der erwarteten Struktur entsprechen.

handlers/user.go:

func CreateUserHandler(w http.ResponseWriter, r *http.Request) {
    var user models.User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, "Invalid input", http.StatusBadRequest)
        return
    }

    // Validate user data...

    users = append(users, user)

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

6. Datenbankzugriff

Verwenden Sie eine Datenbank zum Speichern Ihrer Daten. Verwenden Sie ein Paket wie gorm für ORM oder sqlx für unformatierte SQL-Abfragen.

models/user.go:

package models

import "gorm.io/gorm"

type User struct {
    gorm.Model
    Name  string `json:"name"`
    Email string `json:"email"`
}

main.go:

package main

import (
    "github.com/yourusername/go-rest-api/config"
    "github.com/yourusername/go-rest-api/routes"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
    "log"
    "net/http"
)

func main() {
    config.LoadConfig()

    dsn := "host="   config.AppConfig.DB.Host  
        " user="   config.AppConfig.DB.User  
        " password="   config.AppConfig.DB.Password  
        " dbname="   config.AppConfig.DB.Name  
        " port="   config.AppConfig.DB.Port  
        " sslmode=disable"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatalf("Could not connect to the database: %v", err)
    }

    r := routes.NewRouter(db)

    log.Println("Starting server on port", config.AppConfig.Port)
    log.Fatal(http.ListenAndServe(":" config.AppConfig.Port, r))
}

7. Protokollierung

Verwenden Sie eine strukturierte Protokollierungsbibliothek wie Logrus oder Zap für eine bessere Protokollierung.

middlewares/logging.go:

package middlewares

import (
    "github.com/sirupsen/logrus"
    "net/http"
    "time"
)

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        logrus.WithFields(logrus.Fields{
            "method": r.Method,
            "url":    r.URL.Path,
            "time":   time.Since(start),
        }).Info("handled request")
    })
}

8. Sicherheit

Stellen Sie sicher, dass Ihre API sicher ist, indem Sie HTTPS verwenden, Eingaben validieren und bereinigen und eine ordnungsgemäße Authentifizierung und Autorisierung implementieren.

9. Versionierung

Versionieren Sie Ihre API, um Änderungen zu verarbeiten, ohne bestehende Clients zu beschädigen. Dies kann durch Einfügen der Version in die URL erfolgen, z. B. /api/v1/users.

10. Dokumentation

Dokumentieren Sie Ihre API mit Tools wie Swagger oder Postman, um klare Nutzungsanweisungen für Entwickler bereitzustellen.

Indem Sie diese Best Practices befolgen, können Sie eine robuste, wartbare und skalierbare RESTful-API in Go erstellen.