Heksagonālā arhitektūra: praktisks portu un adapteru ceļvedis

Nepārtraukti mainīgajā programmatūras izstrādes ainavā robustu, uzturamu un testējamu lietojumprogrammu veidošana ir vissvarīgākā. Heksagonālā arhitektūra, pazīstama arī kā porti un adapteri, ir arhitektūras šablons, kas risina šīs problēmas, atsaistot lietojumprogrammas galveno biznesa loģiku no tās ārējām atkarībām. Šī ceļveža mērķis ir sniegt visaptverošu izpratni par heksagonālo arhitektūru, tās priekšrocībām un praktiskām ieviešanas stratēģijām izstrādātājiem visā pasaulē.

Kas ir heksagonālā arhitektūra?

Heksagonālā arhitektūra, ko ieviesa Alisters Kokberns (Alistair Cockburn), balstās uz ideju izolēt lietojumprogrammas galveno biznesa loģiku no ārējās pasaules. Šī izolācija tiek panākta, izmantojot portus un adapterus.

• Kodols (lietojumprogramma): Pārstāv jūsu lietojumprogrammas sirdi, kas satur biznesa loģiku un domēna modeļus. Tam jābūt neatkarīgam no jebkuras konkrētas tehnoloģijas vai ietvara.
• Porti: Definē saskarnes, ko lietojumprogrammas kodols izmanto, lai mijiedarbotos ar ārējo pasauli. Tās ir abstraktas definīcijas tam, kā lietojumprogramma mijiedarbojas ar ārējām sistēmām, piemēram, datu bāzēm, lietotāja saskarnēm vai ziņojumu rindām. Porti var būt divu veidu:
  • Dzenošie (primārie) porti: Definē saskarnes, caur kurām ārējie dalībnieki (piemēram, lietotāji, citas lietojumprogrammas) var iniciēt darbības lietojumprogrammas kodolā.
  • Dzenamie (sekundārie) porti: Definē saskarnes, ko lietojumprogrammas kodols izmanto, lai mijiedarbotos ar ārējām sistēmām (piemēram, datu bāzēm, ziņojumu rindām).
• Adapteri: Ievieš saskarnes, ko definē porti. Tie darbojas kā tulki starp lietojumprogrammas kodolu un ārējām sistēmām. Ir divu veidu adapteri:
  • Dzenošie (primārie) adapteri: Ievieš dzenošos portus, tulkojot ārējos pieprasījumus komandās vai vaicājumos, ko lietojumprogrammas kodols var saprast. Piemēri ietver lietotāja saskarnes komponentus (piemēram, tīmekļa kontrolierus), komandrindas saskarnes vai ziņojumu rindu klausītājus.
  • Dzenamie (sekundārie) adapteri: Ievieš dzenamos portus, tulkojot lietojumprogrammas kodola pieprasījumus konkrētās mijiedarbībās ar ārējām sistēmām. Piemēri ietver datu bāzes piekļuves objektus, ziņojumu rindu producentus vai API klientus.

Iedomājieties to šādi: lietojumprogrammas kodols atrodas centrā, ko apņem heksagonāls apvalks. Porti ir ieejas un izejas punkti uz šī apvalka, un adapteri pieslēdzas šiem portiem, savienojot kodolu ar ārējo pasauli.

Heksagonālās arhitektūras galvenie principi

Vairāki galvenie principi ir pamatā heksagonālās arhitektūras efektivitātei:

• Atkarību inversija: Lietojumprogrammas kodols ir atkarīgs no abstrakcijām (portiem), nevis no konkrētām implementācijām (adapteriem). Tas ir viens no galvenajiem SOLID dizaina principiem.
• Skaidri definētas saskarnes: Porti skaidri definē robežas starp kodolu un ārējo pasauli, veicinot uz līgumiem balstītu pieeju integrācijai.
• Testējamība: Atsaistot kodolu no ārējām atkarībām, kļūst vieglāk testēt biznesa loģiku izolēti, izmantojot portu imitācijas (mock) implementācijas.
• Elastība: Adapterus var viegli nomainīt, neietekmējot lietojumprogrammas kodolu, kas ļauj viegli pielāgoties mainīgajām tehnoloģijām vai prasībām. Iedomājieties, ka nepieciešams pārslēgties no MySQL uz PostgreSQL; jāmaina tikai datu bāzes adapteris.

Heksagonālās arhitektūras izmantošanas priekšrocības

Heksagonālās arhitektūras pieņemšana piedāvā daudzas priekšrocības:

• Uzlabota testējamība: Pienākumu nodalīšana ievērojami atvieglo vienībtestu (unit tests) rakstīšanu galvenajai biznesa loģikai. Portu imitēšana (mocking) ļauj izolēt kodolu un rūpīgi to pārbaudīt, nepaļaujoties uz ārējām sistēmām. Piemēram, maksājumu apstrādes moduli var pārbaudīt, imitējot maksājumu vārtejas portu, simulējot veiksmīgus un neveiksmīgus darījumus, faktiski nepieslēdzoties reālajai vārtejai.
• Palielināta uzturējamība: Izmaiņām ārējās sistēmās vai tehnoloģijās ir minimāla ietekme uz lietojumprogrammas kodolu. Adapteri darbojas kā izolācijas slāņi, aizsargājot kodolu no ārējās nepastāvības. Apsveriet scenāriju, kurā trešās puses API, ko izmanto SMS paziņojumu sūtīšanai, maina savu formātu vai autentifikācijas metodi. Jāatjaunina tikai SMS adapteris, atstājot lietojumprogrammas kodolu neskartu.
• Uzlabota elastība: Adapterus var viegli nomainīt, ļaujot pielāgoties jaunām tehnoloģijām vai prasībām bez lielas pārstrādes. Tas veicina eksperimentēšanu un inovācijas. Uzņēmums varētu nolemt migrēt savu datu glabātuvi no tradicionālās relāciju datu bāzes uz NoSQL datu bāzi. Ar heksagonālo arhitektūru ir jānomaina tikai datu bāzes adapteris, minimizējot traucējumus lietojumprogrammas kodolam.
• Samazināta sasaiste: Lietojumprogrammas kodols ir atsaistīts no ārējām atkarībām, kas nodrošina modulārāku un saskaņotāku dizainu. Tas padara koda bāzi vieglāk saprotamu, modificējamu un paplašināmu.
• Neatkarīga izstrāde: Dažādas komandas var strādāt pie lietojumprogrammas kodola un adapteriem neatkarīgi, veicinot paralēlu izstrādi un ātrāku nonākšanu tirgū. Piemēram, viena komanda varētu koncentrēties uz galvenās pasūtījumu apstrādes loģikas izstrādi, kamēr cita komanda veido lietotāja saskarnes un datu bāzes adapterus.

Heksagonālās arhitektūras ieviešana: praktisks piemērs

Ilustrēsim heksagonālās arhitektūras ieviešanu ar vienkāršotu lietotāja reģistrācijas sistēmas piemēru. Skaidrības labad izmantosim hipotētisku programmēšanas valodu (līdzīgu Java vai C#).

1. Definējiet kodolu (lietojumprogrammu)

Lietojumprogrammas kodols satur biznesa loģiku jauna lietotāja reģistrēšanai.

// 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. Definējiet portus

Mēs definējam portus, ko lietojumprogrammas kodols izmanto, lai mijiedarbotos ar ārējo pasauli.

// 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. Definējiet adapterus

Mēs ieviešam adapterus, kas savieno lietojumprogrammas kodolu ar konkrētām tehnoloģijām.

// 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. Kompozīcija

Visa savienošana kopā. Ņemiet vērā, ka šī kompozīcija (atkarību injekcija) parasti notiek lietojumprogrammas ieejas punktā vai atkarību injekcijas konteinerā.

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

}

Paskaidrojums:

• UserService pārstāv galveno biznesa loģiku. Tas ir atkarīgs no UserRepository, PasswordHasher un UserValidator saskarnēm (portiem).
• DatabaseUserRepository, BCryptPasswordHasher un SimpleUserValidator ir adapteri, kas implementē attiecīgos portus, izmantojot konkrētas tehnoloģijas (datu bāzi, BCrypt un pamata validācijas loģiku).
• WebUserController ir dzenošais adapteris, kas apstrādā tīmekļa pieprasījumus un mijiedarbojas ar UserService.
• Galvenā metode veido lietojumprogrammas kompozīciju, izveidojot adapteru instances un injicējot tās lietojumprogrammas kodolā.

Padziļināti apsvērumi un labākā prakse

Lai gan heksagonālās arhitektūras pamatprincipi ir vienkārši, ir daži padziļināti apsvērumi, kas jāņem vērā:

• Pareizas portu granularitātes izvēle: Izšķiroša nozīme ir piemērota abstrakcijas līmeņa noteikšanai portiem. Pārāk smalki sadalīti porti var radīt nevajadzīgu sarežģītību, savukārt pārāk rupji porti var ierobežot elastību. Definējot portus, apsveriet kompromisus starp vienkāršību un pielāgojamību.
• Transakciju pārvaldība: Strādājot ar vairākām ārējām sistēmām, transakciju konsekvences nodrošināšana var būt sarežģīta. Apsveriet iespēju izmantot sadalītu transakciju pārvaldības metodes vai ieviest kompensējošas transakcijas, lai uzturētu datu integritāti. Piemēram, ja lietotāja reģistrācija ietver konta izveidi atsevišķā norēķinu sistēmā, jums ir jānodrošina, ka abas darbības izdodas vai neizdodas kopā.
• Kļūdu apstrāde: Ieviesiet robustus kļūdu apstrādes mehānismus, lai eleganti apstrādātu kļūmes ārējās sistēmās. Izmantojiet ķēdes pārtraucējus (circuit breakers) vai atkārtošanas mehānismus, lai novērstu kaskādes kļūmes. Ja adapteris nevar izveidot savienojumu ar datu bāzi, lietojumprogrammai ir eleganti jāapstrādā kļūda un, iespējams, jāatkārto savienojums vai jāsniedz informatīvs kļūdas ziņojums lietotājam.
• Testēšanas stratēģijas: Izmantojiet vienībtestu, integrācijas testu un pilnā cikla (end-to-end) testu kombināciju, lai nodrošinātu savas lietojumprogrammas kvalitāti. Vienībtestiem jākoncentrējas uz galveno biznesa loģiku, savukārt integrācijas testiem jāpārbauda mijiedarbība starp kodolu un adapteriem.
• Atkarību injekcijas ietvari: Izmantojiet atkarību injekcijas ietvarus (piemēram, Spring, Guice), lai pārvaldītu atkarības starp komponentiem un vienkāršotu lietojumprogrammas kompozīciju. Šie ietvari automatizē atkarību izveides un injicēšanas procesu, samazinot šablona kodu un uzlabojot uzturējamību.
• CQRS (Command Query Responsibility Segregation): Heksagonālā arhitektūra labi saskan ar CQRS, kur jūs atdalāt lietojumprogrammas lasīšanas un rakstīšanas modeļus. Tas var vēl vairāk uzlabot veiktspēju un mērogojamību, īpaši sarežģītās sistēmās.

Heksagonālās arhitektūras reālās pasaules piemēri

Daudzi veiksmīgi uzņēmumi un projekti ir pieņēmuši heksagonālo arhitektūru, lai izveidotu robustas un uzturamas sistēmas:

• E-komercijas platformas: E-komercijas platformas bieži izmanto heksagonālo arhitektūru, lai atsaistītu galveno pasūtījumu apstrādes loģiku no dažādām ārējām sistēmām, piemēram, maksājumu vārtejām, piegādes pakalpojumu sniedzējiem un krājumu pārvaldības sistēmām. Tas ļauj tām viegli integrēt jaunas maksājumu metodes vai piegādes iespējas, netraucējot galveno funkcionalitāti.
• Finanšu lietojumprogrammas: Finanšu lietojumprogrammas, piemēram, banku sistēmas un tirdzniecības platformas, gūst labumu no testējamības un uzturējamības, ko piedāvā heksagonālā arhitektūra. Galveno finanšu loģiku var rūpīgi pārbaudīt izolēti, un adapterus var izmantot, lai izveidotu savienojumu ar dažādiem ārējiem pakalpojumiem, piemēram, tirgus datu sniedzējiem un klīringa namiem.
• Mikropakalpojumu arhitektūras: Heksagonālā arhitektūra ir dabiski piemērota mikropakalpojumu arhitektūrām, kur katrs mikropakalpojums pārstāv ierobežotu kontekstu ar savu galveno biznesa loģiku un ārējām atkarībām. Porti un adapteri nodrošina skaidru līgumu saziņai starp mikropakalpojumiem, veicinot vāju sasaisti un neatkarīgu izvietošanu.
• Mantoto sistēmu modernizācija: Heksagonālo arhitektūru var izmantot, lai pakāpeniski modernizētu mantotās sistēmas, ietinot esošo kodu adapteros un ieviešot jaunu galveno loģiku aiz portiem. Tas ļauj pakāpeniski nomainīt mantotās sistēmas daļas, nepārrakstot visu lietojumprogrammu.

Izaicinājumi un kompromisi

Lai gan heksagonālā arhitektūra piedāvā ievērojamas priekšrocības, ir svarīgi apzināties ar to saistītos izaicinājumus un kompromisus:

• Paaugstināta sarežģītība: Heksagonālās arhitektūras ieviešana var ieviest papildu abstrakcijas slāņus, kas var palielināt koda bāzes sākotnējo sarežģītību.
• Mācīšanās līkne: Izstrādātājiem var būt nepieciešams laiks, lai izprastu portu un adapteru jēdzienus un to, kā tos efektīvi pielietot.
• Pārāk sarežģītas inženierijas potenciāls: Ir svarīgi izvairīties no pārmērīgas inženierijas, veidojot nevajadzīgus portus un adapterus. Sāciet ar vienkāršu dizainu un pakāpeniski pievienojiet sarežģītību pēc nepieciešamības.
• Veiktspējas apsvērumi: Papildu abstrakcijas slāņi var potenciāli radīt nelielu veiktspējas pieskaitāmo izmaksu, lai gan vairumā lietojumprogrammu tas parasti ir nenozīmīgi.

Ir ļoti svarīgi rūpīgi izvērtēt heksagonālās arhitektūras priekšrocības un izaicinājumus jūsu konkrētā projekta prasību un komandas spēju kontekstā. Tā nav brīnumlīdzeklis, un tā var nebūt labākā izvēle katram projektam.

Noslēgums

Heksagonālā arhitektūra, ar tās uzsvaru uz portiem un adapteriem, nodrošina jaudīgu pieeju uzturamu, testējamu un elastīgu lietojumprogrammu veidošanai. Atsaistot galveno biznesa loģiku no ārējām atkarībām, tā ļauj viegli pielāgoties mainīgām tehnoloģijām un prasībām. Lai gan ir jāņem vērā izaicinājumi un kompromisi, heksagonālās arhitektūras priekšrocības bieži vien atsver izmaksas, īpaši sarežģītām un ilgtermiņa lietojumprogrammām. Pieņemot atkarību inversijas un skaidri definētu saskarņu principus, jūs varat izveidot sistēmas, kas ir noturīgākas, vieglāk saprotamas un labāk aprīkotas, lai atbilstu mūsdienu programmatūras ainavas prasībām.

Šis ceļvedis ir sniedzis visaptverošu pārskatu par heksagonālo arhitektūru, sākot no tās pamatprincipiem līdz praktiskām ieviešanas stratēģijām. Mēs aicinām jūs turpināt pētīt šos jēdzienus un eksperimentēt, pielietojot tos savos projektos. Ieguldījums heksagonālās arhitektūras apguvē un pieņemšanā neapšaubāmi atmaksāsies ilgtermiņā, nodrošinot augstākas kvalitātes programmatūru un apmierinātākas izstrādes komandas.

Galu galā pareizās arhitektūras izvēle ir atkarīga no jūsu projekta specifiskajām vajadzībām. Pieņemot lēmumu, apsveriet sarežģītības, ilgmūžības un uzturēšanas prasības. Heksagonālā arhitektūra nodrošina stabilu pamatu robustu un pielāgojamu lietojumprogrammu veidošanai, taču tas ir tikai viens rīks programmatūras arhitekta rīku komplektā.