რა იცით პორტებისა და ადაპტერების არქიტექტურაზე?

პორტებისა და ადაპტერების არქიტექტურა, ასევე ცნობილი როგორც ჰექსაგონალური არქიტექტურა (Hexagonal Architecture), გამოყოფს აპლიკაციის საგნობრივი ლოგიკას (Core) გარე დამოკიდებულებებიდან (მომხმარებლის ინტერფეისები, მონაცემთა ბაზები, გარე სერვისები).

ძირითადი კონცეფციები:

• პორტები: განსაზღვრავენ ინტერფეისებს, რომელთა მეშვეობითაც Core ურთიერთქმედებს გარე სამყაროსთან. პორტები იყოფა ორ ტიპად:
  • შესასვლელი (Driving Ports): გამოიყენება გარე სუბიექტების მიერ Core-ის ფუნქციონალის გამოძახებისთვის (მაგალითად, API-ინტერფეისი).
  • გამოსავალი (Driven Ports): გამოიყენება Core-ის მიერ გარე სუბიექტების ფუნქციონალის გამოძახებისთვის (მაგალითად, მონაცემთა ბაზის ინტერფეისი).
• ადაპტერები: რეალიზებენ პორტებს, აკავშირებენ Core-ს კონკრეტულ გარე ტექნოლოგიებთან ან ფრეიმვორკებთან:
  • შესასვლელი (Driving Adapters): რეალიზებენ შესასვლელ პორტებს და გარდაქმნიან გარე გარემოდან შემოსულ მოთხოვნებს Core-ის გამოძახილებად, მაგალითად, REST-კონტროლერი.
  • გამოსავალი (Driven Adapters): რეალიზებენ გამოსავალ პორტებს და გარდაქმნიან Core-დან გამავალი გამოძახილებს გარე გარემოსთან ურთიერთქმედებისთვის, მაგალითად, კონკრეტული მონაცემთა ბაზის რეპოზიტორის რეალიზაცია.
• Core (საგნობრივი სფერო): შეიცავს აპლიკაციის ბიზნეს-ლოგიკას. იგი სრულად იზოლირებულია გარე დეტალებისგან და ურთიერთქმედებს მათთან მხოლოდ პორტების მეშვეობით.

უპირატესობები:

• ტესტირების შესაძლებლობა: Core-ის იზოლაცია ამარტივებს ბიზნეს-ლოგიკის ერთეულური ტესტირებას, საჭირო არ არის რთული გარე დამოკიდებულებების მოკირება.
• სწრაფობა: ადვილად შესაძლებელია ახალი გარე ტექნოლოგიების (მონაცემთა ბაზები, ფრეიმვორკები) შეცვლა ან დამატება, دون Core-ის შეცვლის, საკმარისია ახალი ადაპტერის დაწერა არსებული პორტისთვის.
• სუფთა კოდი: ხელს უწყობს უფრო სუფთა და შენარჩუნებად კოდის შექმნას, ყურადღება მხოლოდ ბიზნეს-წესრიგებზე.
• პასუხისმგებლობის განყოფილება: მკაფიოდ ყოფს პასუხისმგებლობის ზონებს.

ფრონტენდთან კავშირი:

ფრონტენდში პორტებისა და ადაპტერების არქიტექტურა გამოიყენება:

• ბიზნეს-ლოგიკის და მონაცემთა წყაროს განყოფილება: კომპონენტი ურთიერთქმედებს "პორტთან" (ინტერფეისთან), რომელიც შეიძლება განხორციელდეს სხვადასხვა "ადაპტერებით" (API-ებით, ლოკალური შენახვით, ტესტური მოკებით და ა.შ).
• გარე მოვლენის დამუშავება: შესასვლელი პორტები შეიძლება წარმოადგენდეს UI-ის მოვლენის დამუშავებლებს, ხოლო ადაპტერები გარდაქმნიან ამ მოვლენებს შიდა ლოგიკის გამოძახილებად.
• გარე ბიბლიოთეკების ურთიერთქმედების ინკაფსულაცია: ადაპტერები შეიძლება ჩაახშოს გარე ბიბლიოთეკების მიმართვები, მაგალითად, რუკების სამუშაო ბიბლიოთეკა, და უზრუნველყოს Core-ის მარტივი და სტაბილური ინტერფეისი.

JavaScript-ის მაგალითი (შეგნობა):

// გამოსავალი პორტის მაგალითი (მონაცემების მიღების ინტერფეისი)
class DataGateway {
  getData() {
    throw new Error("getData მეთოდი უნდა განხორციელდეს");
  }
}

// გამოსავალი ადაპტერის მაგალითი (API-ისთვის)
class ApiDataGateway extends DataGateway {
  async getData() {
    const response = await fetch('/api/data');
    return response.json();
  }
}

// შესასვლელი პორტის მაგალითი (ბიზნეს-ლოგიკისთვის)
class BusinessLogicPort {
  constructor(dataGateway) {
    this.dataGateway = dataGateway;
  }

  async processData() {
    throw new Error("processData მეთოდი უნდა განხორციელდეს");
  }
}

// Core-ის მაგალითი (ბიზნეს-ლოგიკა)
class MyBusinessLogic extends BusinessLogicPort {
  async processData() {
    const data = await this.dataGateway.getData();
    // მონაცემების დამუშავების ლოგიკა
    console.log("მონაცემები დამუშავებულია:", data);
    return data;
  }
}

// შესასვლელი ადაპტერის მაგალითი (UI-ში გამოყენება)
async function initApp() {
  const apiGateway = new ApiDataGateway(); // კონკრეტული ადაპტერის მაგალითი
  const businessLogic = new MyBusinessLogic(apiGateway); // Core იყენებს პორტს
  await businessLogic.processData(); // შესასვლელი ადაპტერის გამოძახება Core-დან
}

initApp();