Heim >Backend-Entwicklung >Golang >Rest Full API – Golang (Best Practices)
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
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) } }
Behandeln Sie Fehler stets 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) }
Verwenden Sie Middleware für Protokollierung, Authentifizierung und andere übergreifende Belange.
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)
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) }
Verwenden Sie eine Datenbank, um Ihre Daten zu speichern. 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)) }
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") }) }
Stellen Sie sicher, dass Ihre API sicher ist, indem Sie HTTPS verwenden, Eingaben validieren und bereinigen und eine ordnungsgemäße Authentifizierung und Autorisierung implementieren.
Versionieren Sie Ihre API, um Änderungen zu verarbeiten, ohne bestehende Clients zu beschädigen. Dies kann durch Einschließen der Version in die URL erfolgen, z. B. /api/v1/users.
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.
Das obige ist der detaillierte Inhalt vonRest Full API – Golang (Best Practices). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!