Monkey Patching 是一種在程式執行時期動態修改程式碼的技術，允許開發者在不變更原始碼的情況下改變程式行為。這種技術在動態語言如 Python、Ruby、JavaScript 中特別常見，因為這些語言的物件結構在執行時期是可變的。Monkey Patching 的名稱來源有多種說法，一種認為它源自「guerrilla patch」（游擊補丁），後來訛變為「gorilla patch」，最終演變為「monkey patch」。
在軟體開發實務中，Monkey Patching 有許多合理的應用場景。當使用的第三方函式庫存在缺陷，而修正版本尚未發布時，可以透過 Monkey Patching 臨時修復問題。在測試環境中，Monkey Patching 可以用來模擬外部依賴、注入測試資料，或隔離被測試的程式碼。在某些情況下，Monkey Patching 也可以用來擴展函式庫功能，或根據執行環境動態調整程式行為。
然而，Monkey Patching 也是一把雙刃劍。不當的使用可能導致程式碼難以理解和維護、產生難以追蹤的錯誤、以及與函式庫更新發生衝突。因此，使用 Monkey Patching 時需要特別謹慎，遵循最佳實踐，並充分記錄所做的修改。
本文將從 Monkey Patching 的基礎概念出發，逐步深入探討其在各種場景中的應用，包括設計模式整合、測試環境模擬、安全補丁機制等。同時，也將介紹元程式設計（Metaprogramming）的相關技術，如元類別和裝飾器，以及它們如何與 Monkey Patching 結合實作更進階的程式碼修改和功能增強。
Monkey Patching 基礎概念與原理
在深入應用之前，首先需要理解 Monkey Patching 的運作原理。在 Python 中，物件的屬性和方法儲存在其 __dict__ 字典中。當我們存取物件的屬性時，Python 會按照特定的順序（稱為方法解析順序，MRO）在物件及其類別的 __dict__ 中查找。Monkey Patching 的本質就是修改這些 __dict__ 中的項目，從而改變物件的行為。
以下是一個展示 Monkey Patching 基本原理的範例：
# monkey_patching_basics.py
# 展示 Monkey Patching 的基本原理
# 透過修改類別和物件的屬性來改變程式行為
class Calculator:
"""
基本計算機類別
用於展示 Monkey Patching 的運作方式
"""
def __init__(self, name):
# 初始化計算機名稱
self.name = name
def add(self, a, b):
# 原始的加法方法
return a + b
def multiply(self, a, b):
# 原始的乘法方法
return a * b
# 建立計算機實例
calc = Calculator("Basic")
# 呼叫原始方法
print(f"原始 add: {calc.add(2, 3)}") # 輸出: 5
print(f"原始 multiply: {calc.multiply(2, 3)}") # 輸出: 6
# 方法一：修改實例的方法
# 這只影響這個特定的實例
def enhanced_add(self, a, b):
# 增強版加法：在計算前印出訊息
print(f"[{self.name}] 執行加法: {a} + {b}")
return a + b
import types
# 將函式綁定為實例方法
calc.add = types.MethodType(enhanced_add, calc)
print(f"增強 add: {calc.add(2, 3)}")
# 方法二：修改類別的方法
# 這會影響所有現有和未來的實例
original_multiply = Calculator.multiply
def logged_multiply(self, a, b):
# 帶日誌的乘法方法
result = original_multiply(self, a, b)
print(f"[日誌] multiply({a}, {b}) = {result}")
return result
Calculator.multiply = logged_multiply
# 所有實例都會使用新方法
calc2 = Calculator("Advanced")
calc.multiply(4, 5)
calc2.multiply(3, 7)
# 方法三：新增類別沒有的方法
def subtract(self, a, b):
# 新增減法功能
return a - b
Calculator.subtract = subtract
print(f"新增 subtract: {calc.subtract(10, 4)}") # 輸出: 6
這個範例展示了三種常見的 Monkey Patching 方式。第一種是修改特定實例的方法，只影響該實例；第二種是修改類別的方法，影響所有實例；第三種是為類別新增原本不存在的方法。在實際應用中，通常傾向於修改類別而不是實例，因為這樣可以確保一致性。
理解 Python 的屬性查找機制對於正確使用 Monkey Patching 非常重要。當存取 obj.attr 時，Python 首先查找 obj.__dict__['attr']，如果找不到則查找 type(obj).__dict__['attr']，然後沿著 MRO 繼續向上查找。這意味著實例屬性會覆蓋類別屬性，而類別屬性會覆蓋父類別屬性。
@startuml
!define PLANTUML_FORMAT svg
!theme _none_
skinparam dpi auto
skinparam shadowing false
skinparam linetype ortho
skinparam roundcorner 5
skinparam defaultFontName "Microsoft JhengHei UI"
skinparam defaultFontSize 16
skinparam minClassWidth 100
title Python 屬性查找順序（MRO）
start
:存取 obj.attr;
:查找 obj.__dict__['attr'];
if (找到?) then (是)
:回傳屬性值;
stop
else (否)
endif
:查找 type(obj).__dict__['attr'];
if (找到?) then (是)
if (是資料描述器?) then (是)
:呼叫描述器的 __get__;
else (否)
:回傳屬性值;
endif
stop
else (否)
endif
:沿 MRO 查找父類別;
if (找到?) then (是)
:回傳屬性值;
stop
else (否)
endif
:嘗試 __getattr__;
if (有定義?) then (是)
:呼叫 __getattr__(attr);
stop
else (否)
:拋出 AttributeError;
stop
endif
@enduml
測試環境中的 Monkey Patching 應用
Monkey Patching 在測試中最常見的應用是模擬（Mocking）外部依賴。當被測試的程式碼依賴外部服務（如資料庫、API、檔案系統）時，直接測試這些依賴既慢又不穩定。透過 Monkey Patching，可以將這些依賴替換為可控的模擬物件，從而實現快速、可靠的單元測試。
Python 標準函式庫的 unittest.mock 模組提供了強大的 Monkey Patching 工具。以下是使用 mock.patch 的範例：
# test_with_mock.py
# 展示如何使用 mock.patch 進行測試
# 模擬外部 API 呼叫以實現隔離測試
import unittest
from unittest import mock
import requests
class WeatherService:
"""
天氣服務類別
從外部 API 獲取天氣資訊
"""
def __init__(self, api_key):
# API 金鑰
self.api_key = api_key
self.base_url = "https://api.weather.example.com"
def get_temperature(self, city):
# 從 API 獲取指定城市的溫度
url = f"{self.base_url}/current"
params = {"city": city, "key": self.api_key}
response = requests.get(url, params=params)
response.raise_for_status()
data = response.json()
return data["temperature"]
def get_forecast(self, city, days):
# 獲取未來幾天的天氣預報
url = f"{self.base_url}/forecast"
params = {"city": city, "days": days, "key": self.api_key}
response = requests.get(url, params=params)
response.raise_for_status()
return response.json()["forecast"]
class TestWeatherService(unittest.TestCase):
"""天氣服務的單元測試"""
def setUp(self):
# 建立服務實例
self.service = WeatherService("test-api-key")
@mock.patch("requests.get")
def test_get_temperature(self, mock_get):
# 測試獲取溫度功能
# 設定模擬回應
mock_response = mock.Mock()
mock_response.json.return_value = {"temperature": 25.5}
mock_response.raise_for_status.return_value = None
mock_get.return_value = mock_response
# 呼叫被測試方法
result = self.service.get_temperature("Taipei")
# 驗證結果
self.assertEqual(result, 25.5)
# 驗證 API 被正確呼叫
mock_get.assert_called_once()
call_args = mock_get.call_args
self.assertIn("city", call_args.kwargs["params"])
self.assertEqual(call_args.kwargs["params"]["city"], "Taipei")
@mock.patch("requests.get")
def test_get_temperature_api_error(self, mock_get):
# 測試 API 錯誤處理
mock_get.side_effect = requests.exceptions.HTTPError("API Error")
# 驗證異常被正確拋出
with self.assertRaises(requests.exceptions.HTTPError):
self.service.get_temperature("InvalidCity")
@mock.patch("requests.get")
def test_get_forecast(self, mock_get):
# 測試天氣預報功能
mock_response = mock.Mock()
mock_response.json.return_value = {
"forecast": [
{"date": "2024-01-01", "temp": 20},
{"date": "2024-01-02", "temp": 22},
{"date": "2024-01-03", "temp": 21}
]
}
mock_response.raise_for_status.return_value = None
mock_get.return_value = mock_response
result = self.service.get_forecast("Taipei", 3)
# 驗證回傳正確的預報數量
self.assertEqual(len(result), 3)
self.assertEqual(result[0]["temp"], 20)
if __name__ == "__main__":
unittest.main()
除了使用 mock.patch 裝飾器，也可以使用上下文管理器形式來精確控制補丁的範圍：
# context_manager_mock.py
# 使用上下文管理器控制 mock 範圍
from unittest import mock
import requests
def fetch_data(url):
# 從指定 URL 獲取資料
response = requests.get(url)
return response.json()
def test_fetch_data_with_context():
# 使用上下文管理器進行測試
with mock.patch("requests.get") as mock_get:
# 設定模擬回應
mock_get.return_value.json.return_value = {"data": "mocked"}
# 在這個區塊內，requests.get 被替換
result = fetch_data("https://example.com/api")
assert result == {"data": "mocked"}
mock_get.assert_called_once_with("https://example.com/api")
# 離開區塊後，requests.get 恢復原狀
# 此時真正的 requests.get 可以正常使用
# 手動控制 mock 的開始和結束
def test_manual_mock_control():
# 建立 patcher
patcher = mock.patch("requests.get")
# 開始 mock
mock_get = patcher.start()
mock_get.return_value.json.return_value = {"status": "ok"}
try:
result = fetch_data("https://api.example.com")
assert result["status"] == "ok"
finally:
# 確保 mock 被停止
patcher.stop()
受控的 Monkey Patching 實作
在生產環境中使用 Monkey Patching 時，需要特別注意其生命週期管理。不受控制的補丁可能導致難以追蹤的問題，特別是在多執行緒環境或長時間運行的應用程式中。使用上下文管理器可以確保補丁在使用完畢後自動還原。
# controlled_patching.py
# 實作受控的 Monkey Patching 機制
# 確保補丁在使用後自動還原
import contextlib
import functools
@contextlib.contextmanager
def temporary_patch(target, attribute, new_value):
"""
臨時補丁上下文管理器
在上下文結束時自動還原原始值
Args:
target: 要修改的物件（模組或類別）
attribute: 要修改的屬性名稱
new_value: 新的屬性值
"""
# 檢查屬性是否存在
if not hasattr(target, attribute):
raise AttributeError(f"{target} 沒有屬性 {attribute}")
# 保存原始值
original = getattr(target, attribute)
try:
# 應用補丁
setattr(target, attribute, new_value)
yield original # 提供原始值給使用者
finally:
# 還原原始值
setattr(target, attribute, original)
@contextlib.contextmanager
def multi_patch(*patches):
"""
同時應用多個補丁的上下文管理器
Args:
patches: (target, attribute, new_value) 元組的列表
"""
originals = []
try:
# 應用所有補丁
for target, attribute, new_value in patches:
original = getattr(target, attribute)
originals.append((target, attribute, original))
setattr(target, attribute, new_value)
yield
finally:
# 以相反順序還原所有補丁
for target, attribute, original in reversed(originals):
setattr(target, attribute, original)
# 使用範例
import math
def custom_sqrt(x):
# 自訂平方根實作（例如：加入日誌）
print(f"計算 sqrt({x})")
# 使用牛頓法
if x < 0:
raise ValueError("不能對負數開根號")
if x == 0:
return 0
guess = x / 2
for _ in range(10):
guess = (guess + x / guess) / 2
return guess
def demonstrate_temporary_patch():
# 展示臨時補丁的使用
print(f"原始 math.sqrt(16) = {math.sqrt(16)}")
with temporary_patch(math, "sqrt", custom_sqrt) as original_sqrt:
# 在這個區塊內使用自訂實作
result = math.sqrt(16)
print(f"補丁後 math.sqrt(16) = {result}")
# 可以透過 original_sqrt 存取原始函式
print(f"原始函式結果: {original_sqrt(16)}")
# 離開區塊後恢復原狀
print(f"還原後 math.sqrt(16) = {math.sqrt(16)}")
def demonstrate_multi_patch():
# 展示多重補丁的使用
print(f"原始: sin(0)={math.sin(0)}, cos(0)={math.cos(0)}")
patches = [
(math, "sin", lambda x: f"sin({x})"),
(math, "cos", lambda x: f"cos({x})"),
]
with multi_patch(*patches):
print(f"補丁後: sin(0)={math.sin(0)}, cos(0)={math.cos(0)}")
print(f"還原後: sin(0)={math.sin(0)}, cos(0)={math.cos(0)}")
if __name__ == "__main__":
demonstrate_temporary_patch()
print()
demonstrate_multi_patch()
設計模式中的 Monkey Patching 應用
Monkey Patching 可以與多種設計模式結合，實現更靈活的系統設計。以下範例展示如何為現有類別動態新增裝飾器功能，實現橫切關注點（如日誌記錄、效能監控）的注入：
# design_pattern_integration.py
# 將 Monkey Patching 與設計模式結合
# 實作動態的切面導向程式設計（AOP）
import functools
import time
from typing import Callable, Any
def create_method_wrapper(aspect_func: Callable) -> Callable:
"""
建立方法包裝器工廠
用於在方法執行前後注入額外邏輯
Args:
aspect_func: 切面函式，接收 (method, args, kwargs, result) 參數
"""
def wrapper_factory(method):
@functools.wraps(method)
def wrapped(*args, **kwargs):
# 執行原始方法
result = method(*args, **kwargs)
# 執行切面邏輯
aspect_func(method, args, kwargs, result)
return result
return wrapped
return wrapper_factory
def logging_aspect(method, args, kwargs, result):
# 日誌記錄切面
print(f"[LOG] {method.__name__} 被呼叫")
print(f" 參數: args={args[1:] if args else ()}, kwargs={kwargs}")
print(f" 結果: {result}")
def timing_aspect(method, args, kwargs, result):
# 效能計時切面（需要額外處理）
pass
def apply_aspect_to_class(cls, aspect_func, method_filter=None):
"""
將切面應用到類別的所有方法
Args:
cls: 目標類別
aspect_func: 切面函式
method_filter: 方法過濾器（可選）
"""
wrapper_factory = create_method_wrapper(aspect_func)
for attr_name in dir(cls):
# 跳過魔術方法和私有方法
if attr_name.startswith("_"):
continue
attr = getattr(cls, attr_name)
# 只處理可呼叫的屬性
if not callable(attr):
continue
# 應用過濾器
if method_filter and not method_filter(attr_name):
continue
# 包裝方法
wrapped = wrapper_factory(attr)
setattr(cls, attr_name, wrapped)
# 使用範例
class OrderService:
"""訂單服務類別"""
def create_order(self, customer_id, items):
# 建立訂單
order_id = f"ORD-{customer_id}-{len(items)}"
return {"order_id": order_id, "items": items}
def cancel_order(self, order_id):
# 取消訂單
return {"order_id": order_id, "status": "cancelled"}
def get_order_status(self, order_id):
# 查詢訂單狀態
return {"order_id": order_id, "status": "processing"}
def demonstrate_aspect_application():
# 展示切面應用
print("=== 應用切面前 ===")
service = OrderService()
service.create_order("C001", ["item1", "item2"])
print("\n=== 應用日誌切面 ===")
apply_aspect_to_class(OrderService, logging_aspect)
# 現在所有方法都會自動記錄日誌
service.create_order("C002", ["item3"])
service.get_order_status("ORD-C002-1")
service.cancel_order("ORD-C002-1")
if __name__ == "__main__":
demonstrate_aspect_application()
條件式補丁與環境適應
在不同的執行環境中，可能需要不同的程式行為。條件式 Monkey Patching 可以根據環境變數、配置檔案或執行時條件來決定是否應用補丁：
# conditional_patching.py
# 根據執行環境條件式應用補丁
import os
import functools
def environment_aware_patch(env_var, env_value=None):
"""
環境感知的補丁裝飾器
只有在特定環境變數設定時才應用補丁
Args:
env_var: 環境變數名稱
env_value: 環境變數的預期值（None 表示只檢查是否存在）
"""
def decorator(patch_func):
def apply_patch(target_module, target_attr):
# 檢查環境變數
actual_value = os.getenv(env_var, "").lower()
if env_value is None:
# 只檢查環境變數是否存在且非空
should_patch = bool(actual_value)
else:
# 檢查環境變數是否等於預期值
should_patch = actual_value == env_value.lower()
if should_patch:
# 保存原始函式
original = getattr(target_module, target_attr)
@functools.wraps(original)
def patched(*args, **kwargs):
return patch_func(original, *args, **kwargs)
setattr(target_module, target_attr, patched)
print(f"[PATCH] 已應用補丁到 {target_module.__name__}.{target_attr}")
else:
print(f"[SKIP] 環境條件不符，跳過補丁 {target_attr}")
return apply_patch
return decorator
# 使用範例
import json
# 定義除錯版本的補丁
@environment_aware_patch("DEBUG_MODE", "true")
def debug_json_loads(original, *args, **kwargs):
# 除錯版本：印出載入的內容
result = original(*args, **kwargs)
print(f"[DEBUG] JSON 載入完成，包含 {len(result) if isinstance(result, (dict, list)) else 1} 個項目")
return result
# 定義效能監控補丁
@environment_aware_patch("PERFORMANCE_MONITORING")
def monitored_json_dumps(original, *args, **kwargs):
# 效能監控版本：計算序列化時間
import time
start = time.perf_counter()
result = original(*args, **kwargs)
elapsed = time.perf_counter() - start
print(f"[PERF] JSON 序列化耗時: {elapsed*1000:.2f}ms")
return result
def setup_environment_patches():
# 設定環境相關補丁
debug_json_loads(json, "loads")
monitored_json_dumps(json, "dumps")
# 功能旗標系統
class FeatureFlags:
"""功能旗標管理器"""
_flags = {}
@classmethod
def set(cls, flag_name, value):
# 設定功能旗標
cls._flags[flag_name] = value
@classmethod
def is_enabled(cls, flag_name):
# 檢查功能旗標
return cls._flags.get(flag_name, False)
def feature_flag_patch(flag_name):
"""
基於功能旗標的條件式補丁
Args:
flag_name: 功能旗標名稱
"""
def decorator(patch_func):
def apply_patch(target_module, target_attr):
original = getattr(target_module, target_attr)
@functools.wraps(original)
def dynamic_patch(*args, **kwargs):
# 每次呼叫時檢查旗標
if FeatureFlags.is_enabled(flag_name):
return patch_func(original, *args, **kwargs)
else:
return original(*args, **kwargs)
setattr(target_module, target_attr, dynamic_patch)
return apply_patch
return decorator
if __name__ == "__main__":
# 模擬不同環境
os.environ["DEBUG_MODE"] = "true"
os.environ["PERFORMANCE_MONITORING"] = "1"
setup_environment_patches()
# 測試補丁效果
data = {"key": "value", "numbers": [1, 2, 3]}
json_str = json.dumps(data)
loaded = json.loads(json_str)
元程式設計與進階 Monkey Patching
元程式設計（Metaprogramming）是撰寫能夠操作程式碼本身的程式碼。在 Python 中，元類別（Metaclass）是實現元程式設計的重要工具。元類別可以在類別建立時自動修改類別的行為，這可以視為一種「預先 Monkey Patching」。
以下範例展示如何使用元類別實作自動外掛註冊系統：
# metaclass_plugin_system.py
# 使用元類別實作企業級外掛架構
# 自動註冊和管理外掛
from abc import ABC, abstractmethod
class PluginRegistryMeta(type):
"""
外掛登入檔元類別
自動註冊所有繼承自 BasePlugin 的類別
"""
# 類別變數：儲存所有已註冊的外掛
_registry = {}
def __new__(mcls, name, bases, namespace):
# 建立新類別
cls = super().__new__(mcls, name, bases, namespace)
# 跳過基礎類別，只註冊具體實作
if not namespace.get("_abstract", False):
# 取得外掛識別符
plugin_id = namespace.get("PLUGIN_ID", name.lower())
# 註冊外掛
if plugin_id in mcls._registry:
raise ValueError(f"外掛 ID '{plugin_id}' 已被註冊")
mcls._registry[plugin_id] = cls
print(f"[Registry] 已註冊外掛: {plugin_id}")
return cls
@classmethod
def get_plugin(mcls, plugin_id):
"""取得已註冊的外掛類別"""
if plugin_id not in mcls._registry:
raise KeyError(f"找不到外掛: {plugin_id}")
return mcls._registry[plugin_id]
@classmethod
def create_plugin(mcls, plugin_id, *args, **kwargs):
"""建立外掛實例"""
plugin_cls = mcls.get_plugin(plugin_id)
return plugin_cls(*args, **kwargs)
@classmethod
def list_plugins(mcls):
"""列出所有已註冊的外掛"""
return list(mcls._registry.keys())
class BasePlugin(metaclass=PluginRegistryMeta):
"""
外掛基礎類別
所有外掛必須繼承此類別
"""
# 標記為抽象類別，不要註冊
_abstract = True
@abstractmethod
def initialize(self, config):
"""初始化外掛"""
pass
@abstractmethod
def execute(self, context):
"""執行外掛邏輯"""
pass
@abstractmethod
def cleanup(self):
"""清理資源"""
pass
class DatabasePlugin(BasePlugin):
"""資料庫連線外掛"""
PLUGIN_ID = "database"
def __init__(self, connection_string):
# 資料庫連線字串
self.connection_string = connection_string
self.connection = None
def initialize(self, config):
# 建立資料庫連線
print(f"[Database] 連線到 {self.connection_string}")
self.connection = f"Connection({self.connection_string})"
def execute(self, context):
# 執行資料庫查詢
query = context.get("query", "SELECT 1")
print(f"[Database] 執行查詢: {query}")
return {"result": f"Query result for: {query}"}
def cleanup(self):
# 關閉連線
print(f"[Database] 關閉連線")
self.connection = None
class CachePlugin(BasePlugin):
"""快取外掛"""
PLUGIN_ID = "cache"
def __init__(self, cache_size=100):
# 快取大小
self.cache_size = cache_size
self.cache = {}
def initialize(self, config):
# 初始化快取
print(f"[Cache] 初始化快取，大小: {self.cache_size}")
def execute(self, context):
# 執行快取操作
operation = context.get("operation", "get")
key = context.get("key")
if operation == "get":
return {"value": self.cache.get(key)}
elif operation == "set":
self.cache[key] = context.get("value")
return {"status": "ok"}
def cleanup(self):
# 清空快取
print(f"[Cache] 清空快取")
self.cache.clear()
class NotificationPlugin(BasePlugin):
"""通知外掛"""
PLUGIN_ID = "notification"
def __init__(self, channel="email"):
# 通知管道
self.channel = channel
def initialize(self, config):
print(f"[Notification] 初始化 {self.channel} 通知管道")
def execute(self, context):
message = context.get("message", "")
recipient = context.get("recipient", "")
print(f"[Notification] 發送到 {recipient}: {message}")
return {"status": "sent"}
def cleanup(self):
print(f"[Notification] 關閉通知管道")
def demonstrate_plugin_system():
# 展示外掛系統
print("=== 已註冊的外掛 ===")
print(PluginRegistryMeta.list_plugins())
print()
# 動態建立外掛
print("=== 建立外掛實例 ===")
db = PluginRegistryMeta.create_plugin("database", "postgresql://localhost/mydb")
cache = PluginRegistryMeta.create_plugin("cache", cache_size=200)
notify = PluginRegistryMeta.create_plugin("notification", channel="slack")
# 初始化外掛
print("\n=== 初始化外掛 ===")
db.initialize({})
cache.initialize({})
notify.initialize({})
# 執行外掛
print("\n=== 執行外掛 ===")
db.execute({"query": "SELECT * FROM users"})
cache.execute({"operation": "set", "key": "user:1", "value": "data"})
notify.execute({"recipient": "[email protected]", "message": "系統啟動完成"})
# 清理
print("\n=== 清理資源 ===")
db.cleanup()
cache.cleanup()
notify.cleanup()
if __name__ == "__main__":
demonstrate_plugin_system()
安全補丁機制
在應用 Monkey Patching 時，需要考慮安全性問題。不當的補丁可能破壞程式的正確性，或引入安全漏洞。以下是一個實作安全補丁機制的範例，包含簽章驗證和類型檢查：
# safe_patching.py
# 實作安全的 Monkey Patching 機制
# 包含驗證和回滾功能
import inspect
import functools
from typing import Callable, Any
class PatchError(Exception):
"""補丁錯誤"""
pass
class SafePatcher:
"""
安全補丁管理器
提供驗證、應用和回滾補丁的功能
"""
def __init__(self):
# 儲存已應用的補丁，用於回滾
self._applied_patches = []
def validate_patch(self, target, attribute, new_func):
"""
驗證補丁的安全性
Args:
target: 目標物件
attribute: 屬性名稱
new_func: 新函式
"""
# 檢查屬性是否存在
if not hasattr(target, attribute):
raise PatchError(f"{target} 沒有屬性 '{attribute}'")
original = getattr(target, attribute)
# 檢查是否為可呼叫物件
if not callable(original):
raise PatchError(f"'{attribute}' 不是可呼叫物件")
if not callable(new_func):
raise PatchError("新函式不是可呼叫物件")
# 比較函式簽章
try:
original_sig = inspect.signature(original)
new_sig = inspect.signature(new_func)
# 取得參數名稱（排除 self）
original_params = [
p for p in original_sig.parameters.values()
if p.name != "self"
]
new_params = [
p for p in new_sig.parameters.values()
if p.name not in ("self", "original")
]
# 簡化的簽章檢查
if len(original_params) != len(new_params):
print(f"[警告] 參數數量不符: 原始 {len(original_params)}, 新 {len(new_params)}")
except (ValueError, TypeError) as e:
print(f"[警告] 無法比較簽章: {e}")
return True
def apply(self, target, attribute, new_func, validate=True):
"""
應用補丁
Args:
target: 目標物件
attribute: 屬性名稱
new_func: 新函式
validate: 是否進行驗證
"""
if validate:
self.validate_patch(target, attribute, new_func)
# 保存原始值
original = getattr(target, attribute)
# 應用補丁
setattr(target, attribute, new_func)
# 記錄補丁資訊
self._applied_patches.append({
"target": target,
"attribute": attribute,
"original": original,
"new": new_func
})
print(f"[Patcher] 已應用補丁: {target.__name__ if hasattr(target, '__name__') else target}.{attribute}")
def rollback(self, count=1):
"""
回滾指定數量的補丁
Args:
count: 要回滾的補丁數量
"""
for _ in range(min(count, len(self._applied_patches))):
patch_info = self._applied_patches.pop()
setattr(
patch_info["target"],
patch_info["attribute"],
patch_info["original"]
)
print(f"[Patcher] 已回滾補丁: {patch_info['attribute']}")
def rollback_all(self):
"""回滾所有補丁"""
self.rollback(len(self._applied_patches))
# 使用範例
class MathOperations:
"""數學運算類別"""
@staticmethod
def add(a, b):
return a + b
@staticmethod
def multiply(a, b):
return a * b
def logged_add(a, b):
# 帶日誌的加法
result = a + b
print(f"add({a}, {b}) = {result}")
return result
def invalid_add(a):
# 錯誤的簽章
return a + 1
def demonstrate_safe_patching():
patcher = SafePatcher()
print("=== 測試有效補丁 ===")
patcher.apply(MathOperations, "add", logged_add)
result = MathOperations.add(5, 3)
print(f"結果: {result}")
print("\n=== 測試回滾 ===")
patcher.rollback()
result = MathOperations.add(5, 3)
print(f"回滾後結果: {result}")
print("\n=== 測試無效補丁 ===")
try:
patcher.apply(MathOperations, "add", invalid_add)
except PatchError as e:
print(f"補丁錯誤: {e}")
if __name__ == "__main__":
demonstrate_safe_patching()
最佳實踐與注意事項
在使用 Monkey Patching 時，遵循最佳實踐可以減少潛在問題：
首先，盡量減少補丁的範圍和持續時間。使用上下文管理器或明確的生命週期管理來控制補丁的應用範圍，避免全域性的永久修改。
其次，保持補丁的向後相容性。補丁的函式簽章應該與原始函式相同，行為也應該盡可能相似。如果補丁改變了回傳值的型別或拋出不同的異常，可能會導致依賴原始行為的程式碼出錯。
第三，記錄所有的補丁。每個補丁都應該有清楚的文件說明，包括為什麼需要這個補丁、它修改了什麼、以及何時可以移除。
第四，優先考慮其他解決方案。在使用 Monkey Patching 之前，考慮是否有更好的替代方案，如繼承、組合、依賴注入等。
第五，測試補丁本身。補丁程式碼也需要測試，確保它正確地實現了預期的行為，並且不會破壞原有的功能。
結語
Monkey Patching 是一種強大但需要謹慎使用的技術。它提供了在執行時期修改程式行為的靈活性，在測試、臨時修復、功能擴展等場景中非常有用。然而，不當的使用可能導致程式碼難以理解和維護，甚至引入難以追蹤的錯誤。
本文探討了 Monkey Patching 的基礎原理和多種應用場景，包括測試環境中的模擬、受控的補丁機制、與設計模式的整合、條件式補丁，以及與元程式設計的結合。透過這些技術的合理應用，開發者可以更靈活地應對各種軟體開發挑戰。
元程式設計技術，如元類別和裝飾器，進一步擴展了 Monkey Patching 的應用範圍。透過在類別建立時自動注入行為，可以實現如自動註冊、切面導向程式設計等進階功能。這些技術在企業級應用中特別有價值，可以大幅減少樣板程式碼，提高系統的可擴展性。
無論使用哪種技術，最重要的是理解其適用場景和潛在風險，並遵循最佳實踐。正確使用這些技術可以使程式碼更加靈活和強大，但過度或不當的使用則可能導致維護困難。在軟體開發中，平衡靈活性和可維護性始終是一個重要的考量。