Bản thân lớp có nhất thiết phải sửa đổi không? Hay mục tiêu chỉ đơn giản là thay thế đối tượng.method () nào thực hiện tại một điểm cụ thể trong thời gian chạy?
Tôi hỏi vì tôi đã tránh được vấn đề thực sự sửa đổi lớp thành các cuộc gọi phương thức cụ thể vá khỉ trong khuôn khổ của tôi với getattribute và Runtime Decorator trên đối tượng kế thừa Cơ sở của tôi.
Các phương thức được truy xuất bởi một đối tượng Cơ sở trong getattribute được bao bọc trong một Runtime_Decorator để phân tích cú pháp phương thức gọi các đối số từ khóa cho các trình trang trí / các bản vá khỉ áp dụng.
Điều này cho phép bạn sử dụng cú pháp object.method (Monkey_patch = "mypatch"), object.method (decorator = "mydecorator") và thậm chí object.method (decorators = my_decorator_list).
Điều này hoạt động cho bất kỳ lệnh gọi phương thức riêng lẻ nào (tôi bỏ qua các phương thức ma thuật), làm như vậy mà không thực sự sửa đổi bất kỳ thuộc tính lớp / phiên bản nào, có thể sử dụng các phương thức tùy ý, thậm chí là ngoại lai để vá và sẽ hoạt động minh bạch trên các lớp con kế thừa từ Base (miễn là chúng không tất nhiên không ghi đè getattribute ).
import trace
def monkey_patched(self, *args, **kwargs):
print self, "Tried to call a method, but it was monkey patched instead"
return "and now for something completely different"
class Base(object):
def __init__(self):
super(Base, self).__init__()
def testmethod(self):
print "%s test method" % self
def __getattribute__(self, attribute):
value = super(Base, self).__getattribute__(attribute)
if "__" not in attribute and callable(value):
value = Runtime_Decorator(value)
return value
class Runtime_Decorator(object):
def __init__(self, function):
self.function = function
def __call__(self, *args, **kwargs):
if kwargs.has_key("monkey_patch"):
module_name, patch_name = self._resolve_string(kwargs.pop("monkey_patch"))
module = self._get_module(module_name)
monkey_patch = getattr(module, patch_name)
return monkey_patch(self.function.im_self, *args, **kwargs)
if kwargs.has_key('decorator'):
decorator_type = str(kwargs['decorator'])
module_name, decorator_name = self._resolve_string(decorator_type)
decorator = self._get_decorator(decorator_name, module_name)
wrapped_function = decorator(self.function)
del kwargs['decorator']
return wrapped_function(*args, **kwargs)
elif kwargs.has_key('decorators'):
decorators = []
for item in kwargs['decorators']:
module_name, decorator_name = self._resolve_string(item)
decorator = self._get_decorator(decorator_name, module_name)
decorators.append(decorator)
wrapped_function = self.function
for item in reversed(decorators):
wrapped_function = item(wrapped_function)
del kwargs['decorators']
return wrapped_function(*args, **kwargs)
else:
return self.function(*args, **kwargs)
def _resolve_string(self, string):
try:
module_name, decorator_name = string.split(".")
except ValueError:
module_name = "__main__"
decorator_name = string
finally:
return module_name, decorator_name
def _get_module(self, module_name):
try:
module = modules[module_name]
except KeyError:
module = __import__(module_name)
finally:
return module
def _get_decorator(self, decorator_name, module_name):
module = self._get_module(module_name)
try:
decorator_wrap = getattr(module, decorator_name)
except AttributeError:
print("failed to locate decorators %s for function %s." %\
(kwargs["decorator"], self.function))
else:
return decorator_wrap
class Tracer(object):
def __init__(self, function):
self.function = function
def __call__(self, *args, **kwargs):
tracer = trace.Trace(trace=1)
tracer.runfunc(self.function, *args, **kwargs)
b = Base()
b.testmethod(monkey_patch="monkey_patched")
b.testmethod(decorator="Tracer")
Nhược điểm của phương pháp này là getattribute móc tất cả quyền truy cập vào các thuộc tính, vì vậy việc kiểm tra và gói phương thức tiềm năng xảy ra ngay cả đối với các thuộc tính không phải là phương thức + sẽ không sử dụng tính năng cho lệnh gọi cụ thể được đề cập. Và việc sử dụng getattribute vốn dĩ hơi phức tạp.
Tác động thực tế của chi phí này trong trải nghiệm của tôi / cho mục đích của tôi là không đáng kể và máy của tôi chạy Celeron lõi kép. Việc triển khai trước đó, tôi đã sử dụng các phương thức nội quan dựa trên đối tượng init và sau đó ràng buộc Runtime_Decorator với các phương thức. Làm những việc theo cách đó đã loại bỏ nhu cầu sử dụng getattribute và giảm chi phí đã đề cập trước đây ... tuy nhiên, nó cũng phá vỡ dây dưa (có thể không thì là) và kém năng động hơn so với cách tiếp cận này.
Các trường hợp sử dụng duy nhất mà tôi thực sự gặp phải "trong tự nhiên" với kỹ thuật này là tính thời gian và truy tìm trang trí. Tuy nhiên, khả năng nó mở ra là vô cùng rộng lớn.
Nếu bạn có một lớp tồn tại trước đó không thể được thực hiện để kế thừa từ một cơ sở khác (hoặc sử dụng kỹ thuật định nghĩa lớp của chính nó hoặc trong lớp cơ sở của nó '), thì rất tiếc toàn bộ điều không áp dụng cho vấn đề của bạn.
Tôi không nghĩ rằng việc thiết lập / xóa các thuộc tính không thể gọi trên một lớp trong thời gian chạy có nhất thiết phải là một thách thức như vậy không? trừ khi bạn muốn các lớp kế thừa từ lớp đã sửa đổi cũng tự động phản ánh những thay đổi trong chính chúng ... Mặc dù vậy, đó sẽ là một con sâu 'nother can o' hoàn toàn bởi âm thanh của nó.