Mateusz Przybyła

Struktura wzorca

Diagram UML przedstawia schemat działania systemu przed pojawieniem się nowej wersji API.

Klasa BookConnector pełni rolę klienta (Client) i komunikuje się bezpośrednio z interfejsem LibraryAPI (Target), który definiuje kontrakt dostępu do biblioteki.

Zależność wygląda następująco:

Wraz z pojawieniem się nowego API (Adaptee) zmienił się kontrakt metod — zarówno w zakresie argumentów, jak i typów zwracanych wartości.

Aby uniknąć modyfikacji klasy BookConnector, wprowadzono wzorzec Adapter.

Nowa struktura wygląda następująco:

Struktura plików

• adapter
  • user.py -> definiuje encję domenową (User)
  • library_api.py -> stary interfejs (LibraryAPI)
  • library_api_new.py -> nowe API (LibraryAPINew)
  • library_api_adapter.py -> Adapter implementujący stary interfejs i tłumaczący wywołania do nowego API
  • book_connector.py -> klient, który korzysta ze starego interfejsu API
  • main.py -> przykład użycia

Kod źródłowy

user.py

from datetime import date
from dataclasses import dataclass

@dataclass
class User:
    first_name: str
    last_name: str
    email: str
    date_of_birth: date

    def __str__(self) -> str:
        return f"{self.first_name} {self.last_name} ({self.email})"
Code language: Python (python)

library_api.py

from abc import ABC, abstractmethod
from datetime import date

class LibraryAPI(ABC):
    @abstractmethod
    def is_book_available(self, isbn: str) -> bool:
        pass

    @abstractmethod
    def get_return_date(
        self, 
        isbn: str, 
        first_name: str, 
        last_name: str, 
        date_of_birth: date
    ) -> date:
        pass

    @abstractmethod
    def reserve_book(
        self, 
        isbn: str, 
        first_name: str, 
        last_name: str, 
        date_of_birth: date
    ) -> bool:
        pass
Code language: Python (python)

library_api_new.py

from datetime import date, timedelta

class LibraryAPINew:
    def number_of_available_copies(self, isbn: str) -> int:
        print(f"Checking copies for ISBN: {isbn}...")
        return 3

    def get_return_date(self, isbn: str, email: str) -> date:
        print(f"Getting return date for {email}, ISBN: {isbn}...")
        return date.today() + timedelta(days=14)

    def reserve_book(self, isbn: str, email: str) -> bool:
        print(f"Reserving book for {email}, ISBN: {isbn}...")
        return True
Code language: Python (python)

library_api_adapter.py

from datetime import date
from library_api import LibraryAPI
from library_api_new import LibraryAPINew
   
class LibraryAPIAdapter(LibraryAPI):
    def __init__(self, new_api: LibraryAPINew):
        self._new_api = new_api

    def is_book_available(self, isbn: str) -> bool:
        # The NEW API returns an int, but the old contract requires a bool
        return self._new_api.number_of_available_copies(isbn) > 0

    def get_return_date(
        self,
        isbn: str,
        first_name: str,
        last_name: str,
        date_of_birth: date
    ) -> date:
        # In a production environment, the email would be retrieved from the database.
        # Here we generate it artificially solely for demonstration purposes.
        email = self._build_email(first_name, last_name)

        return self._new_api.get_return_date(isbn, email)

    def reserve_book(
        self,
        isbn: str,
        first_name: str,
        last_name: str,
        date_of_birth: date
    ) -> bool:
        email = self._build_email(first_name, last_name)

        return self._new_api.reserve_book(isbn, email)

    def _build_email(self, first_name: str, last_name: str) -> str:
        return f"{first_name.lower()}.{last_name.lower()}@example.com"
Code language: Python (python)

book_connector.py

from datetime import date
from library_api import LibraryAPI
from user import User

class BookConnector:
    def __init__(self, api: LibraryAPI):
        self._api = api

    def check_availability(self, isbn: str) -> bool:
        return self._api.is_book_available(isbn)
    
    def check_return_date(self, isbn: str, user: User) -> date:
        return self._api.get_return_date(
            isbn,
            user.first_name,
            user.last_name,
            user.date_of_birth
        )

    def reserve(self, isbn: str, user: User) -> bool:
        return self._api.reserve_book(
            isbn,
            user.first_name,
            user.last_name,
            user.date_of_birth
        )
Code language: Python (python)

main.py

from datetime import date
from library_api_new import LibraryAPINew
from library_api_adapter import LibraryAPIAdapter
from book_connector import BookConnector
from user import User

if __name__ == "__main__":
    isbn = "978-3-16-148410-0"

    user = User(
        "Mateusz",
        "Przybyla",
        "mateusz.przybyla@example.com",
        date(1995, 5, 12)
    )

    print("--- Using new API via Adapter ---")

    new_api = LibraryAPINew()
    adapter = LibraryAPIAdapter(new_api)
    connector = BookConnector(adapter)

    print("Available:", connector.check_availability(isbn))
    print("Reserved:", connector.reserve(isbn, user))
    print("Return date:", connector.check_return_date(isbn, user))
Code language: Python (python)