Bạn có một đối tượng nặng: tải chậm, tốn RAM, hoặc nằm ở server khác. Bạn muốn kiểm soát khi nào nó thật sự được dùng, hoặc thêm một lớp kiểm tra trước khi cho ai đó chạm vào nó. Nhưng bạn không muốn sửa đối tượng đó, cũng không muốn client phải học một cách gọi mới. Proxy sinh ra cho đúng tình huống này: một đối tượng đại diện, giả dạng đối tượng thật, đứng ra nhận lệnh trước.
Proxy là gì, có mấy loại
Proxy nghĩa đen là "người/vật được uỷ quyền đại diện". Trong lập trình, proxy là một object cài cùng interface với đối tượng thật (gọi là real subject) và giữ một tham chiếu tới đối tượng thật đó. Mọi lời gọi từ client đi vào proxy trước; proxy quyết định có chuyển tiếp tới đối tượng thật hay không, và làm thêm việc gì quanh lời gọi đó.
Vì cùng interface, client không phân biệt được đang cầm proxy hay đối tượng thật. Đó là điểm cốt lõi: bạn tráo proxy vào chỗ đối tượng thật mà không ai bên ngoài phải sửa gì.
Có vài loại proxy hay gặp, phân theo mục đích kiểm soát:
- Virtual proxy (proxy ảo): hoãn việc tạo đối tượng nặng cho tới khi thật sự cần (lazy loading). Ví dụ: chỉ đọc ảnh từ đĩa vào bộ nhớ khi lần đầu hiển thị.
- Protection proxy (proxy bảo vệ): kiểm tra quyền trước khi cho gọi. Ví dụ: chỉ user có role admin mới được gọi method xoá.
- Caching proxy (proxy nhớ đệm): nhớ kết quả của lời gọi tốn kém, lần sau trả lại kết quả cũ thay vì tính lại.
- Remote proxy (proxy từ xa): đại diện cho một đối tượng nằm ở tiến trình hoặc máy khác; proxy lo phần gửi/nhận qua mạng để client gọi như gọi local.
Một hình dung gần gũi: cái thẻ ATM. Thẻ không phải là tiền, cũng không phải là tài khoản của bạn; nó là đại diện cho tài khoản. Khi bạn quẹt thẻ, hệ thống kiểm tra mã PIN, kiểm tra số dư, ghi log, rồi mới cho chạm tới tài khoản thật. Thẻ (proxy) kiểm soát truy cập tới tài khoản (real subject) mà bạn không bao giờ cầm trực tiếp "cục tiền" trong ngân hàng.
Hoặc gần với công việc hơn: một trợ lý lọc lịch hẹn trước khi tới sếp. Bạn muốn gặp sếp thì nói với trợ lý; trợ lý xem lịch còn trống không, việc có đáng để làm phiền không, rồi mới xếp cho bạn vào. Trợ lý cùng "interface" với sếp ở chỗ bạn vẫn đặt được lịch, nhưng đứng giữa để kiểm soát.
Vấn đề nếu không có proxy
Giả sử app của bạn có một thư viện ảnh. Mỗi RealImage khi tạo ra là đọc file từ đĩa vào bộ nhớ ngay. Nếu bạn tạo cả trăm ảnh lúc mở màn hình danh sách, app khựng một nhịp dài vì phải tải hết, dù người dùng có thể chỉ xem vài tấm đầu.
Cách "vá" tự nhiên là nhét logic hoãn tải thẳng vào chỗ dùng: chỗ nào cần ảnh thì viết thêm câu if kiểm tra "đã tải chưa, chưa thì tải". Nhưng logic đó rải khắp nơi, lặp đi lặp lại, và trộn lẫn chuyện tải ảnh với chuyện hiển thị. Sửa cách tải (thêm cache, đổi nguồn) là phải sục vào mọi chỗ.
Bạn cũng không muốn nhồi logic đó vào chính RealImage, vì nhiệm vụ của nó chỉ nên là "giữ và hiển thị ảnh", không phải "tự quyết khi nào mình được tải". Trộn hai việc vào một class là vi phạm nguyên tắc trách nhiệm đơn (chữ S trong SOLID).
Proxy tách phần "kiểm soát khi nào tải" ra một đối tượng riêng, đứng trước RealImage, cùng interface với nó.
Cách hoạt động: một virtual proxy chạy được
Ta dựng interface chung Image. Đối tượng thật RealImage tải file ngay khi khởi tạo. Proxy ImageProxy cùng interface, nhưng chỉ tạo RealImage khi lần đầu ai đó gọi display(). Client làm việc với Image, không cần biết mình cầm proxy:
from abc import ABC, abstractmethod
class Image(ABC): # interface chung cho ca that lan proxy
@abstractmethod
def display(self): ...
class RealImage(Image): # doi tuong that: nang, tai tu dia
def __init__(self, path):
self._path = path
self._load() # tai ngay khi khoi tao
def _load(self):
print(f"[tai anh tu dia: {self._path}] ... xong")
def display(self):
return f"hien anh: {self._path}"
class ImageProxy(Image): # proxy: cung interface Image
def __init__(self, path):
self._path = path
self._real = None # chua tao doi tuong that
def display(self):
if self._real is None: # chi tao khi lan dau thuc su can
self._real = RealImage(self._path)
return self._real.display()
# Client chi lam viec voi Image, khong biet la that hay proxy
print("== Tao 3 proxy (chua tai gi) ==")
gallery = [ImageProxy(f"anh_{i}.png") for i in range(1, 4)]
print("== Xem anh_1 lan 1 ==")
print(gallery[0].display())
print("== Xem anh_1 lan 2 (khong tai lai) ==")
print(gallery[0].display())
print("== Cac anh khac chua bao gio hien -> chua ton chi phi tai ==")
Đọc kỹ output sẽ thấy đúng ý đồ. Tạo 3 proxy nhưng không có dòng "tai anh tu dia" nào, nghĩa là chưa file nào bị đọc. Chỉ khi gọi display() lần đầu trên anh_1, proxy mới tạo RealImage và lúc đó mới thấy dòng tải. Gọi lần hai, không tải lại vì self._real đã có. Hai ảnh còn lại chưa ai xem nên chưa tốn một byte nào cho việc tải.
Điểm mấu chốt: ImageProxy và RealImage cùng có method display(). Client gọi display() như nhau, không cần biết phía sau là gì. Bạn kiểm soát được thời điểm tạo đối tượng nặng mà không đụng tới client hay tới chính RealImage.
dict nhớ kết quả theo tham số, có sẵn thì trả về, chưa có thì gọi real subject rồi lưu lại. Muốn thành protection proxy? Trước khi chuyển tiếp, kiểm tra quyền rồi ném lỗi nếu không đủ. Khung xương "cùng interface, chặn ở giữa" giữ nguyên.Proxy khác Decorator ở đâu
Nhìn code, Proxy và Decorator giống nhau đến mức dễ nhầm: cả hai đều cài cùng interface với đối tượng bên trong, đều bọc một đối tượng và chuyển tiếp lời gọi. Khác nhau nằm ở mục đích, không phải ở hình dạng code.
- Proxy tồn tại để kiểm soát truy cập tới một đối tượng: quyết định có cho gọi không, gọi khi nào, gọi có phải làm lại không, gọi ở đâu. Proxy thường tự quản lý vòng đời của real subject (nó tự tạo ra
RealImagekhi cần). - Decorator tồn tại để thêm hành vi mới vào một đối tượng đã có: bọc thêm một lớp chức năng (nén, mã hoá, ghi log định dạng...) quanh cái gốc. Decorator nhận đối tượng cần bọc từ bên ngoài, và thường xếp chồng nhiều lớp lên nhau.
Proxy không trong suốt tuyệt đối
Ở trên tôi nói client không phân biệt được proxy với đối tượng thật. Câu đó đúng ở mức "gọi method thì vẫn chạy", nhưng không đúng tuyệt đối. Proxy chỉ giống đối tượng thật ở đúng phần interface mà bạn có ý bắt chước; mọi thứ còn lại đều có thể lộ ra. Đây là chỗ hay cắn người đọc code lần đầu.
- Danh tính (identity):
proxy is real_objectluôn làFalse. Code nào so sánh bằngis, dùng đối tượng làm khoádicthay phần tửset, hoặc giữweakreftới đối tượng, đều có thể chạy sai khi bạn tráo proxy vào. - Kiểu:
type(proxy)kháctype(real_object). Nếu proxy không kế thừa cùng một lớp cơ sở thìisinstancetrả về kết quả không như bạn mong đợi, và mọi đoạn code rẽ nhánh theo kiểu sẽ rẽ nhầm. - Độ trễ (latency): một dòng trông như truy cập thuộc tính bình thường có thể âm thầm bắn một truy vấn cơ sở dữ liệu hay một lời gọi mạng. Đây chính là gốc rễ của vấn đề N+1 query: vòng lặp đọc 100 phần tử biến thành 101 lần đi xuống database, mà nhìn code thì không thấy.
- Ngữ nghĩa lỗi: proxy thêm được loại lỗi mới mà đối tượng thật không bao giờ ném: hết thời gian chờ, mất kết nối, bị từ chối quyền. Client viết cho đối tượng thật không lường trước những lỗi này nên không bắt, và nó nổi lên tận trên.
- Những thứ quanh rìa:
repr()in ra tên lớp proxy,picklehay serialize có thể thất bại hoặc lưu nhầm vỏ proxy, và các thuộc tính đặc biệt (__dict__,__class__, các dunder method) thường không được chuyển tiếp trừ khi bạn làm thủ công.
Một ví dụ ngắn cho thấy proxy và đối tượng thật là hai thực thể khác nhau, dù gọi method thì giống hệt:
class RealService:
def ping(self):
return "pong"
class ServiceProxy: # cung method ping(), nhung khong cung lop
def __init__(self):
self._real = None
def _get(self):
if self._real is None:
self._real = RealService()
return self._real
def ping(self):
return self._get().ping()
proxy = ServiceProxy()
print("goi qua proxy :", proxy.ping())
real = proxy._get()
print("proxy is real :", proxy is real)
print("proxy == real :", proxy == real)
print("type(proxy) :", type(proxy).__name__)
print("type(real) :", type(real).__name__)
print("isinstance proxy:", isinstance(proxy, RealService))
# Dung lam khoa dict: proxy va real la HAI khoa khac nhau
cache = {}
cache[real] = "ban ghi cua doi tuong that"
print("tra cache bang proxy:", cache.get(proxy, "KHONG THAY"))
Lời gọi ping() chạy đúng như qua đối tượng thật. Nhưng is là False, type khác nhau, isinstance không nhận, và dòng cuối là chỗ đau nhất: bản ghi đã lưu trong dict theo đối tượng thật không tìm lại được khi tra bằng proxy, vì với Python đây là hai khoá khác nhau.
is, dùng đối tượng làm khoá, kiểm tra isinstance, hay ngầm coi truy cập thuộc tính là miễn phí không.Khi nào nên và khi nào KHÔNG nên dùng
Proxy hợp lý khi bạn có nhu cầu kiểm soát truy cập thật sự:
- Đối tượng nặng, muốn hoãn tạo tới lúc cần (virtual proxy).
- Cần một chốt kiểm tra quyền tập trung trước khi cho gọi (protection proxy).
- Lời gọi tốn kém và hay lặp với cùng tham số, muốn cache (caching proxy).
- Đối tượng nằm ở tiến trình/máy khác, muốn client gọi như gọi local (remote proxy).
Điểm mạnh là bạn thêm các lớp kiểm soát đó mà không sửa đối tượng thật, cũng không sửa client, nhờ cùng interface.
Cũng lưu ý: proxy làm luồng gọi bớt tường minh (gọi display() nhưng đôi khi kèm cả một lần tải đĩa). Với caching proxy còn phải nghĩ chuyện dữ liệu cũ (cache hết hạn khi nào). Đây là cái giá phải cân nhắc, không phải thứ dùng mặc định.
Trong hệ thống thật
Proxy là mẫu bạn gặp hàng ngày mà ít khi gọi tên nó ra:
- Quan hệ lazy trong ORM. Với SQLAlchemy hay Django ORM,
order.customernhìn như một thuộc tính bình thường, nhưng lần đầu chạm vào nó mới bắn truy vấn xuống database. Đó đúng là virtual proxy, và cũng là nguồn của N+1 query khi bạn lặp qua danh sách đơn hàng rồi đọccustomertrong vòng lặp. - SimpleLazyObject của Django.
request.userkhông phải đối tượngUserthật; nó là mộtSimpleLazyObjectbọc ngoài, chỉ gọi hàm lấy user khi có ai đó đọc thuộc tính đầu tiên. Nhờ vậy bạn hoãn được một truy vấn cho mọi request không dùng tới user. - Client bọc cache. Một lớp dựng cùng interface với service client thật: đọc Redis hoặc bộ nhớ trước, trật thì mới gọi service rồi lưu lại. Code gọi không đổi một dòng.
- Proxy kiểm tra quyền. Lớp đứng trước service, đối chiếu vai trò hoặc scope của token, đủ quyền thì chuyển tiếp, không đủ thì ném lỗi từ chối. Toàn bộ luật quyền nằm một chỗ thay vì rải trong từng method nghiệp vụ.
- API gateway và service mesh sidecar. Kong, Nginx, hay sidecar Envoy của Istio đứng trước service thật để lo xác thực, giới hạn tốc độ, thử lại, đo lường. Với người gọi, địa chỉ vẫn là địa chỉ của service.
- unittest.mock khi test.
MagicMockhaypatchđứng thay đối tượng thật, nhận cùng những lời gọi và ghi lại để bạn kiểm tra. Đây là proxy ở phạm vi test.
Trade-off
Được:
- Thêm được kiểm soát (quyền, cache, log, giới hạn tốc độ, thử lại) mà client không phải đổi code, cũng không phải sửa đối tượng thật.
- Hoãn được chi phí khởi tạo nặng tới đúng lúc cần, đôi khi là không bao giờ cần.
- Có một chỗ tự nhiên để đặt retry và đo lường: đếm số lần gọi, đo thời gian, ghi lại lỗi, tất cả nằm gọn trong một lớp.
- Giấu được chi tiết như địa chỉ mạng hay giao thức sau một interface quen thuộc.
Phải trả giá:
- Chi phí ẩn: một dòng code trông như miễn phí lại là một lời gọi mạng. Người đọc code sau này không nhìn thấy điều đó.
- Khó debug hơn: stack trace dài thêm một tầng, và lỗi có thể sinh ra ở proxy chứ không phải ở đối tượng thật.
- Không trong suốt tuyệt đối, như phần trên đã nói: danh tính, kiểu, và ngữ nghĩa lỗi đều có thể lộ.
- Cache đặt trong proxy kéo theo bài toán vô hiệu hoá cache: khi nào hết hạn, ai xoá, dữ liệu cũ tới mức nào thì còn chấp nhận được.
- Dễ nhầm với Decorator khi đọc code, vì hai mẫu nhìn gần như giống hệt nhau trên màn hình.
Tóm tắt
- Proxy là đối tượng đại diện, cùng interface với đối tượng thật, đứng trước để kiểm soát truy cập tới nó.
- Client không phân biệt proxy với đối tượng thật, nên bạn chèn được logic kiểm soát mà không sửa client hay real subject.
- Các loại hay gặp: virtual (lazy loading), protection (kiểm quyền), caching (nhớ kết quả), remote (đại diện đối tượng ở xa).
- Giống Decorator về hình dạng code nhưng khác mục đích: Proxy kiểm soát truy cập, Decorator thêm hành vi.
- Chỉ dùng khi có nhu cầu kiểm soát/tối ưu thật; thêm bừa là phức tạp thừa.
Nguồn tham khảo
- Gamma, Helm, Johnson, Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 - Proxy nằm trong nhóm Structural, định nghĩa "provide a surrogate or placeholder for another object to control access to it".
- Kai