Mit tud az portok és adapterek architektúrájáról…

A portok és adapterek architektúrája, más néven hexagonális architektúra (Hexagonal Architecture), elválasztja az alkalmazás domain logikáját (Core) a külső függőségektől (felhasználói felületek, adatbázisok, külső szolgáltatások).

Fő fogalmak:

Portok: Meghatározzák az interfészeket, amelyeken keresztül a Core kapcsolatba lép a külső világgal. Két típusuk van:
- Bemeneti portok (Driving Ports): Külső entitások használják a Core funkcionalitásának hívására (pl. API interfész).
- Kimeneti portok (Driven Ports): A Core használja a külső entitások funkcionalitásának hívására (pl. repository interfész az adatokhoz való hozzáféréshez).
Adapterek: Implementálják a portokat, összekötve a Core-t konkrét külső technológiákkal vagy framework-ökkel.
- Bemeneti adapterek (Driving Adapters): Implementálják a bemeneti portokat, és a külső környezetből érkező kéréseket a Core hívásaira alakítják (pl. REST controller).
- Kimeneti adapterek (Driven Adapters): Implementálják a kimeneti portokat, és a Core-ból érkező hívásokat a külső környezettel való kommunikációra alakítják (pl. repository implementáció konkrét adatbázissal).
Core (Domain): Tartalmazza az alkalmazás üzleti logikáját. Teljesen elszigetelt a külső részletektől, és csak portokon keresztül lép kapcsolatba velük.

Előnyök:

Tesztelhetőség: A Core izolálása megkönnyíti az üzleti logika egységtesztelését anélkül, hogy komplex külső függőségeket kellene mock-olni.
Rugalmasság: Könnyen cserélhető vagy hozzáadható új külső technológiák (adatbázisok, frameworkök) anélkül, hogy a Core módosulna. Csak írni kell egy új adaptert a meglévő porthoz.
Tiszta kód: Segít tisztább és könnyebben karbantartható kód létrehozásában, a Core csak az üzleti szabályokra koncentrálva.
Felelősségek szétválasztása: Világosan elkülöníti a felelősségi területeket.

Kapcsolat a Frontenddel:

A frontendben a portok és adapterek architektúrája a következőkre alkalmazható:

Az üzleti logika elkülönítése a komponens adatforrásaitól: A komponens a "port"-tal (interfész) kommunikál, amit különböző "adapter"-ek valósíthatnak meg (API-ból, Local Storage-ból, teszt mock-okból származó adatok).*
Külső események kezelése: A bemeneti portok reprezentálhatnak UI eseménykezelőket, az adapterek pedig ezeket az eseményeket a belső logikára alakítják.
A külső könyvtárakkal való kommunikáció inkapszulálása: Az adapterek burkolhatják a harmadik féltől származó könyvtárak (pl. térképes könyvtárak) hívásait, egyszerű és stabil interfészt biztosítva a Core számára.

Példa JavaScriptben (séma):

// Példa kimeneti port (interfész az adatok lekéréséhez)
class DataGateway {
  getData() {
    throw new Error("A getData metódusnak meg kell valósulnia");
  }
}

// Kimeneti adapter példa (port implementáció API-hoz)
class ApiDataGateway extends DataGateway {
  async getData() {
    const response = await fetch('/api/data');
    return response.json();
  }
}

// Bemeneti port példa (interfész az üzleti logikához)
class BusinessLogicPort {
  constructor(dataGateway) {
    this.dataGateway = dataGateway;
  }

  async processData() {
    throw new Error("A processData metódusnak meg kell valósulnia");
  }
}

// Core példa (üzleti logika)
class MyBusinessLogic extends BusinessLogicPort {
  async processData() {
    const data = await this.dataGateway.getData();
    // Adatok feldolgozási logika
    console.log("Adatok feldolgozva:", data);
    return data;
  }
}

// Bemeneti adapter példa (üzleti logika UI-ban való használata)
async function initApp() {
  const apiGateway = new ApiDataGateway(); // Konkrét adapter
  const businessLogic = new MyBusinessLogic(apiGateway); // Core portot használ
  await businessLogic.processData(); // Bemeneti adapter hívja a Core-t
}

initApp();

Mit tud az portok és adapterek architektúrájáról?