Architektura Heksagonalna: Praktyczny przewodnik po portach i adapterach

W stale zmieniającym się krajobrazie rozwoju oprogramowania, budowanie solidnych, łatwych w utrzymaniu i testowaniu aplikacji jest najważniejsze. Architektura heksagonalna, znana również jako Porty i Adaptery, to wzorzec architektoniczny, który odpowiada na te obawy poprzez oddzielenie podstawowej logiki biznesowej aplikacji od jej zewnętrznych zależności. Niniejszy przewodnik ma na celu zapewnienie kompleksowego zrozumienia architektury heksagonalnej, jej zalet i praktycznych strategii implementacji dla programistów na całym świecie.

Co to jest Architektura Heksagonalna?

Architektura heksagonalna, której autorem jest Alistair Cockburn, koncentruje się wokół idei izolowania podstawowej logiki biznesowej aplikacji od jej świata zewnętrznego. Izolacja ta jest osiągana poprzez użycie portów i adapterów.

• Rdzeń (aplikacja): Reprezentuje serce Twojej aplikacji, zawierające logikę biznesową i modele domenowe. Powinien być niezależny od jakiejkolwiek konkretnej technologii lub frameworka.
• Porty: Definiują interfejsy, których rdzeń aplikacji używa do interakcji ze światem zewnętrznym. Są to abstrakcyjne definicje sposobu, w jaki aplikacja wchodzi w interakcje z zewnętrznymi systemami, takimi jak bazy danych, interfejsy użytkownika lub kolejki komunikatów. Porty mogą być dwojakiego rodzaju:
  • Porty napędzające (podstawowe): Definiują interfejsy, za pośrednictwem których zewnętrzne podmioty (np. użytkownicy, inne aplikacje) mogą inicjować działania w rdzeniu aplikacji.
  • Porty napędzane (wtórne): Definiują interfejsy, których rdzeń aplikacji używa do interakcji z zewnętrznymi systemami (np. bazy danych, kolejki komunikatów).
• Adaptery: Implementują interfejsy zdefiniowane przez porty. Działają jako tłumacze między rdzeniem aplikacji a zewnętrznymi systemami. Istnieją dwa typy adapterów:
  • Adaptery napędzające (podstawowe): Implementują porty napędzające, tłumacząc zewnętrzne żądania na polecenia lub zapytania, które rdzeń aplikacji może zrozumieć. Przykłady obejmują komponenty interfejsu użytkownika (np. kontrolery internetowe), interfejsy wiersza poleceń lub odbiorniki kolejek komunikatów.
  • Adaptery napędzane (wtórne): Implementują porty napędzane, tłumacząc żądania rdzenia aplikacji na konkretne interakcje z zewnętrznymi systemami. Przykłady obejmują obiekty dostępu do bazy danych, producentów kolejek komunikatów lub klientów API.

Pomyśl o tym w ten sposób: rdzeń aplikacji znajduje się w centrum, otoczony heksagonalną powłoką. Porty są punktami wejścia i wyjścia na tej powłoce, a adaptery podłączają się do tych portów, łącząc rdzeń ze światem zewnętrznym.

Kluczowe zasady architektury heksagonalnej

Kilka kluczowych zasad leży u podstaw skuteczności architektury heksagonalnej:

• Odwrócenie zależności: Rdzeń aplikacji zależy od abstrakcji (portów), a nie od konkretnych implementacji (adapterów). Jest to podstawowa zasada projektowania SOLID.
• Jawne interfejsy: Porty jasno definiują granice między rdzeniem a światem zewnętrznym, promując podejście do integracji oparte na kontraktach.
• Testowalność: Oddzielając rdzeń od zewnętrznych zależności, łatwiej jest testować logikę biznesową w izolacji przy użyciu atrap implementacji portów.
• Elastyczność: Adaptery można wymieniać bez wpływu na rdzeń aplikacji, co pozwala na łatwe dostosowanie do zmieniających się technologii lub wymagań. Wyobraź sobie potrzebę przejścia z MySQL na PostgreSQL; wystarczy zmienić adapter bazy danych.

Korzyści z używania architektury heksagonalnej

Przyjęcie architektury heksagonalnej oferuje liczne zalety:

• Ulepszona testowalność: Oddzielenie problemów znacznie ułatwia pisanie testów jednostkowych dla podstawowej logiki biznesowej. Mockowanie portów pozwala na izolację rdzenia i jego dokładne przetestowanie bez polegania na zewnętrznych systemach. Na przykład moduł przetwarzania płatności można przetestować, mockując port bramki płatniczej, symulując udane i nieudane transakcje bez faktycznego łączenia się z rzeczywistą bramką.
• Zwiększona łatwość konserwacji: Zmiany w zewnętrznych systemach lub technologiach mają minimalny wpływ na rdzeń aplikacji. Adaptery działają jako warstwy izolacyjne, chroniąc rdzeń przed zewnętrzną zmiennością. Rozważmy scenariusz, w którym interfejs API innej firmy używany do wysyłania powiadomień SMS zmienia format lub metodę uwierzytelniania. Należy zaktualizować tylko adapter SMS, pozostawiając rdzeń aplikacji nietknięty.
• Zwiększona elastyczność: Adaptery można łatwo przełączać, co pozwala na dostosowanie się do nowych technologii lub wymagań bez większego refaktoringu. Ułatwia to eksperymentowanie i innowacje. Firma może podjąć decyzję o migracji pamięci masowej danych z tradycyjnej relacyjnej bazy danych do bazy danych NoSQL. Dzięki architekturze heksagonalnej wystarczy wymienić adapter bazy danych, minimalizując zakłócenia w rdzeniu aplikacji.
• Zmniejszone sprzężenie: Rdzeń aplikacji jest oddzielony od zewnętrznych zależności, co prowadzi do bardziej modularnej i spójnej konstrukcji. Ułatwia to zrozumienie, modyfikowanie i rozszerzanie bazy kodu.
• Niezależny rozwój: Różne zespoły mogą pracować nad rdzeniem aplikacji i adapterami niezależnie, promując równoległy rozwój i szybszy czas wprowadzenia na rynek. Na przykład jeden zespół mógłby skupić się na opracowaniu podstawowej logiki przetwarzania zamówień, podczas gdy inny zespół buduje interfejs użytkownika i adaptery bazy danych.

Implementacja architektury heksagonalnej: praktyczny przykład

Zilustrujmy implementację architektury heksagonalnej uproszczonym przykładem systemu rejestracji użytkowników. Dla jasności użyjemy hipotetycznego języka programowania (podobnego do Java lub C#).

1. Zdefiniuj rdzeń (aplikację)

Rdzeń aplikacji zawiera logikę biznesową rejestracji nowego użytkownika.

// Core/UserService.java (lub 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) {
        // Validate user input
        ValidationResult validationResult = userValidator.validate(username, password, email);
        if (!validationResult.isValid()) {
            return Result.failure(validationResult.getErrorMessage());
        }

        // Check if user already exists
        if (userRepository.findByUsername(username).isPresent()) {
            return Result.failure("Username already exists");
        }

        // Hash the password
        String hashedPassword = passwordHasher.hash(password);

        // Create a new user
        User user = new User(username, hashedPassword, email);

        // Save the user to the repository
        userRepository.save(user);

        return Result.success(user);
    }
}

2. Zdefiniuj porty

Definiujemy porty, których rdzeń aplikacji używa do interakcji ze światem zewnętrznym.

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

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

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

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

3. Zdefiniuj adaptery

Implementujemy adaptery, które łączą rdzeń aplikacji z określonymi technologiami.

// Adapters/DatabaseUserRepository.java (lub 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) {
        // Implementation using JDBC, JPA, or another database access technology
        // ...
        return Optional.empty(); // Placeholder
    }

    @Override
    public void save(User user) {
        // Implementation using JDBC, JPA, or another database access technology
        // ...
    }
}

// Adapters/BCryptPasswordHasher.java (lub BCryptPasswordHasher.cs)
public class BCryptPasswordHasher implements PasswordHasher {
    @Override
    public String hash(String password) {
        // Implementation using BCrypt library
        // ...
        return "hashedPassword"; //Placeholder
    }
}

//Adapters/SimpleUserValidator.java (lub SimpleUserValidator.cs)
public class SimpleUserValidator implements UserValidator {
  @Override
  public ValidationResult validate(String username, String password, String email){
    //Simple Validation logic
     if (username == null || username.isEmpty()) {
            return new SimpleValidationResult(false, "Username cannot be empty");
        }
        if (password == null || password.length() < 8) {
            return new SimpleValidationResult(false, "Password must be at least 8 characters long");
        }
        if (email == null || !email.contains("@")) {
            return new SimpleValidationResult(false, "Invalid email format");
        }

        return new SimpleValidationResult(true, null);
  }
}

//Adapters/SimpleValidationResult.java (lub 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;
  }
}



//Adapters/WebUserController.java (lub WebUserController.cs)
//Driving Adapter - handles requests from the 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 "Registration successful!";
        } else {
            return "Registration failed: " + result.getFailure();
        }
    }
}

4. Kompozycja

Łączenie wszystkiego razem. Należy pamiętać, że ta kompozycja (wstrzykiwanie zależności) zwykle odbywa się w punkcie wejścia aplikacji lub w kontenerze wstrzykiwania zależności.

//Main class or dependency injection configuration
public class Main {
    public static void main(String[] args) {
        // Create instances of the adapters
        DatabaseConnection databaseConnection = new DatabaseConnection("jdbc:mydb://localhost:5432/users", "user", "password");
        DatabaseUserRepository userRepository = new DatabaseUserRepository(databaseConnection);
        BCryptPasswordHasher passwordHasher = new BCryptPasswordHasher();
        SimpleUserValidator userValidator = new SimpleUserValidator();

        // Create an instance of the core application, injecting the adapters
        UserService userService = new UserService(userRepository, passwordHasher, userValidator);

        //Create a driving adapter and connect it to the service
        WebUserController userController = new WebUserController(userService);

        //Now you can handle user registration requests through the userController
        String result = userController.registerUser("john.doe", "P@sswOrd123", "john.doe@example.com");
        System.out.println(result);
    }
}



//DatabaseConnection is a simple class for demonstration purposes only
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;
    }

    // ... methods to connect to the database (not implemented for brevity)
}

//Result class (similar to Either in functional programming)
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("Result is a failure");
        }
        return success;
    }

    public E getFailure() {
        if (isSuccess) {
            throw new IllegalStateException("Result is a success");
        }
        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;
    }

    // getters and setters (omitted for brevity)

}

Wyjaśnienie:

• UserService reprezentuje podstawową logikę biznesową. Zależy od interfejsów UserRepository, PasswordHasher i UserValidator (portów).
• DatabaseUserRepository, BCryptPasswordHasher i SimpleUserValidator to adaptery, które implementują odpowiednie porty przy użyciu konkretnych technologii (bazy danych, BCrypt i podstawowej logiki walidacji).
• WebUserController to adapter napędzający, który obsługuje żądania internetowe i wchodzi w interakcje z UserService.
• Główna metoda składa aplikację, tworząc instancje adapterów i wstrzykując je do rdzenia aplikacji.

Zaawansowane zagadnienia i najlepsze praktyki

Chociaż podstawowe zasady architektury heksagonalnej są proste, należy pamiętać o kilku zaawansowanych kwestiach:

• Wybór odpowiedniej szczegółowości dla portów: Określenie odpowiedniego poziomu abstrakcji dla portów ma kluczowe znaczenie. Zbyt szczegółowe porty mogą prowadzić do niepotrzebnej złożoności, podczas gdy zbyt ogólne porty mogą ograniczać elastyczność. Rozważ kompromisy między prostotą a możliwością adaptacji podczas definiowania portów.
• Zarządzanie transakcjami: Podczas pracy z wieloma zewnętrznymi systemami zapewnienie spójności transakcyjnej może być trudne. Rozważ użycie technik rozproszonego zarządzania transakcjami lub wdrożenie transakcji kompensacyjnych w celu utrzymania integralności danych. Na przykład, jeśli rejestracja użytkownika obejmuje utworzenie konta w oddzielnym systemie rozliczeniowym, musisz upewnić się, że obie operacje zakończą się powodzeniem lub niepowodzeniem.
• Obsługa błędów: Wdróż solidne mechanizmy obsługi błędów, aby z wdziękiem obsługiwać awarie w zewnętrznych systemach. Użyj wyłączników lub mechanizmów ponawiania, aby zapobiec kaskadowym awariom. Gdy adapter nie może połączyć się z bazą danych, aplikacja powinna obsłużyć błąd z wdziękiem i potencjalnie ponowić próbę połączenia lub wyświetlić użytkownikowi informacyjny komunikat o błędzie.
• Strategie testowania: Zastosuj kombinację testów jednostkowych, testów integracyjnych i testów kompleksowych, aby zapewnić jakość aplikacji. Testy jednostkowe powinny koncentrować się na podstawowej logice biznesowej, a testy integracyjne powinny weryfikować interakcje między rdzeniem a adapterami.
• Frameworki wstrzykiwania zależności: Wykorzystaj frameworki wstrzykiwania zależności (np. Spring, Guice) do zarządzania zależnościami między komponentami i uproszczenia kompozycji aplikacji. Frameworki te automatyzują proces tworzenia i wstrzykiwania zależności, redukując ilość kodu standardowego i poprawiając łatwość konserwacji.
• CQRS (Command Query Responsibility Segregation): Architektura heksagonalna dobrze współgra z CQRS, gdzie oddzielasz modele odczytu i zapisu swojej aplikacji. Może to dodatkowo poprawić wydajność i skalowalność, szczególnie w złożonych systemach.

Przykłady użycia architektury heksagonalnej w świecie rzeczywistym

Wiele odnoszących sukcesy firm i projektów przyjęło architekturę heksagonalną, aby budować solidne i łatwe w utrzymaniu systemy:

• Platformy e-commerce: Platformy e-commerce często używają architektury heksagonalnej do oddzielenia podstawowej logiki przetwarzania zamówień od różnych zewnętrznych systemów, takich jak bramki płatnicze, dostawcy usług spedycyjnych i systemy zarządzania zapasami. Pozwala im to łatwo integrować nowe metody płatności lub opcje wysyłki bez zakłócania podstawowej funkcjonalności.
• Aplikacje finansowe: Aplikacje finansowe, takie jak systemy bankowe i platformy transakcyjne, korzystają z testowalności i łatwości konserwacji oferowanej przez architekturę heksagonalną. Podstawową logikę finansową można dokładnie przetestować w izolacji, a adaptery można wykorzystać do łączenia się z różnymi zewnętrznymi usługami, takimi jak dostawcy danych rynkowych i izby rozliczeniowe.
• Architektury mikroserwisów: Architektura heksagonalna naturalnie pasuje do architektur mikroserwisów, gdzie każdy mikroserwis reprezentuje ograniczony kontekst z własną podstawową logiką biznesową i zewnętrznymi zależnościami. Porty i adaptery zapewniają jasny kontrakt na komunikację między mikroserwisami, promując luźne sprzężenie i niezależne wdrażanie.
• Modernizacja starszych systemów: Architektura heksagonalna może być używana do stopniowej modernizacji starszych systemów poprzez owijanie istniejącego kodu w adaptery i wprowadzanie nowej podstawowej logiki za portami. Pozwala to na przyrostową wymianę części starszego systemu bez przepisywania całej aplikacji.

Wyzwania i kompromisy

Chociaż architektura heksagonalna oferuje znaczące korzyści, ważne jest, aby uznać związane z nią wyzwania i kompromisy:

• Zwiększona złożoność: Implementacja architektury heksagonalnej może wprowadzić dodatkowe warstwy abstrakcji, co może zwiększyć początkową złożoność bazy kodu.
• Krzywa uczenia się: Programiści mogą potrzebować czasu, aby zrozumieć koncepcje portów i adapterów oraz jak je skutecznie stosować.
• Potencjał nadmiernego projektowania: Ważne jest, aby unikać nadmiernego projektowania poprzez tworzenie niepotrzebnych portów i adapterów. Zacznij od prostego projektu i stopniowo dodawaj złożoność w razie potrzeby.
• Względy dotyczące wydajności: Dodatkowe warstwy abstrakcji mogą potencjalnie wprowadzić pewien narzut wydajnościowy, chociaż zwykle jest on pomijalny w większości aplikacji.

Konieczne jest dokładne przeanalizowanie korzyści i wyzwań architektury heksagonalnej w kontekście konkretnych wymagań projektu i możliwości zespołu. Nie jest to panaceum i może nie być najlepszym wyborem dla każdego projektu.

Wniosek

Architektura heksagonalna, z naciskiem na porty i adaptery, zapewnia potężne podejście do budowania łatwych w utrzymaniu, testowaniu i elastycznych aplikacji. Oddzielając podstawową logikę biznesową od zewnętrznych zależności, umożliwia dostosowanie się do zmieniających się technologii i wymagań z łatwością. Chociaż należy wziąć pod uwagę wyzwania i kompromisy, korzyści płynące z architektury heksagonalnej często przewyższają koszty, szczególnie w przypadku złożonych i długowiecznych aplikacji. Przyjmując zasady odwrócenia zależności i jawnych interfejsów, możesz tworzyć systemy, które są bardziej odporne, łatwiejsze do zrozumienia i lepiej przygotowane do sprostania wymaganiom współczesnego krajobrazu oprogramowania.

Ten przewodnik zawiera kompleksowy przegląd architektury heksagonalnej, od jej podstawowych zasad po praktyczne strategie implementacji. Zachęcamy do dalszego zgłębiania tych koncepcji i eksperymentowania z ich stosowaniem we własnych projektach. Inwestycja w naukę i przyjęcie architektury heksagonalnej bez wątpienia opłaci się w dłuższej perspektywie, prowadząc do oprogramowania wyższej jakości i bardziej zadowolonych zespołów programistycznych.

Ostatecznie wybór odpowiedniej architektury zależy od konkretnych potrzeb Twojego projektu. Rozważ wymagania dotyczące złożoności, trwałości i łatwości konserwacji podczas podejmowania decyzji. Architektura heksagonalna stanowi solidny fundament do budowania solidnych i adaptowalnych aplikacji, ale jest to tylko jedno narzędzie w zestawie narzędzi architekta oprogramowania.