Hexagonální architektura: Praktický průvodce porty a adaptéry

V neustále se vyvíjejícím prostředí vývoje softwaru je budování robustních, udržovatelných a testovatelných aplikací prvořadé. Hexagonální architektura, známá také jako porty a adaptéry, je architektonický vzor, ​​který řeší tyto obavy oddělením základní obchodní logiky aplikace od jejích externích závislostí. Tato příručka si klade za cíl poskytnout komplexní pochopení hexagonální architektury, jejích výhod a praktických strategií implementace pro vývojáře po celém světě.

Co je hexagonální architektura?

Hexagonální architektura, kterou vytvořil Alistair Cockburn, se točí kolem myšlenky izolace základní obchodní logiky aplikace od jejího vnějšího světa. Této izolace je dosaženo pomocí portů a adaptérů.

• Jádro (Aplikace): Představuje srdce vaší aplikace, které obsahuje obchodní logiku a doménové modely. Mělo by být nezávislé na jakékoli konkrétní technologii nebo frameworku.
• Porty: Definují rozhraní, která jádro aplikace používá k interakci s vnějším světem. Jsou to abstraktní definice toho, jak aplikace interaguje s externími systémy, jako jsou databáze, uživatelská rozhraní nebo fronty zpráv. Porty mohou být dvou typů:
  • Řídicí (primární) porty: Definují rozhraní, prostřednictvím kterých mohou externí aktéři (např. uživatelé, jiné aplikace) iniciovat akce v rámci jádra aplikace.
  • Řízené (sekundární) porty: Definují rozhraní, která jádro aplikace používá k interakci s externími systémy (např. databáze, fronty zpráv).
• Adaptéry: Implementují rozhraní definovaná porty. Fungují jako překladače mezi jádrem aplikace a externími systémy. Existují dva typy adaptérů:
  • Řídicí (primární) adaptéry: Implementují řídicí porty a překládají externí požadavky na příkazy nebo dotazy, kterým jádro aplikace rozumí. Příklady zahrnují komponenty uživatelského rozhraní (např. webové kontrolery), rozhraní příkazového řádku nebo posluchače front zpráv.
  • Řízené (sekundární) adaptéry: Implementují řízené porty a překládají požadavky jádra aplikace na konkrétní interakce s externími systémy. Příklady zahrnují objekty pro přístup k databázi, producenty front zpráv nebo klienty API.

Představte si to takto: jádro aplikace sedí uprostřed, obklopené šestiúhelníkovou skořápkou. Porty jsou vstupní a výstupní body na této skořápce a adaptéry se zapojují do těchto portů a spojují jádro s vnějším světem.

Klíčové principy hexagonální architektury

Účinnost hexagonální architektury je založena na několika klíčových principech:

• Inverze závislostí: Jádro aplikace závisí na abstrakcích (portech), nikoli na konkrétních implementacích (adaptérech). Toto je základní princip návrhu SOLID.
• Explicitní rozhraní: Porty jasně definují hranice mezi jádrem a vnějším světem a podporují přístup k integraci založený na smlouvách.
• Testovatelnost: Oddělením jádra od externích závislostí je snazší testovat obchodní logiku izolovaně pomocí falešných implementací portů.
• Flexibilita: Adaptéry lze vyměňovat bez ovlivnění jádra aplikace, což umožňuje snadné přizpůsobení se měnícím se technologiím nebo požadavkům. Představte si, že potřebujete přejít z MySQL na PostgreSQL; je třeba změnit pouze databázový adaptér.

Výhody používání hexagonální architektury

Přijetí hexagonální architektury nabízí řadu výhod:

• Vylepšená testovatelnost: Oddělení zájmů výrazně usnadňuje psaní jednotkových testů pro základní obchodní logiku. Mockování portů vám umožňuje izolovat jádro a důkladně jej testovat bez spoléhání se na externí systémy. Například platební modul lze testovat mockováním portu platební brány, simulací úspěšných a neúspěšných transakcí bez skutečného připojení ke skutečné bráně.
• Zvýšená udržovatelnost: Změny externích systémů nebo technologií mají minimální dopad na jádro aplikace. Adaptéry fungují jako izolační vrstvy, které chrání jádro před vnější volatilitou. Představte si scénář, kdy API třetí strany používané k odesílání SMS notifikací změní svůj formát nebo metodu autentizace. Je třeba aktualizovat pouze SMS adaptér, přičemž jádro aplikace zůstane nedotčeno.
• Vylepšená flexibilita: Adaptéry lze snadno přepínat, což vám umožní přizpůsobit se novým technologiím nebo požadavkům bez rozsáhlého refaktoringu. To usnadňuje experimentování a inovace. Společnost se může rozhodnout migrovat své úložiště dat z tradiční relační databáze do databáze NoSQL. S hexagonální architekturou je třeba vyměnit pouze databázový adaptér, čímž se minimalizuje narušení jádra aplikace.
• Snížené provázání: Jádro aplikace je odděleno od externích závislostí, což vede k modulárnějšímu a soudržnějšímu návrhu. Díky tomu je kód snáze pochopitelný, upravitelný a rozšiřitelný.
• Nezávislý vývoj: Různé týmy mohou pracovat na jádru aplikace a adaptérech nezávisle na sobě, což podporuje paralelní vývoj a rychlejší uvedení na trh. Například jeden tým by se mohl zaměřit na vývoj základní logiky zpracování objednávek, zatímco jiný tým by vytvářel uživatelské rozhraní a databázové adaptéry.

Implementace hexagonální architektury: Praktický příklad

Pojďme si ilustrovat implementaci hexagonální architektury na zjednodušeném příkladu systému registrace uživatelů. Pro jasnost použijeme hypotetický programovací jazyk (podobný Javě nebo C#).

1. Definujte jádro (aplikaci)

Jádro aplikace obsahuje obchodní logiku pro registraci nového uživatele.

// Core/UserService.java (or 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. Definujte porty

Definujeme porty, které jádro aplikace používá k interakci s vnějším světem.

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

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

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

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

3. Definujte adaptéry

Implementujeme adaptéry, které propojují jádro aplikace s konkrétními technologiemi.

// Adapters/DatabaseUserRepository.java (or 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 (or BCryptPasswordHasher.cs)
public class BCryptPasswordHasher implements PasswordHasher {
    @Override
    public String hash(String password) {
        // Implementation using BCrypt library
        // ...
        return "hashedPassword"; //Placeholder
    }
}

//Adapters/SimpleUserValidator.java (or 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 (or 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 (or 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. Kompozice

Propojení všeho dohromady. Všimněte si, že tato kompozice (injekce závislostí) se obvykle děje ve vstupním bodě aplikace nebo v kontejneru pro injekci závislostí.

//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)

}

Vysvětlení:

• UserService představuje základní obchodní logiku. Závisí na rozhraních UserRepository, PasswordHasher a UserValidator (portech).
• DatabaseUserRepository, BCryptPasswordHasher a SimpleUserValidator jsou adaptéry, které implementují příslušné porty pomocí konkrétních technologií (databáze, BCrypt a základní ověřovací logika).
• WebUserController je řídicí adaptér, který zpracovává webové požadavky a interaguje s UserService.
• Hlavní metoda skládá aplikaci, vytváří instance adaptérů a vkládá je do jádra aplikace.

Pokročilé úvahy a osvědčené postupy

Zatímco základní principy hexagonální architektury jsou přímočaré, je třeba mít na paměti některé pokročilé úvahy:

• Výběr správné granularity pro porty: Určení vhodné úrovně abstrakce pro porty je zásadní. Příliš jemně odstupňované porty mohou vést k zbytečné složitosti, zatímco příliš hrubě odstupňované porty mohou omezit flexibilitu. Zvažte kompromisy mezi jednoduchostí a přizpůsobivostí při definování portů.
• Správa transakcí: Při práci s více externími systémy může být zajištění transakční konzistence náročné. Zvažte použití technik distribuované správy transakcí nebo implementaci kompenzačních transakcí k zachování integrity dat. Například pokud registrace uživatele zahrnuje vytvoření účtu v samostatném fakturačním systému, musíte zajistit, aby obě operace proběhly úspěšně nebo neúspěšně společně.
• Zpracování chyb: Implementujte robustní mechanismy zpracování chyb, abyste elegantně zvládli selhání v externích systémech. Použijte jističe nebo mechanismy opakování, abyste zabránili kaskádovitým selháním. Pokud se adaptéru nepodaří připojit k databázi, aplikace by měla chybu elegantně zpracovat a potenciálně zopakovat připojení nebo poskytnout uživateli informativní chybovou zprávu.
• Testovací strategie: Použijte kombinaci jednotkových testů, integračních testů a komplexních testů, abyste zajistili kvalitu vaší aplikace. Jednotkové testy by se měly zaměřit na základní obchodní logiku, zatímco integrační testy by měly ověřit interakce mezi jádrem a adaptéry.
• Frameworky pro injekci závislostí: Využijte frameworky pro injekci závislostí (např. Spring, Guice) ke správě závislostí mezi komponentami a zjednodušení kompozice aplikace. Tyto frameworky automatizují proces vytváření a vkládání závislostí, snižují množství opakujícího se kódu a zlepšují udržovatelnost.
• CQRS (Oddělení odpovědnosti za příkazy a dotazy): Hexagonální architektura dobře ladí s CQRS, kde oddělujete modely pro čtení a zápis vaší aplikace. To může dále zlepšit výkon a škálovatelnost, zejména ve složitých systémech.

Příklady použití hexagonální architektury v reálném světě

Mnoho úspěšných společností a projektů přijalo hexagonální architekturu k budování robustních a udržovatelných systémů:

• Platformy elektronického obchodu: Platformy elektronického obchodu často používají hexagonální architekturu k oddělení základní logiky zpracování objednávek od různých externích systémů, jako jsou platební brány, přepravci a systémy správy zásob. To jim umožňuje snadno integrovat nové platební metody nebo možnosti dopravy bez narušení základní funkčnosti.
• Finanční aplikace: Finanční aplikace, jako jsou bankovní systémy a obchodní platformy, těží z testovatelnosti a udržovatelnosti, které nabízí hexagonální architektura. Základní finanční logiku lze důkladně testovat izolovaně a adaptéry lze použít k připojení k různým externím službám, jako jsou poskytovatelé tržních dat a clearingové domy.
• Architektury mikroslužeb: Hexagonální architektura je přirozeně vhodná pro architektury mikroslužeb, kde každá mikroslužba představuje ohraničený kontext s vlastní základní obchodní logikou a externími závislostmi. Porty a adaptéry poskytují jasnou smlouvu pro komunikaci mezi mikroslužbami, podporují volné provázání a nezávislé nasazení.
• Modernizace starších systémů: Hexagonální architekturu lze použít k postupné modernizaci starších systémů zabalením existujícího kódu do adaptérů a zavedením nové základní logiky za porty. To vám umožní postupně nahrazovat části staršího systému bez přepisování celé aplikace.

Výzvy a kompromisy

Zatímco hexagonální architektura nabízí značné výhody, je důležité si uvědomit související výzvy a kompromisy:

• Zvýšená složitost: Implementace hexagonální architektury může zavést další vrstvy abstrakce, které mohou zvýšit počáteční složitost kódu.
• Křivka učení: Vývojáři mohou potřebovat čas, aby pochopili koncepty portů a adaptérů a jak je efektivně aplikovat.
• Potenciál pro nadměrné inženýrství: Je důležité vyhnout se nadměrnému inženýrství vytvářením zbytečných portů a adaptérů. Začněte s jednoduchým návrhem a postupně přidávejte složitost podle potřeby.
• Úvahy o výkonu: Další vrstvy abstrakce mohou potenciálně zavést určité režie výkonu, i když je to ve většině aplikací obvykle zanedbatelné.

Je zásadní pečlivě vyhodnotit výhody a výzvy hexagonální architektury v kontextu vašich specifických požadavků projektu a schopností týmu. Není to stříbrná kulka a nemusí to být nejlepší volba pro každý projekt.

Závěr

Hexagonální architektura se svým důrazem na porty a adaptéry poskytuje výkonný přístup k budování udržovatelných, testovatelných a flexibilních aplikací. Oddělením základní obchodní logiky od externích závislostí vám umožňuje snadno se přizpůsobit měnícím se technologiím a požadavkům. I když je třeba zvážit výzvy a kompromisy, výhody hexagonální architektury často převažují nad náklady, zejména u složitých a dlouhodobých aplikací. Přijetím principů inverze závislostí a explicitních rozhraní můžete vytvořit systémy, které jsou odolnější, snáze pochopitelné a lépe vybavené pro splnění požadavků moderního softwarového prostředí.

Tato příručka poskytla komplexní přehled hexagonální architektury, od jejích základních principů až po praktické strategie implementace. Doporučujeme vám, abyste tyto koncepty dále prozkoumali a experimentovali s jejich aplikací ve vlastních projektech. Investice do učení a přijetí hexagonální architektury se nepochybně z dlouhodobého hlediska vyplatí a povede k softwaru vyšší kvality a spokojenějším vývojovým týmům.

Výběr správné architektury nakonec závisí na specifických potřebách vašeho projektu. Při rozhodování zvažte složitost, životnost a požadavky na udržovatelnost. Hexagonální architektura poskytuje pevný základ pro budování robustních a adaptabilních aplikací, ale je to jen jeden nástroj v sadě nástrojů softwarového architekta.