Von Monolith zu Modularität: Refactoring von Go Webanwendungen

Einleitung

In der dynamischen Welt der Go-Entwicklung ist es üblich, dass ein Projekt mit einer einfachen Struktur beginnt, die oft um eine einzige main.go-Datei herum aufgebaut ist. Dieser Ansatz bietet schnelles Prototyping und zügige Entwicklungszyklen, insbesondere für kleinere Anwendungen. Wenn sich diese Projekte jedoch weiterentwickeln, an Komplexität gewinnen und mehr Funktionen und Mitwirkende anziehen, verwandelt sich diese anfängliche Einfachheit oft in einen erheblichen Engpass. Eine ausufernde main.go-Datei wird schwer zu navigieren, schwierig zu debuggen und fast unmöglich effizient zu skalieren oder zu warten. Diese Situation ist nicht nur ein ästhetisches Problem; sie beeinträchtigt direkt die Produktivität der Entwickler, führt zu technischen Schulden und behindert zukünftiges Wachstum. Dieser Artikel führt Sie durch den Prozess des Zerlegens einer solchen monolithischen Struktur und des Wiederaufbaus in ein modulares, wartbares Go-Webprojekt, um sein volles Potenzial auszuschöpfen.

Dekonstruktion des Monolithen

Bevor wir uns dem Refactoring-Prozess widmen, wollen wir ein gemeinsames Verständnis der Kernkonzepte entwickeln, die unseren Modularisierungsbemühungen zugrunde liegen.

Kernkonzepte

• Monolithische Anwendung: Eine Anwendung, bei der alle Komponenten (UI, Geschäftslogik, Datenzugriff) eng miteinander verknüpft sind und als eine einzige, unteilbare Einheit bereitgestellt werden. Obwohl sie einfach zu starten ist, leidet sie unter schlechter Skalierbarkeit, schwieriger Wartung und hoher Kopplung, wenn sie wächst.
• Modulare Anwendung: Eine Anwendung, die in verschiedene, unabhängige Module oder Pakete unterteilt ist, die jeweils für eine bestimmte Funktionalität verantwortlich sind. Diese Module kommunizieren über klar definierte Schnittstellen, wodurch die Kopplung reduziert und die Wartbarkeit verbessert wird.
• Paket (Go): Go's grundlegende Einheit der Codeorganisation. Pakete kapseln zugehörige Funktionalitäten, ermöglichen Code-Wiederverwendung und fördern eine klare Trennung der Zuständigkeiten.
• Schichtenarchitektur: Ein Strukturmuster, bei dem eine Anwendung in verschiedene Schichten unterteilt ist, die jeweils eine bestimmte Rolle spielen. Übliche Schichten sind Präsentation (HTTP-Handler), Service (Geschäftslogik) und Repository (Datenzugriff). Dies fördert die Trennung der Zuständigkeiten und verbessert die Testbarkeit.
• Dependency Injection (DI): Eine Technik, bei der Abhängigkeiten (z. B. eine Datenbankverbindung) einer Komponente bereitgestellt werden, anstatt dass die Komponente sie selbst erstellt. Dies reduziert die Kopplung, macht Komponenten unabhängiger und vereinfacht das Testen.

Die Schmerzpunkte einer einzelnen main.go

Eine typische main.go in einem wachsenden Projekt könnte ungefähr so aussehen:

// main.go (Vor dem Refactoring)
package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	_ "github.com/go-sql-driver/mysql" // Beispiel Datenbanktreiber
)

// User repräsentiert einen Benutzer im System
type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
	Email string `json:"email"`
}

var db *sql.DB

func initDB() {
	var err error
	db, err = sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database")
	if err != nil {
		log.Fatalf("Fehler beim Öffnen der Datenbank: %v", err)
	}
	if err = db.Ping(); err != nil {
		log.Fatalf("Fehler beim Verbinden mit der Datenbank: %v", err)
	}
	fmt.Println("Erfolgreich mit der Datenbank verbunden!")
}

func createUserHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		http.Error(w, "Methode nicht erlaubt", http.StatusMethodNotAllowed)
		return
	}

	var user User
	err := json.NewDecoder(r.Body).Decode(&user)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	stmt, err := db.Prepare("INSERT INTO users(name, email) VALUES(?,?)")
	if err != nil {
		http.Error(w, "Interner Serverfehler", http.StatusInternalServerError)
		log.Printf("Fehler beim Vorbereiten der Anweisung: %v", err)
		return
	}
	defer stmt.Close()

	result, err := stmt.Exec(user.Name, user.Email)
	if err != nil {
		http.Error(w, "Interner Serverfehler", http.StatusInternalServerError)
		log.Printf("Fehler beim Ausführen der Anweisung: %v", err)
		return
	}

	id, _ := result.LastInsertId()
	user.ID = int(id)

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

func getUsersHandler(w http.ResponseWriter, r *http.Request) {

rows, err := db.Query("SELECT id, name, email FROM users")
	if err != nil {
		http.Error(w, "Interner Serverfehler", http.StatusInternalServerError)
		log.Printf("Fehler beim Abfragen von Benutzern: %v", err)
		return
	}
	defer rows.Close()

	var users []User
	for rows.Next() {
		var u User
		if err := rows.Scan(&u.ID, &u.Name, &u.Email); err != nil {
			http.Error(w, "Interner Serverfehler", http.StatusInternalServerError)
			log.Printf("Fehler beim Scannen des Benutzers: %v", err)
			return
		}
		users = append(users, u)
	}

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

func main() {
	initDB()
	defer db.Close()

	http.HandleFunc("/users", getUsersHandler)
	http.HandleFunc("/users/create", createUserHandler)

	fmt.Println("Server läuft auf :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

Dieses einfache Beispiel zeigt bereits mehrere Probleme:

1. Enge Kopplung: Handler interagieren direkt mit der Datenbank.
2. Fehlende Wiederverwendbarkeit: Datenbanklogik, Geschäftslogik und HTTP-Handling sind vermischt.
3. Schwierige Testbarkeit: Das Testen einzelner Komponenten (z. B. nur der Datenlogik) ist schwierig, ohne auch HTTP-Server einzurichten.
4. Schlechte Skalierbarkeit: Das Hinzufügen neuer Funktionen wird zu einem Spiel, bei dem man Platz in main.go finden muss, und führt zu potenziellen Regressionen.

Refactoring zu einer modularen Struktur

Lassen Sie uns dies in eine besser strukturierte Anwendung refactoren. Wir streben eine Schichtenarchitektur an: handler (Präsentation), service (Geschäftslogik) und repository (Datenzugriff).

Schritt 1: Definition der Anwendungsstruktur

Ein guter Ausgangspunkt ist die Festlegung einer klaren Verzeichnisstruktur:

├── cmd/
│   └── api/
│       └── main.go           // Einstiegspunkt für die API
├── internal/
│   ├── config/
│   │   └── config.go         // Anwendungskonfiguration
│   ├── models/
│   │   └── user.go           // Datenstrukturen (z.B. User-Struktur)
│   ├── repository/
│   │   └── user_repository.go // Datenzugriffslogik für Benutzer
│   ├── service/
│   │   └── user_service.go   // Geschäftslogik für Benutzer
│   └── handler/
│       └── user_handler.go   // HTTP-Anfragehandler für Benutzer
└── go.mod
└── go.sum

• cmd/api: Enthält den Haupteinstiegspunkt für unsere Web-API.
• internal/: Beherbergt den gesamten anwendungsspezifischen Code, der nicht öffentlich von anderen Anwendungen importiert werden sollte.
  • config/: Verwaltet die Anwendungskonfiguration.
  • models/: Definiert Datenstrukturen.
  • repository/: Abstrahiert die Datenspeicherung und -abfrage.
  • service/: Implementiert die Geschäftslogik.
  • handler/: Enthält HTTP-Anfragehandler.

Schritt 2: Extrahieren von Modellen (internal/models/user.go)

Zuerst verschieben wir unsere User-Struktur in ihr eigenes models-Paket.

// internal/models/user.go
package models

// User repräsentiert einen Benutzer im System
type User struct {
	ID    int    `json:"id"`
	Name string `json:"name"`
	Email string `json:"email"`
}

Schritt 3: Abstrahieren der Datenbankkonfiguration (internal/config/config.go)

Es ist eine gute Praxis, die Konfiguration zu zentralisieren.

// internal/config/config.go
package config

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/go-sql-driver/mysql" // Beispiel Datenbanktreiber
)

// DBConfig enthält Details zur Datenbankverbindung
type DBConfig struct {
	User     string
	Password string
	Host     string
	Port     string
	Database string
}

// NewDBConfig erstellt eine neue Standard-Datenbankkonfiguration
func NewDBConfig() DBConfig {
	return DBConfig{
		User:     "user",
		Password: "password",
		Host:     "127.0.0.1",
		Port:     "3306",
		Database: "database",
	}
}

// InitDatabase initialisiert und gibt einen Datenbankverbindungspool zurück
func InitDatabase(cfg DBConfig) (*sql.DB, error) {
	connStr := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s", cfg.User, cfg.Password, cfg.Host, cfg.Port, cfg.Database)
	db, err := sql.Open("mysql", connStr)
	if err != nil {
		return nil, fmt.Errorf("Fehler beim Öffnen der Datenbank: %w", err)
	}
	if err = db.Ping(); err != nil {
		return nil, fmt.Errorf("Fehler beim Verbinden mit der Datenbank: %w", err)
	}
	log.Println("Erfolgreich mit der Datenbank verbunden!")
	return db, nil
}

Schritt 4: Implementieren der Repository-Schicht (internal/repository/user_repository.go)

Das Repository kümmert sich um alle Datenbankinteraktionen für User-Objekte. Es definiert eine Schnittstelle zur Abstraktion des Speicherungsmechanismus.

// internal/repository/user_repository.go
package repository

import (
	"database/sql"
	"fmt"

	"your_module_name/internal/models" // Ersetzen Sie your_module_name
)

// UserRepository definiert die Schnittstelle für Benutzerdatenoperationen
type UserRepository interface {
	CreateUser(user *models.User) (*models.User, error)
	GetUsers() ([]models.User, error)
}

// MySQLUserRepository implementiert UserRepository für MySQL
type MySQLUserRepository struct {
	db *sql.DB
}

// NewMySQLUserRepository erstellt ein neues MySQLUserRepository
func NewMySQLUserRepository(db *sql.DB) *MySQLUserRepository {
	return &MySQLUserRepository{db: db}
}

// CreateUser fügt einen neuen Benutzer in die Datenbank ein
func (r *MySQLUserRepository) CreateUser(user *models.User) (*models.User, error) {
	stmt, err := r.db.Prepare("INSERT INTO users(name, email) VALUES(?,?)")
	if err != nil {
		return nil, fmt.Errorf("Fehler beim Vorbereiten der Anweisung: %w", err)
	}
	defer stmt.Close()

	result, err := stmt.Exec(user.Name, user.Email)
	if err != nil {
		return nil, fmt.Errorf("Fehler beim Ausführen der Anweisung: %w", err)
	}

	id, _ := result.LastInsertId()
	user.ID = int(id)
	return user, nil
}

// GetUsers ruft alle Benutzer aus der Datenbank ab
func (r *MySQLUserRepository) GetUsers() ([]models.User, error) {

rows, err := r.db.Query("SELECT id, name, email FROM users")
	if err != nil {
		return nil, fmt.Errorf("Fehler beim Abfragen von Benutzern: %w", err)
	}
	defer rows.Close()

	var users []models.User
	for rows.Next() {
		var u models.User
		if err := rows.Scan(&u.ID, &u.Name, &u.Email); err != nil {
			return nil, fmt.Errorf("Fehler beim Scannen des Benutzers: %w", err)
		}
		users = append(users, u)
	}
	return users, nil
}

Schritt 5: Implementieren der Service-Schicht (internal/service/user_service.go)

Die Service-Schicht enthält die Geschäftslogik der Anwendung. Sie orchestriert Interaktionen zwischen Handlern und Repositories.

// internal/service/user_service.go
package service

import (
	"fmt"

	"your_module_name/internal/models"      // Ersetzen Sie your_module_name
	"your_module_name/internal/repository" // Ersetzen Sie your_module_name
)

// UserService definiert die Schnittstelle für benutzerbezogene Geschäftslogik
type UserService interface {
	CreateUser(name, email string) (*models.User, error)
	GetAllUsers() ([]models.User, error)
}

// UserServiceImpl implementiert UserService
type UserServiceImpl struct {
	userRepo repository.UserRepository
}

// NewUserService erstellt einen neuen UserService
func NewUserService(repo repository.UserRepository) *UserServiceImpl {
	return &UserServiceImpl{userRepo: repo}
}

// CreateUser behandelt die Geschäftslogik für die Erstellung eines Benutzers
func (s *UserServiceImpl) CreateUser(name, email string) (*models.User, error) {
	if name == "" || email == "" {
		return nil, fmt.Errorf("Name und E-Mail dürfen nicht leer sein")
	}

	// Beispiel für Geschäftslogik: Prüfung auf vorhandene E-Mail
	// (der Kürze halber hier nicht implementiert, würde aber einen weiteren Repo-Aufruf erfordern)

	user := &models.User{Name: name, Email: email}
	createdUser, err := s.userRepo.CreateUser(user)
	if err != nil {
		return nil, fmt.Errorf("Fehler beim Erstellen des Benutzers im Repository: %w", err)
	}
	return createdUser, nil
}

// GetAllUsers ruft alle Benutzer mit potenzieller Geschäftslogik ab
func (s *UserServiceImpl) GetAllUsers() ([]models.User, error) {
	users, err := s.userRepo.GetUsers()
	if err != nil {
		return nil, fmt.Errorf("Fehler beim Abrufen von Benutzern aus dem Repository: %w", err)
	}
	return users, nil
}

Schritt 6: Implementieren der Handler-Schicht (internal/handler/user_handler.go)

Die Handler-Schicht befasst sich mit HTTP-Anfragen und -Antworten und delegiert die Geschäftslogik an die Service-Schicht.

// internal/handler/user_handler.go
package handler

import (
	"encoding/json"
	"net/http"
	"log"

	"your_module_name/internal/models"      // Ersetzen Sie your_module_name
	"your_module_name/internal/service"   // Ersetzen Sie your_module_name
)

// UserHandler behandelt HTTP-Anfragen im Zusammenhang mit Benutzern
type UserHandler struct {
	userService service.UserService
}

// NewUserHandler erstellt einen neuen UserHandler
func NewUserHandler(svc service.UserService) *UserHandler {
	return &UserHandler{userService: svc}
}

// CreateUserHandler behandelt POST-Anfragen zum Erstellen eines neuen Benutzers
func (h *UserHandler) CreateUserHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		http.Error(w, "Methode nicht erlaubt", http.StatusMethodNotAllowed)
		return
	}

	var reqUser struct {
		Name  string `json:"name"`
		Email string `json:"email"`
	}
	err := json.NewDecoder(r.Body).Decode(&reqUser)
	if err != nil {
		http.Error(w, "Ungültiger Anfragekörper", http.StatusBadRequest)
		return
	}

	user, err := h.userService.CreateUser(reqUser.Name, reqUser.Email)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest) // Häufig ein 400 für Fehler in der Geschäftslogik
		log.Printf("Fehler beim Erstellen des Benutzers: %v", err)
		return
	}

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

// GetUsersHandler behandelt GET-Anfragen zum Abrufen aller Benutzer
func (h *UserHandler) GetUsersHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != "GET" {
		http.Error(w, "Methode nicht erlaubt", http.StatusMethodNotAllowed)
		return
	}

	users, err := h.userService.GetAllUsers()
	if err != nil {
		http.Error(w, "Interner Serverfehler", http.StatusInternalServerError)
		log.Printf("Fehler beim Abrufen von Benutzern: %v", err)
		return
	}

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

Schritt 7: Rekonstruktion von main.go (cmd/api/main.go)

Die Datei main.go fungiert nun als Orchestrator, der Abhängigkeiten einrichtet und die Komponenten miteinander verbindet. Hier glänzt Dependency Injection.

// cmd/api/main.go (Nach dem Refactoring)
package main

import (
	"fmt"
	"log"
	"net/http"

	"your_module_name/internal/config"        // Ersetzen Sie your_module_name
	"your_module_name/internal/handler"       // Ersetzen Sie your_module_name
	"your_module_name/internal/repository"    // Ersetzen Sie your_module_name
	"your_module_name/internal/service"       // Ersetzen Sie your_module_name
)

func main() {
	// 1. Konfiguration initialisieren
	dbConfig := config.NewDBConfig()

	// 2. Datenbank initialisieren
	db, err := config.InitDatabase(dbConfig)
	if err != nil {
		log.Fatalf("Fehler bei der Initialisierung der Datenbank: %v", err)
	}
	defer db.Close()

	// 3. Repository-Schicht einrichten
	userRepo := repository.NewMySQLUserRepository(db)

	// 4. Service-Schicht einrichten
	userService := service.NewUserService(userRepo)

	// 5. Handler-Schicht einrichten
	userHandler := handler.NewUserHandler(userService)

	// 6. Routen registrieren
	http.HandleFunc("/users", userHandler.GetUsersHandler)
	http.HandleFunc("/users/create", userHandler.CreateUserHandler)

	fmt.Println("Server läuft auf :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

Wichtige Erkenntnisse aus der refactorten Struktur:

• Klare Trennung von Zuständigkeiten: Jedes Paket hat eine einzige, klar definierte Verantwortung.
• Reduzierte Kopplung: Komponenten interagieren über Schnittstellen (z. B. UserRepository, UserService), wodurch sie weniger von konkreten Implementierungen abhängig sind. Die Änderung der Datenbank von MySQL zu PostgreSQL würde nur die Erstellung eines PostgreSQLUserRepository und eine Änderung in main.go erfordern.
• Verbesserte Testbarkeit: Jede Schicht kann isoliert getestet werden. Sie können das UserRepository mocken, um den UserService ohne Datenbankverbindung zu testen, und das UserService mocken, um den UserHandler ohne eine Live-Datenbank oder komplexe Geschäftslogik zu testen.
• Erhöhte Wartbarkeit: Fehler sind leichter zu finden, und neue Funktionen können hinzugefügt werden, ohne Änderungen an nicht verwandten Teilen des Codes vorzunehmen.
• Skalierbarkeit: Ermöglicht bei Bedarf die einfachere horizontale Skalierung spezifischer Dienste in einem Microservices-Kontext (dieses Muster ist aber auch für Monolithen nützlich).

Verwendung und Anwendung

Um diese umstrukturierte Anwendung auszuführen, stellen Sie sicher, dass Sie eine go.mod-Datei haben:

go mod init your_module_name # Ersetzen Sie dies durch Ihren tatsächlichen Modulnamen, z. B. github.com/yourusername/webapp
go mod tidy

Führen Sie dann von Ihrem Projektstammverzeichnis aus aus:

go run cmd/api/main.go

Sie können die Endpunkte dann mit curl oder einem Tool wie Postman testen:

• Benutzer erstellen (POST):

  curl -X POST -H "Content-Type: application/json" -d '{"name": "Alice", "email": "alice@example.com"}' http://localhost:8080/users/create

• Benutzer abrufen (GET):

  curl http://localhost:8080/users

Diese Schichtenarchitektur bietet eine robuste Grundlage für den Aufbau wartbarer und skalierbarer Go-Webanwendungen und geht über die Einschränkungen einer einzelnen, ausufernden main.go-Datei hinaus.

Fazit

Das Refactoring einer monolithischen main.go in ein gut strukturiertes, modulares Go-Webprojekt ist ein entscheidender Schritt für die langfristige Gesundheit des Projekts. Durch die Übernahme einer Schichtenarchitektur und die Nutzung von Konzepten wie Paketen und Schnittstellen erreichen wir eine klare Trennung von Zuständigkeiten, reduzieren die Kopplung und verbessern die Testbarkeit und Wartbarkeit erheblich. Diese Transformation ermöglicht es Entwicklungsteams, robustere und skalierbarere Anwendungen zu erstellen, die sich an sich entwickelnde Anforderungen anpassen.