👋 Chào mừng đến với Nocoem — kiến thức Backend, System Design và lập trình. Khám phá ngay

Adapter Pattern: cục chuyển đổi giúp hai interface không khớp làm việc với nhau

TL;DR: Adapter là một pattern nhóm Structural, biến interface của một class thành interface khác mà client (bên gọi) mong đợi. Nhờ đó hai thứ vốn không khớp - ví dụ một thư viện cũ trả XML và một client chỉ biết gọi .get_json() - vẫn làm việc được với nhau, mà bạn không phải sửa cả hai. Trong Python, ta thường dùng object adapter (bọc bằng composition).

Bạn từng mang laptop sang nước khác và phát hiện phích cắm không vừa ổ điện chưa? Chân dẹt, chân tròn, khác chuẩn hoàn toàn. Bạn không đập tường đổi ổ điện, cũng không thay phích của laptop. Bạn mua một cục chuyển đổi (adapter) nhỏ: một đầu vừa ổ tường, một đầu vừa phích laptop. Cắm vào là chạy. Trong code cũng có đúng cái cục đó, và nó tên là Adapter.

Adapter là gì?

Adapter (bộ chuyển đổi) là một mẫu thiết kế cấu trúc (Structural pattern). Nhiệm vụ của nó: chuyển interface của một class thành một interface khác mà client mong đợi. Client và class kia vốn không nói chung một "ngôn ngữ" (tên method khác nhau, định dạng dữ liệu khác nhau), Adapter đứng giữa làm phiên dịch.

Quay lại cục chuyển ổ cắm. Ổ điện trên tường là một hệ thống có sẵn, bạn không đổi được. Phích laptop cũng cố định. Cục adapter không thay đổi bên nào cả: nó chỉ nhận hình dạng của bên này và trình ra hình dạng bên kia cần. Trong phần mềm, "hình dạng" chính là interface - tập hợp các method mà một bên gọi và một bên cung cấp.

Adapter khác với việc sửa code nguồn ở chỗ: nó không đụng vào cả client lẫn class được bọc. Nó là một tầng riêng, tháo ra lắp vào được, y như cục chuyển đổi rời chứ không phải hàn cứng vào ổ điện.

Vấn đề: hai interface không khớp

Tình huống rất hay gặp. Bạn đang viết một dashboard thời tiết. Client (phần vẽ giao diện) được thiết kế để làm việc với các nguồn dữ liệu qua một interface thống nhất: gọi .get_json(city) và nhận về chuỗi JSON. Sạch sẽ, đúng tinh thần program to an interface.

Nhưng công ty có sẵn một thư viện thời tiết cũ, đã chạy ổn định nhiều năm. Vấn đề: nó chỉ có method fetch_xml(city) và trả về... XML. Tên method khác, định dạng khác. Client không hiểu nó, nó không hiểu client.

Bạn có mấy lựa chọn. Sửa thư viện cũ ư? Không được, nó là dependency bên ngoài (hoặc code chung mà nhiều nơi khác đang xài, đụng vào là vỡ chỗ khác). Sửa client để nó biết cả JSON lẫn XML ư? Cũng tệ: client đang phụ thuộc vào một interface duy nhất, giờ nhét thêm nhánh xử lý XML vào là nó dính chặt lấy một cài đặt cụ thể, phá vỡ thiết kế. Mỗi nguồn dữ liệu lạ lại thêm một nhánh if, dần dần thành mớ bòng bong.

Đây đúng là lúc cần một cục chuyển đổi: một tầng riêng, nhận đầu vào của thư viện cũ và trình ra đúng interface mà client mong đợi.

Cách hoạt động: ví dụ Python chạy được

Ý tưởng: viết một class Adapter bọc (wrap) thư viện cũ. Adapter công bố đúng interface client cần (.get_json()), bên trong nó gọi method của thư viện cũ (.fetch_xml()) rồi dịch XML sang JSON. Client chỉ nhìn thấy Adapter, hoàn toàn không biết phía sau là đồ cũ trả XML.

import json
import xml.etree.ElementTree as ET

# --- Thu vien cu, khong sua duoc: chi tra du lieu dang XML ---
class LegacyWeatherAPI:
    def fetch_xml(self, city):
        return (
            "<weather>"
            f"<city>{city}</city>"
            "<temp>31</temp>"
            "<unit>C</unit>"
            "</weather>"
        )

# --- Client moi chi biet lam viec voi interface .get_json() ---
def render_dashboard(source, city):
    data = json.loads(source.get_json(city))
    return f"{data['city']}: {data['temp']} do {data['unit']}"

# --- Adapter: boc thu vien cu, doi fetch_xml() thanh get_json() ---
class WeatherJsonAdapter:
    def __init__(self, legacy):          # composition: giu tham chieu, khong ke thua
        self._legacy = legacy

    def get_json(self, city):
        xml = self._legacy.fetch_xml(city)
        root = ET.fromstring(xml)
        data = {child.tag: child.text for child in root}
        return json.dumps(data)

legacy = LegacyWeatherAPI()
adapter = WeatherJsonAdapter(legacy)
print(render_dashboard(adapter, "Da Nang"))
Da Nang: 31 do C

Để ý ba vai trò. Client là hàm render_dashboard, nó chỉ biết gọi .get_json(). Adaptee (bên bị bọc) là LegacyWeatherAPI, đồ cũ trả XML, không đụng một dòng. Adapter là WeatherJsonAdapter, đứng giữa dịch qua lại. Client chạy trơn tru mà không hề biết bên dưới là XML.

Object adapter vs class adapter

Cách ở trên là object adapter: Adapter giữ một tham chiếu tới đối tượng cũ (dòng self._legacy = legacy) rồi gọi qua nó. Đây là composition (quan hệ has-a), và là cách phổ biến nhất trong Python.

Còn class adapter thì kế thừa thẳng từ class cũ rồi bổ sung method mới:

class WeatherJsonAdapter(LegacyWeatherAPI):   # ke thua thang (is-a)
    def get_json(self, city):
        root = ET.fromstring(self.fetch_xml(city))
        return json.dumps({c.tag: c.text for c in root})

print(WeatherJsonAdapter().get_json("Da Nang"))
{"city": "Da Nang", "temp": "31", "unit": "C"}

Cả hai đều chạy, nhưng object adapter thường tốt hơn: nó ưu tiên composition hơn kế thừa, nên bọc được cả những class mà bạn không muốn (hoặc không thể) kế thừa, và không dính vào chi tiết nội bộ của class cũ. Class adapter thì gọn hơn chút, nhưng buộc quan hệ "is-a" cứng với đồ cũ - dễ vỡ khi lớp cha đổi. Vì vậy trong Python tôi mặc định chọn object adapter.

Duck typing. Python không bắt Adapter phải kế thừa một interface hình thức nào. Chỉ cần WeatherJsonAdapter có method get_json đúng chữ ký là render_dashboard dùng được ngay. Nhưng nếu muốn hợp đồng rõ ràng, bạn vẫn có thể khai báo một base class trừu tượng (ABC) cho phía nguồn dữ liệu.

Khi nào dùng, khi nào không

Dùng Adapter khi bạn cần tích hợp một class hay thư viện mà bạn không sửa được vào code đang mong một interface khác. Điển hình:

  • Bọc thư viện bên thứ ba (third-party) có API không khớp với phần còn lại của hệ thống.
  • Tích hợp code cũ (legacy) trong khi phần mới đã thống nhất một interface sạch.
  • Cho phép nhiều nguồn dữ liệu khác nhau (mỗi nguồn một định dạng) trình ra cùng một interface, để client viết một lần dùng cho tất cả.

Đừng dùng Adapter khi:

  • Bạn sửa được nguồn. Nếu class kia là code của bạn và bạn đổi được interface của nó, hãy sửa thẳng cho khớp thay vì thêm một tầng trung gian. Adapter thừa chỉ làm code khó lần theo.
  • Cần thay đổi cả hành vi, không chỉ hình dạng. Adapter chỉ dịch interface, không thêm logic nghiệp vụ mới. Nếu bạn muốn bọc để thêm tính năng (log, cache, kiểm tra quyền), thứ bạn cần là Decorator, không phải Adapter.
  • Chỉ có một nơi dùng và sẽ không đổi. Khi đó một hàm chuyển đổi nhỏ có khi đủ, chưa cần nâng lên thành class.

Có một điểm đáng nhấn: Adapter sống được là nhờ client đã program to an interface. Chính vì render_dashboard chỉ phụ thuộc vào cái interface .get_json() chứ không phụ thuộc class cụ thể, nên ta mới có thể lén thay bằng một Adapter mà nó không hề hay biết. Không có nguyên tắc nền đó, Adapter cũng hết đất diễn.

Trong hệ thống thật

Chỗ tôi gặp Adapter nhiều nhất là biên giới giữa hệ thống của mình và thế giới bên ngoài. Vài tình huống cụ thể:

  • Bọc SDK của nhà cung cấp. Thanh toán là ví dụ kinh điển. Bạn định nghĩa một interface của riêng mình, chẳng hạn PaymentGateway với .pay() và .refund(), rồi viết StripeAdapter và VnpayAdapter cùng trình ra interface đó. Phần còn lại của hệ thống chỉ thấy PaymentGateway, không biết bên dưới là ai. Nhờ vậy đổi nhà cung cấp là viết thêm một adapter, không phải đi sửa rải rác khắp nơi.
  • Adapter cho hệ thống cũ (legacy). Service nội bộ mười năm tuổi trả về XML, hoặc trả JSON nhưng tên trường kiểu cust_nm, dt_crt, trong khi code mới dùng customer_name, created_at. Một adapter đứng giữa lo việc đổi tên và đổi định dạng, còn hệ cũ không phải động dao kéo.
  • Lớp mỏng cho thư viện bên thứ ba. Bạn khai báo một Protocol nội bộ (kiểu Cache với .get() và .set()) rồi cho adapter của Redis khớp vào. Khi test, bạn thay adapter bằng một bản giả (fake) dùng dict trong bộ nhớ, không cần dựng Redis thật.
  • Adapter giữa hai phiên bản API. Đang di chuyển dần từ v1 sang v2, bạn để một adapter dịch request và response giữa hai bên. Những phần chưa kịp chuyển vẫn chạy, chuyển xong thì gỡ adapter ra.

Điểm tôi muốn nhấn: Adapter là chỗ để nhốt sự khác biệt của bên ngoài lại một nơi. Mọi thứ lạ của nhà cung cấp, từ tên trường kỳ cục, đơn vị tiền tính bằng cent, cho đến định dạng ngày tháng riêng, đều dừng lại ở trước cửa adapter.

Và đây là phần rất hay bị quên: adapter cũng là chỗ dịch lỗi của họ thành lỗi của mình. Nếu stripe.error.CardError rò ra khắp code nghiệp vụ thì bạn đã bỏ công bọc SDK để rồi vẫn phụ thuộc vào nó, chỉ là phụ thuộc qua đường ngoại lệ. Hãy bắt lỗi của SDK ngay trong adapter và ném lại bằng exception của bạn:

class PaymentError(Exception):
    """Loi thanh toan cua he thong minh, khong dinh gi toi nha cung cap."""

class CardDeclined(PaymentError):
    pass

# --- SDK ben ngoai: loi rieng cua ho ---
class StripeCardError(Exception):
    def __init__(self, code, message):
        super().__init__(message)
        self.code = code

class StripeSDK:
    def charge(self, amount_cents, token):
        if token == "tok_bad":
            raise StripeCardError("card_declined", "Your card was declined.")
        return {"id": "ch_123", "amount": amount_cents, "status": "succeeded"}

# --- Adapter: trinh ra interface cua minh, dich ca du lieu lan loi ---
class StripeAdapter:
    def __init__(self, sdk):
        self._sdk = sdk

    def pay(self, amount_vnd, token):
        try:
            res = self._sdk.charge(int(amount_vnd / 250), token)
        except StripeCardError as e:
            raise CardDeclined(f"the tu choi ({e.code})") from e
        return {"ref": res["id"], "ok": res["status"] == "succeeded"}

gateway = StripeAdapter(StripeSDK())
print(gateway.pay(250000, "tok_ok"))
try:
    gateway.pay(250000, "tok_bad")
except PaymentError as e:
    print("PaymentError:", e)
{'ref': 'ch_123', 'ok': True} PaymentError: the tu choi (card_declined)

Code nghiệp vụ chỉ cần bắt PaymentError. Mai này bạn thay Stripe bằng VNPAY, chỉ có StripeAdapter bị xóa đi, câu except PaymentError ở tầng trên không đổi một chữ.

Adapter ở đây vẫn chỉ dịch: đổi đơn vị, đổi tên trường, đổi kiểu lỗi. Nó không quyết định có retry hay không, không ghi sổ kế toán, không gửi mail. Những thứ đó là nghiệp vụ, và chúng thuộc về tầng trên.

Trade-off

Adapter rẻ và dễ viết, nhưng không miễn phí. Đặt lên bàn cân cho rõ.

Được:

  • Dùng được những đoạn code bạn không sửa được: thư viện đóng, SDK nhà cung cấp, hệ cũ không ai dám đụng.
  • Cô lập phụ thuộc bên ngoài vào một chỗ. Cần biết hệ thống chạm vào Stripe ở đâu? Mở đúng một file.
  • Đổi nhà cung cấp rẻ hơn nhiều: viết adapter mới, đổi chỗ khởi tạo, phần còn lại giữ nguyên.
  • Dễ test. Interface là của bạn, nên bạn viết được một bản giả gọn nhẹ để thay vào, không cần gọi mạng trong unit test.

Phải trả giá:

  • Thêm một tầng phải bảo trì. Bên ngoài đổi API là bạn phải đồng bộ lại adapter, không ai làm thay.
  • Adapter rất dễ bị nhét thêm logic nghiệp vụ vào: một câu if cho khách VIP, một lần retry, rồi nó phình thành class không ai dám sửa.
  • Ánh xạ khái niệm hiếm khi khớp hoàn toàn. Bên họ có trường bạn không dùng, bên bạn cần trường họ không có, thế là mất thông tin hoặc phải bịa một giá trị mặc định, mà giá trị bịa thì sau này hay thành bug.
  • Thêm một tầng dịch nữa khi debug. Stack trace dài hơn, và đôi khi bạn phải mất công chứng minh lỗi nằm ở adapter hay ở phía nhà cung cấp.

Khi sự khác biệt không nằm ở tên method mà nằm ở cả một cụm thao tác phức tạp, thứ bạn cần có thể là Facade, một cửa vào gọn cho cả hệ con. Còn nếu bạn muốn hai trục thay đổi độc lập ngay từ đầu chứ không phải chắp vá về sau, hãy xem Bridge.

Tóm tắt

  • Adapter chuyển interface của một class thành interface mà client mong đợi, để hai bên vốn không khớp làm việc được với nhau - như cục chuyển đổi ổ cắm khi đi nước ngoài.
  • Ba vai trò: Client (bên gọi), Adaptee (đồ cũ bị bọc, không sửa), Adapter (tầng giữa dịch interface).
  • Object adapter (composition, giữ tham chiếu) là lựa chọn mặc định trong Python; class adapter (kế thừa) gọn hơn nhưng cứng hơn.
  • Dùng khi tích hợp thư viện hay code không sửa được. Không dùng khi bạn sửa thẳng nguồn được, hoặc khi thứ bạn cần là thêm hành vi (đó là Decorator).
  • Adapter phát huy được là nhờ client đã phụ thuộc vào interface chứ không vào class cụ thể.
Series Design Patterns - nhóm Structural. Adapter là một trong các pattern nhóm Structural (lo về cách ghép các class và đối tượng thành cấu trúc lớn hơn). Nếu chưa vững phần nền, đọc lại Program to interface & Composition over inheritance và SOLID - hai bài này giải thích vì sao Adapter hoạt động được. Xem toàn bộ lộ trình ở mục lục Design Patterns.

- Kai

Thấy bài viết hữu ích?

0 lượt thích

Đăng nhận xét