Hexagonale Architektur: Ein praktischer Leitfaden zu Ports und Adaptern

In der sich ständig weiterentwickelnden Softwareentwicklung ist der Bau robuster, wartbarer und testbarer Anwendungen von größter Bedeutung. Die Hexagonale Architektur, auch bekannt als Ports und Adapter, ist ein Architekturmuster, das diesen Anliegen begegnet, indem es die Kernlogik einer Anwendung von ihren externen Abhängigkeiten entkoppelt. Dieser Leitfaden zielt darauf ab, ein umfassendes Verständnis der Hexagonalen Architektur, ihrer Vorteile und praktischer Implementierungsstrategien für Entwickler weltweit zu vermitteln.

Was ist Hexagonale Architektur?

Die Hexagonale Architektur, geprägt von Alistair Cockburn, dreht sich um die Idee, die Kernlogik der Anwendung von ihrer Außenwelt zu isolieren. Diese Isolation wird durch die Verwendung von Ports und Adaptern erreicht.

• Kern (Anwendung): Repräsentiert das Herzstück Ihrer Anwendung, das die Geschäftslogik und Domänenmodelle enthält. Es sollte unabhängig von einer bestimmten Technologie oder einem Framework sein.
• Ports: Definieren die Schnittstellen, die die Kernanwendung zur Interaktion mit der Außenwelt verwendet. Dies sind abstrakte Definitionen, wie die Anwendung mit externen Systemen wie Datenbanken, Benutzeroberflächen oder Messaging-Warteschlangen interagiert. Ports können von zwei Typen sein:
  • Treibende (Primäre) Ports: Definieren die Schnittstellen, über die externe Akteure (z. B. Benutzer, andere Anwendungen) Aktionen innerhalb der Kernanwendung initiieren können.
  • Getriebene (Sekundäre) Ports: Definieren die Schnittstellen, die die Kernanwendung zur Interaktion mit externen Systemen (z. B. Datenbanken, Nachrichtenwarteschlangen) verwendet.
• Adapter: Implementieren die von den Ports definierten Schnittstellen. Sie fungieren als Übersetzer zwischen der Kernanwendung und den externen Systemen. Es gibt zwei Arten von Adaptern:
  • Treibende (Primäre) Adapter: Implementieren die treibenden Ports und übersetzen externe Anfragen in Befehle oder Abfragen, die die Kernanwendung verstehen kann. Beispiele sind Benutzeroberflächenkomponenten (z. B. Web-Controller), Kommandozeilen-Schnittstellen oder Nachrichtenwarteschlangen-Listener.
  • Getriebene (Sekundäre) Adapter: Implementieren die getriebenen Ports und übersetzen die Anfragen der Kernanwendung in spezifische Interaktionen mit externen Systemen. Beispiele sind Datenbankzugriffsobjekte, Nachrichtenwarteschlangen-Produzenten oder API-Clients.

Stellen Sie es sich so vor: Die Kernanwendung sitzt im Zentrum, umgeben von einer hexagonalen Hülle. Die Ports sind die Ein- und Ausgangspunkte auf dieser Hülle, und die Adapter stecken in diesen Ports und verbinden den Kern mit der Außenwelt.

Grundprinzipien der Hexagonalen Architektur

Mehrere Schlüsselprinzipien untermauern die Effektivität der Hexagonalen Architektur:

• Abhängigkeitsinversion: Die Kernanwendung hängt von Abstraktionen (Ports) ab, nicht von konkreten Implementierungen (Adaptern). Dies ist ein Kernprinzip des SOLID-Designs.
• Explizite Schnittstellen: Ports definieren klar die Grenzen zwischen dem Kern und der Außenwelt und fördern einen vertragsbasierten Integrationsansatz.
• Testbarkeit: Durch die Entkopplung des Kerns von externen Abhängigkeiten wird es einfacher, die Geschäftslogik isoliert mithilfe von Mock-Implementierungen der Ports zu testen.
• Flexibilität: Adapter können ohne Beeinträchtigung der Kernanwendung ausgetauscht werden, was eine einfache Anpassung an sich ändernde Technologien oder Anforderungen ermöglicht. Stellen Sie sich vor, Sie müssten von MySQL auf PostgreSQL umsteigen; nur der Datenbankadapter müsste geändert werden.

Vorteile der Hexagonalen Architektur

Die Einführung der Hexagonalen Architektur bietet zahlreiche Vorteile:

• Verbesserte Testbarkeit: Die Trennung der Belange macht es erheblich einfacher, Unit-Tests für die Kerngeschäftslogik zu schreiben. Das Mocken der Ports ermöglicht es Ihnen, den Kern zu isolieren und gründlich zu testen, ohne sich auf externe Systeme verlassen zu müssen. Zum Beispiel kann ein Zahlungsabwicklungsmodul getestet werden, indem der Zahlungs-Gateway-Port gemockt wird, um erfolgreiche und fehlgeschlagene Transaktionen zu simulieren, ohne sich tatsächlich mit dem echten Gateway zu verbinden.
• Erhöhte Wartbarkeit: Änderungen an externen Systemen oder Technologien haben minimale Auswirkungen auf die Kernanwendung. Adapter fungieren als Isolationsschichten, die den Kern vor externer Volatilität schützen. Betrachten Sie ein Szenario, in dem eine Drittanbieter-API, die zum Senden von SMS-Benachrichtigungen verwendet wird, ihr Format oder ihre Authentifizierungsmethode ändert. Nur der SMS-Adapter muss aktualisiert werden, die Kernanwendung bleibt unberührt.
• Verbesserte Flexibilität: Adapter können leicht ausgetauscht werden, was eine Anpassung an neue Technologien oder Anforderungen ohne größere Refaktorierung ermöglicht. Dies fördert Experimente und Innovationen. Ein Unternehmen könnte beschließen, seine Datenspeicherung von einer traditionellen relationalen Datenbank zu einer NoSQL-Datenbank zu migrieren. Mit der Hexagonalen Architektur muss nur der Datenbankadapter ersetzt werden, was die Störung der Kernanwendung minimiert.
• Reduzierte Kopplung: Die Kernanwendung ist von externen Abhängigkeiten entkoppelt, was zu einem modulareren und kohärenteren Design führt. Dies macht die Codebasis einfacher zu verstehen, zu ändern und zu erweitern.
• Unabhängige Entwicklung: Verschiedene Teams können unabhängig voneinander an der Kernanwendung und den Adaptern arbeiten, was eine parallele Entwicklung und eine schnellere Markteinführung fördert. Zum Beispiel könnte sich ein Team auf die Entwicklung der Kernlogik der Auftragsabwicklung konzentrieren, während ein anderes Team die Benutzeroberfläche und die Datenbankadapter erstellt.

Implementierung der Hexagonalen Architektur: Ein praktisches Beispiel

Lassen Sie uns die Implementierung der Hexagonalen Architektur anhand eines vereinfachten Beispiels eines Benutzerregistrierungssystems veranschaulichen. Zur Klarheit verwenden wir eine hypothetische Programmiersprache (ähnlich Java oder C#).

1. Den Kern (Anwendung) definieren

Die Kernanwendung enthält die Geschäftslogik zur Registrierung eines neuen Benutzers.

// Kern/UserService.java (oder UserService.cs)
public class UserService {
    private final UserRepository userRepository;
    private final PasswordHasher passwordHasher;
    private final UserValidator userValidator;

    public UserService(UserRepository userRepository, PasswordHasher passwordHasher, UserValidator userValidator) {
        this.userRepository = userRepository;
        this.passwordHasher = passwordHasher;
        this.userValidator = userValidator;
    }

    public Result<User, String> registerUser(String username, String password, String email) {
        // Benutzereingabe validieren
        ValidationResult validationResult = userValidator.validate(username, password, email);
        if (!validationResult.isValid()) {
            return Result.failure(validationResult.getErrorMessage());
        }

        // Prüfen, ob Benutzer bereits existiert
        if (userRepository.findByUsername(username).isPresent()) {
            return Result.failure("Benutzername existiert bereits");
        }

        // Passwort hashen
        String hashedPassword = passwordHasher.hash(password);

        // Neuen Benutzer erstellen
        User user = new User(username, hashedPassword, email);

        // Benutzer im Repository speichern
        userRepository.save(user);

        return Result.success(user);
    }
}

2. Die Ports definieren

Wir definieren die Ports, die die Kernanwendung zur Interaktion mit der Außenwelt verwendet.

// Ports/UserRepository.java (oder UserRepository.cs)
public interface UserRepository {
    Optional<User> findByUsername(String username);
    void save(User user);
}

// Ports/PasswordHasher.java (oder PasswordHasher.cs)
public interface PasswordHasher {
    String hash(String password);
}

//Ports/UserValidator.java (oder UserValidator.cs)
public interface UserValidator{
  ValidationResult validate(String username, String password, String email);
}

//Ports/ValidationResult.java (oder ValidationResult.cs)
public interface ValidationResult{
  boolean isValid();
  String getErrorMessage();
}

3. Die Adapter definieren

Wir implementieren die Adapter, die die Kernanwendung mit spezifischen Technologien verbinden.

// Adapter/DatabaseUserRepository.java (oder DatabaseUserRepository.cs)
public class DatabaseUserRepository implements UserRepository {
    private final DatabaseConnection databaseConnection;

    public DatabaseUserRepository(DatabaseConnection databaseConnection) {
        this.databaseConnection = databaseConnection;
    }

    @Override
    public Optional<User> findByUsername(String username) {
        // Implementierung mit JDBC, JPA oder einer anderen Datenbankzugriffstechnologie
        // ...
        return Optional.empty(); // Platzhalter
    }

    @Override
    public void save(User user) {
        // Implementierung mit JDBC, JPA oder einer anderen Datenbankzugriffstechnologie
        // ...
    }
}

// Adapter/BCryptPasswordHasher.java (oder BCryptPasswordHasher.cs)
public class BCryptPasswordHasher implements PasswordHasher {
    @Override
    public String hash(String password) {
        // Implementierung mit BCrypt-Bibliothek
        // ...
        return "hashedPassword"; //Platzhalter
    }
}

//Adapter/SimpleUserValidator.java (oder SimpleUserValidator.cs)
public class SimpleUserValidator implements UserValidator {
  @Override
  public ValidationResult validate(String username, String password, String email){
    //Einfache Validierungslogik
     if (username == null || username.isEmpty()) {
            return new SimpleValidationResult(false, "Benutzername darf nicht leer sein");
        }
        if (password == null || password.length() < 8) {
            return new SimpleValidationResult(false, "Passwort muss mindestens 8 Zeichen lang sein");
        }
        if (email == null || !email.contains("@")) {
            return new SimpleValidationResult(false, "Ungültiges E-Mail-Format");
        }

        return new SimpleValidationResult(true, null);
  }
}

//Adapter/SimpleValidationResult.java (oder SimpleValidationResult.cs)
public class SimpleValidationResult implements ValidationResult {
  private final boolean valid;
  private final String errorMessage;

    public SimpleValidationResult(boolean valid, String errorMessage) {
        this.valid = valid;
        this.errorMessage = errorMessage;
    }
  @Override
  public boolean isValid(){
    return valid;
  }

  @Override
  public String getErrorMessage(){
    return errorMessage;
  }
}



//Adapter/WebUserController.java (oder WebUserController.cs)
//Treibender Adapter - verarbeitet Anfragen aus dem Web
public class WebUserController {
    private final UserService userService;

    public WebUserController(UserService userService) {
        this.userService = userService;
    }

    public String registerUser(String username, String password, String email) {
        Result<User, String> result = userService.registerUser(username, password, email);
        if (result.isSuccess()) {
            return "Registrierung erfolgreich!";
        } else {
            return "Registrierung fehlgeschlagen: " + result.getFailure();
        }
    }
}

4. Komposition

Alles miteinander verbinden. Beachten Sie, dass diese Komposition (Dependency Injection) typischerweise am Einstiegspunkt der Anwendung oder innerhalb eines Dependency-Injection-Containers stattfindet.

//Hauptklasse oder Konfiguration der Abhängigkeitsinjektion
public class Main {
    public static void main(String[] args) {
        // Instanzen der Adapter erstellen
        DatabaseConnection databaseConnection = new DatabaseConnection("jdbc:mydb://localhost:5432/users", "user", "password");
        DatabaseUserRepository userRepository = new DatabaseUserRepository(databaseConnection);
        BCryptPasswordHasher passwordHasher = new BCryptPasswordHasher();
        SimpleUserValidator userValidator = new SimpleUserValidator();

        // Eine Instanz der Kernanwendung erstellen und die Adapter injizieren
        UserService userService = new UserService(userRepository, passwordHasher, userValidator);

        //Einen treibenden Adapter erstellen und ihn mit dem Dienst verbinden
        WebUserController userController = new WebUserController(userService);

        //Jetzt können Sie Benutzerregistrierungsanfragen über den userController verarbeiten
        String result = userController.registerUser("john.doe", "P@sswOrd123", "john.doe@example.com");
        System.out.println(result);
    }
}



//DatabaseConnection ist nur eine einfache Klasse zu Demonstrationszwecken
class DatabaseConnection {
    private String url;
    private String username;
    private String password;

    public DatabaseConnection(String url, String username, String password) {
        this.url = url;
        this.username = username;
        this.password = password;
    }

    // ... Methoden zur Verbindung mit der Datenbank (aus Platzgründen nicht implementiert)
}

//Result-Klasse (ähnlich Either in der funktionalen Programmierung)
class Result<T, E> {
    private final T success;
    private final E failure;
    private final boolean isSuccess;

    private Result(T success, E failure, boolean isSuccess) {
        this.success = success;
        this.failure = failure;
        this.isSuccess = isSuccess;
    }

    public static <T, E> Result<T, E> success(T value) {
        return new Result<>(value, null, true);
    }

    public static <T, E> Result<T, E> failure(E error) {
        return new Result<>(null, error, false);
    }

    public boolean isSuccess() {
        return isSuccess;
    }

    public T getSuccess() {
        if (!isSuccess) {
            throw new IllegalStateException("Ergebnis ist ein Fehler");
        }
        return success;
    }

    public E getFailure() {
        if (isSuccess) {
            throw new IllegalStateException("Ergebnis ist ein Erfolg");
        }
        return failure;
    }
}

class User {
    private String username;
    private String password;
    private String email;

    public User(String username, String password, String email) {
        this.username = username;
        this.password = password;
        this.email = email;
    }

    // Getter und Setter (aus Platzgründen weggelassen)

}

Erklärung:

• Der UserService repräsentiert die Kerngeschäftslogik. Er hängt von den Schnittstellen UserRepository, PasswordHasher und UserValidator (Ports) ab.
• Der DatabaseUserRepository, BCryptPasswordHasher und SimpleUserValidator sind Adapter, die die jeweiligen Ports unter Verwendung konkreter Technologien (eine Datenbank, BCrypt und grundlegende Validierungslogik) implementieren.
• Der WebUserController ist ein treibender Adapter, der Webanfragen verarbeitet und mit dem UserService interagiert.
• Die Hauptmethode komponiert die Anwendung, indem sie Instanzen der Adapter erstellt und diese in die Kernanwendung injiziert.

Fortgeschrittene Überlegungen und Best Practices

Obwohl die Grundprinzipien der Hexagonalen Architektur unkompliziert sind, gibt es einige fortgeschrittene Überlegungen zu beachten:

• Die richtige Granularität für Ports wählen: Die Bestimmung des angemessenen Abstraktionsgrades für Ports ist entscheidend. Zu feingranulare Ports können zu unnötiger Komplexität führen, während zu grobgranulare Ports die Flexibilität einschränken können. Berücksichtigen Sie die Kompromisse zwischen Einfachheit und Anpassungsfähigkeit bei der Definition Ihrer Ports.
• Transaktionsmanagement: Beim Umgang mit mehreren externen Systemen kann die Sicherstellung der Transaktionskonsistenz eine Herausforderung sein. Erwägen Sie die Verwendung von verteilten Transaktionsmanagementtechniken oder die Implementierung von kompensierenden Transaktionen, um die Datenintegrität zu gewährleisten. Wenn zum Beispiel die Registrierung eines Benutzers die Erstellung eines Kontos in einem separaten Abrechnungssystem beinhaltet, müssen Sie sicherstellen, dass beide Operationen entweder zusammen erfolgreich sind oder zusammen fehlschlagen.
• Fehlerbehandlung: Implementieren Sie robuste Fehlerbehandlungsmechanismen, um Ausfälle in externen Systemen elegant zu handhaben. Verwenden Sie Circuit Breaker oder Wiederholungsmechanismen, um Kaskadenfehler zu verhindern. Wenn ein Adapter keine Verbindung zu einer Datenbank herstellen kann, sollte die Anwendung den Fehler elegant behandeln und möglicherweise die Verbindung erneut versuchen oder eine informative Fehlermeldung an den Benutzer liefern.
• Teststrategien: Setzen Sie eine Kombination aus Unit-Tests, Integrationstests und End-to-End-Tests ein, um die Qualität Ihrer Anwendung sicherzustellen. Unit-Tests sollten sich auf die Kerngeschäftslogik konzentrieren, während Integrationstests die Interaktionen zwischen dem Kern und den Adaptern überprüfen sollten.
• Dependency Injection Frameworks: Nutzen Sie Dependency Injection Frameworks (z. B. Spring, Guice), um die Abhängigkeiten zwischen Komponenten zu verwalten und die Komposition der Anwendung zu vereinfachen. Diese Frameworks automatisieren den Prozess der Erstellung und Injektion von Abhängigkeiten, reduzieren Boilerplate-Code und verbessern die Wartbarkeit.
• CQRS (Command Query Responsibility Segregation): Die Hexagonale Architektur passt gut zu CQRS, wo Sie die Lese- und Schreibmodelle Ihrer Anwendung trennen. Dies kann die Leistung und Skalierbarkeit, insbesondere in komplexen Systemen, weiter verbessern.

Praxisbeispiele der Hexagonalen Architektur im Einsatz

Viele erfolgreiche Unternehmen und Projekte haben die Hexagonale Architektur übernommen, um robuste und wartbare Systeme zu bauen:

• E-Commerce-Plattformen: E-Commerce-Plattformen verwenden häufig die Hexagonale Architektur, um die Kernlogik der Auftragsabwicklung von verschiedenen externen Systemen wie Zahlungs-Gateways, Versanddienstleistern und Bestandsverwaltungssystemen zu entkoppeln. Dies ermöglicht es ihnen, neue Zahlungsmethoden oder Versandoptionen einfach zu integrieren, ohne die Kernfunktionalität zu stören.
• Finanzanwendungen: Finanzanwendungen, wie Bankensysteme und Handelsplattformen, profitieren von der Testbarkeit und Wartbarkeit, die die Hexagonale Architektur bietet. Die finanzielle Kernlogik kann isoliert gründlich getestet werden, und Adapter können verwendet werden, um eine Verbindung zu verschiedenen externen Diensten wie Marktdatenanbietern und Clearingstellen herzustellen.
• Microservices-Architekturen: Die Hexagonale Architektur passt gut zu Microservices-Architekturen, bei denen jeder Microservice einen begrenzten Kontext mit seiner eigenen Kerngeschäftslogik und externen Abhängigkeiten darstellt. Ports und Adapter bieten einen klaren Vertrag für die Kommunikation zwischen Microservices, was eine lose Kopplung und unabhängige Bereitstellung fördert.
• Modernisierung von Altsystemen: Die Hexagonale Architektur kann verwendet werden, um Altsysteme schrittweise zu modernisieren, indem der bestehende Code in Adaptern gekapselt und neue Kernlogik hinter Ports eingeführt wird. Dies ermöglicht es Ihnen, Teile des Altsystems schrittweise zu ersetzen, ohne die gesamte Anwendung neu schreiben zu müssen.

Herausforderungen und Kompromisse

Obwohl die Hexagonale Architektur erhebliche Vorteile bietet, ist es wichtig, die damit verbundenen Herausforderungen und Kompromisse anzuerkennen:

• Erhöhte Komplexität: Die Implementierung der Hexagonalen Architektur kann zusätzliche Abstraktionsebenen einführen, was die anfängliche Komplexität der Codebasis erhöhen kann.
• Lernkurve: Entwickler benötigen möglicherweise Zeit, um die Konzepte von Ports und Adaptern zu verstehen und sie effektiv anzuwenden.
• Potenzial für Over-Engineering: Es ist wichtig, Over-Engineering zu vermeiden, indem man unnötige Ports und Adapter erstellt. Beginnen Sie mit einem einfachen Design und fügen Sie die Komplexität bei Bedarf schrittweise hinzu.
• Leistungsüberlegungen: Die zusätzlichen Abstraktionsebenen können potenziell einen gewissen Leistungs-Overhead mit sich bringen, obwohl dies in den meisten Anwendungen normalerweise vernachlässigbar ist.

Es ist entscheidend, die Vorteile und Herausforderungen der Hexagonalen Architektur im Kontext Ihrer spezifischen Projektanforderungen und Teamfähigkeiten sorgfältig zu bewerten. Es ist keine Wunderwaffe und möglicherweise nicht die beste Wahl für jedes Projekt.

Fazit

Die Hexagonale Architektur, mit ihrem Schwerpunkt auf Ports und Adaptern, bietet einen leistungsstarken Ansatz zum Bau wartbarer, testbarer und flexibler Anwendungen. Durch die Entkopplung der Kerngeschäftslogik von externen Abhängigkeiten ermöglicht sie es Ihnen, sich mühelos an sich ändernde Technologien und Anforderungen anzupassen. Obwohl es Herausforderungen und Kompromisse zu berücksichtigen gilt, überwiegen die Vorteile der Hexagonalen Architektur oft die Kosten, insbesondere bei komplexen und langlebigen Anwendungen. Durch die Übernahme der Prinzipien der Abhängigkeitsinversion und expliziten Schnittstellen können Sie Systeme schaffen, die widerstandsfähiger, leichter zu verstehen und besser gerüstet sind, um den Anforderungen der modernen Softwarelandschaft gerecht zu werden.

Dieser Leitfaden hat einen umfassenden Überblick über die Hexagonale Architektur gegeben, von ihren Grundprinzipien bis zu praktischen Implementierungsstrategien. Wir ermutigen Sie, diese Konzepte weiter zu erforschen und sie in Ihren eigenen Projekten anzuwenden. Die Investition in das Erlernen und die Übernahme der Hexagonalen Architektur wird sich zweifellos langfristig auszahlen und zu qualitativ hochwertigerer Software und zufriedeneren Entwicklungsteams führen.

Letztendlich hängt die Wahl der richtigen Architektur von den spezifischen Anforderungen Ihres Projekts ab. Berücksichtigen Sie Komplexität, Langlebigkeit und Wartbarkeitsanforderungen bei Ihrer Entscheidung. Die Hexagonale Architektur bietet eine solide Grundlage für den Bau robuster und anpassungsfähiger Anwendungen, ist aber nur ein Werkzeug im Werkzeugkasten des Softwarearchitekten.