Python Design Patterns: Bridge

Bridge là một mẫu thiết kế cấu trúc chia logic nghiệp vụ hoặc lớp khổng lồ thành các cấu trúc phân cấp lớp riêng biệt có thể được phát triển độc lập.

Một trong những cấu trúc phân cấp này (thường được gọi là Trừu tượng) sẽ nhận được một tham chiếu đến một đối tượng của cấu trúc phân cấp thứ hai (Hiện thực). Phần trừu tượng sẽ có thể ủy quyền một số (đôi khi, hầu hết) các lệnh gọi của nó cho đối tượng hiện thực. Vì tất cả các hiện thực sẽ có một giao diện chung nên chúng có thể hoán đổi cho nhau bên trong phần trừu tượng.

Cách sử dụng mẫu

Sử dụng: Mẫu Bridge đặc biệt hữu ích khi xử lý các ứng dụng đa nền tảng, hỗ trợ nhiều loại máy chủ cơ sở dữ liệu hoặc làm việc với một số nhà cung cấp API thuộc một loại nhất định (ví dụ: nền tảng đám mây, mạng xã hội, v.v.)

Nhận dạng: Bridge có thể được nhận ra bởi sự phân biệt rõ ràng giữa một số thực thể kiểm soát và một số nền tảng khác nhau mà nó dựa vào.

Chương trình mẫu

main.py

from __future__ import annotations
from abc import ABC, abstractmethod


class Abstraction:
    """
    Abstraction định nghĩa giao diện cho phần "điều khiển" của hai phân cấp lớp.
    Nó duy trì một tham chiếu đến một đối tượng của hệ thống phân cấp 
    Implementation và ủy quyền tất cả công việc thực cho đối tượng này.
    """

    def __init__(self, implementation: Implementation) -> None:
        self.implementation = implementation

    def operation(self) -> str:
        return (f"Abstraction: Base operation with:\n"
                f"{self.implementation.operation_implementation()}")


class ExtendedAbstraction(Abstraction):
    """
    Có thể mở rộng Abstraction  mà không cần thay đổi các lớp Implementation.
    """

    def operation(self) -> str:
        return (f"ExtendedAbstraction: Extended operation with:\n"
                f"{self.implementation.operation_implementation()}")


class Implementation(ABC):
    """
    Implementation xác định giao diện cho tất cả các lớp hiện thực. Nó không nhất 
    thiết phải phù hợp với giao diện của Abstraction. Trên thực tế, hai giao diện 
    có thể hoàn toàn khác nhau. Thông thường, giao diện Implementation chỉ cung 
    cấp các hoạt động nguyên thủy, trong khi Abstraction xác định các hoạt động
    cấp cao hơn dựa trên các nguyên thủy đó.
    """

    @abstractmethod
    def operation_implementation(self) -> str:
        pass


"""
Mỗi Concrete Implementation  tương ứng với một nền tảng cụ thể và triển 
khai giao diện Implementation bằng cách sử dụng API của nền tảng đó.
"""


class ConcreteImplementationA(Implementation):
    def operation_implementation(self) -> str:
        return "ConcreteImplementationA: Here's the result on the platform A."


class ConcreteImplementationB(Implementation):
    def operation_implementation(self) -> str:
        return "ConcreteImplementationB: Here's the result on the platform B."


def client_code(abstraction: Abstraction) -> None:
    """
    Ngoại trừ giai đoạn khởi tạo, trong đó một đối tượng Abstraction được liên 
    kết với một đối tượng Implementation cụ thể, Client chỉ nên phụ thuộc vào  
    lớp Abstraction . Bằng cách này, Client có thể hỗ trợ bất kỳ kết hợp 
    hiện thực - trừu tượng nào.
    """

    # ...

    print(abstraction.operation(), end="")

    # ...


if __name__ == "__main__":
    """
    Client phải có thể hoạt động với bất kỳ tổ hợp hiện thực - trừu tượng
    nào được định cấu hình trước.
    """

    implementation = ConcreteImplementationA()
    abstraction = Abstraction(implementation)
    client_code(abstraction)

    print("\n")

    implementation = ConcreteImplementationB()
    abstraction = ExtendedAbstraction(implementation)
    client_code(abstraction)

Kết quả

Abstraction: Base operation with:
ConcreteImplementationA: Here's the result on the platform A.

ExtendedAbstraction: Extended operation with:
ConcreteImplementationB: Here's the result on the platform B.