如何在Python中实现嵌套类结构的调用拦截与重定向？

问题场景 #

现有一套多层嵌套的硬件系统类结构，示例代码如下：

class B():
    def __init__(self):
        self.attr_c = 0

    def setup_b(self):
        return "Setup of Class B might fail"

class A():
    def __init__(self):
        self.attr_b = B()

    def setup_a(self):
        return "Setup of Class A might fail"

    def capture_a(self):
        return "Some real captured data"

需要实现VirtualA类，在初始化阶段替代A的实例，且无需修改原有调用代码即可正常使用，同时满足：

• 任意嵌套层级的部分方法可返回指定值（如成功/失败）
• 可重写特定方法返回虚拟数据（如capture_a）
• 无需复制完整类结构，仅关注需虚拟化的方法
• 保持可调试性

解决方案：动态属性代理 #

利用Python的__getattr__魔法方法实现动态嵌套对象代理，自动处理未定义的属性和方法，仅需显式定义需要自定义的逻辑。

实现代码 #

class VirtualComponent:
    def __init__(self, custom_methods=None):
        # 存储需要自定义返回值的方法/属性
        self.custom_methods = custom_methods or {}
        # 存储用户动态设置的属性（如attr_c = 1）
        self._attrs = {}

    def __getattr__(self, name):
        # 优先返回自定义的方法或固定值
        if name in self.custom_methods:
            val = self.custom_methods[name]
            return val if callable(val) else lambda: val
        # 未定义的属性/方法自动生成新的虚拟组件，支持无限嵌套
        return VirtualComponent()

    def __setattr__(self, name, value):
        # 区分内部属性和用户设置的业务属性
        if name in ['custom_methods', '_attrs']:
            super().__setattr__(name, value)
        else:
            self._attrs[name] = value

    def __getattribute__(self, name):
        # 优先返回用户手动设置的属性
        if name != '_attrs' and name in object.__getattribute__(self, '_attrs'):
            return object.__getattribute__(self, '_attrs')[name]
        return super().__getattribute__(name)


class VirtualA(VirtualComponent):
    def __init__(self):
        # 自定义需要虚拟化的方法返回值
        custom_methods = {
            'capture_a': lambda: "Some virtual data",
            'setup_a': lambda: "Setup of Class A (virtual) succeeded",
            'setup_b': lambda: "Setup of Class B (virtual) succeeded"
        }
        super().__init__(custom_methods)

使用示例 #

# 原有真实类的调用逻辑（完全无需修改）
a_real = A()
a_real.setup_a()
a_real.attr_b.setup_b()
a_real.attr_b.attr_c = 1
print(a_real.capture_a())  # 输出: Some real captured data

# 虚拟类的调用逻辑（与真实类完全一致）
a_virtual = VirtualA()
a_virtual.setup_a()
a_virtual.attr_b.setup_b()
a_virtual.attr_b.attr_c = 1
print(a_virtual.capture_a())  # 输出: Some virtual data
# 验证自定义的setup返回值
print(a_virtual.setup_a())  # 输出: Setup of Class A (virtual) succeeded
print(a_virtual.attr_b.setup_b())  # 输出: Setup of Class B (virtual) succeeded
# 验证手动设置的属性
print(a_virtual.attr_b.attr_c)  # 输出: 1

方案优势 #

1. 无需复制类结构：仅需定义需要自定义的方法，其余嵌套属性/方法自动生成
2. 灵活配置：通过custom_methods字典可快速配置任意层级方法的返回值
3. 可调试性强：可在__getattr__中添加日志打印，追踪属性/方法的访问路径，示例：

def __getattr__(self, name):
    print(f"Virtual component accessed: {name}")  # 调试日志
    # 原有逻辑...

4. 完全兼容原有代码：调用方式与真实类完全一致，无需修改业务逻辑

内容的提问来源于stack exchange，提问作者Knyq