Python 装饰器泛化公有和私有属性访问控制

注意：重写 __getattribute__ 时必须小心，因为所有属性访问都会触发它，包括内部属性如 __dict__。如果在其中直接访问实例属性而不使用 super().__getattribute__，会导致无限递归。

泛化公有属性的装饰器实现

我们可以通过类装饰器创建一个包装类，拦截属性访问。以下示例展示了如何监视和修改公有属性的访问和设置。

def generalizing_public_attributes(cls):
    class WrappedClass(cls):
        def __getattribute__(self, name):
            # 避免递归访问 __dict__ 或其他内部属性
            if name.startswith('_') and not name.endswith('__'):
                return super().__getattribute__(name)
            
            try:
                val = super().__getattribute__(name)
                print(f"[Public Get] 访问公有属性：{name}, 当前值：{val}")
                return val
            except AttributeError:
                raise

        def __setattr__(self, name, value):
            # 初始化时通常不打印，或者特殊处理
            if name in ('__class__', '__dict__', '_WrappedClass__private_attr'):
                super().__setattr__(name, value)
                return
            
            print(f"[Public Set] 设置公有属性：{name} 值为 {value}")
            super().__setattr__(name, value)

    return WrappedClass

@generalizing_public_attributes
class MyClass:
    public_attr = 10
    def __init__(self):
        self.instance_attr = "test"

my_instance = MyClass()
print(my_instance.public_attr)
my_instance.public_attr = 20

在这个示例中，generalizing_public_attributes 装饰器创建了一个继承自原类的包装类。通过重写 __getattribute__ 和 __setattr__，我们可以在每次读写属性时插入自定义逻辑。这适用于需要统一审计所有公有属性变更的场景。

泛化私有属性的装饰器实现

Python 中的私有属性通过双下划线（__）开头定义，这会触发名称修饰（Name Mangling）。例如，__private_attr 在类外部会被重命名为 _ClassName__private_attr。装饰器同样可以控制这些属性的访问。

def generalizing_private_attributes(cls):
    class WrappedClass(cls):
        def __getattribute__(self, name):
            # 检查是否涉及名称修饰后的私有属性
            if name.startswith('_') and not name.endswith('__'):
                # 这里简单演示，实际应更精确判断
                pass
            
            try:
                val = super().__getattribute__(name)
                print(f"[Private Get] 访问属性：{name}")
                return val
            except AttributeError:
                raise

        def __setattr__(self, name, value):
            print(f"[Private Set] 设置属性：{name} 值为 {value}")
            super().__setattr__(name, value)

    return WrappedClass

@generalizing_private_attributes
class SecureClass:
    def __init__(self):
        self.__secret = 100

my_obj = SecureClass()
# 访问时需要使用名称修饰后的名字
print(my_obj._SecureClass__secret)
my_obj._SecureClass__secret = 200

此示例展示了如何通过装饰器监控私有属性的底层存储。尽管名称修饰使得私有属性在外部不可见，但通过装饰器拦截，开发者仍可在框架层面管理其生命周期。

操作私有属性的装饰器控制

除了监控，我们还可以利用装饰器实施严格的访问控制策略。例如，禁止外部直接修改某些敏感属性。

def control_sensitive_attributes(cls):
    class WrappedClass(cls):
        _protected_attrs = {'__secret', 'password'}

        def __getattribute__(self, name):
            # 检查是否为受保护的私有属性
            if name in object.__getattribute__(self, '_protected_attrs') or \
               (name.startswith('__') and not name.endswith('__')):
                # 获取真实属性名以进行判断
                real_name = name
                if hasattr(object.__getattribute__(self, '__class__'), '__name__'):
                    cls_name = object.__getattribute__(self, '__class__').__name__
                    real_name = f"_{cls_name}{name}"
                
                # 简单的安全策略：拒绝访问
                print(f"[Security] 拒绝访问敏感属性：{name}")
                raise AttributeError(f"无法访问属性：{name}")
            
            return super().__getattribute__(name)

        def __setattr__(self, name, value):
            if name.startswith('__') and not name.endswith('__'):
                print(f"[Security] 拒绝设置敏感属性：{name}")
                raise AttributeError(f"无法设置属性：{name}")
            
            super().__setattr__(name, value)

    return WrappedClass

@control_sensitive_attributes
class User:
    def __init__(self):
        self.username = "admin"
        self.__password = "123456"

user = User()
print(user.username)  # 正常访问
try:
    print(user.__password)  # 触发异常
except AttributeError as e:
    print(e)

在此场景中，装饰器充当了安全网关的角色。当检测到对私有属性的非法访问尝试时，主动抛出异常，防止数据泄露或意外篡改。

装饰器的嵌套应用

在实际开发中，单一的控制可能不足以满足需求。装饰器支持嵌套使用，以实现多重控制逻辑。需要注意的是，嵌套装饰器的执行顺序是从下往上（即最靠近类的装饰器最先执行）。

def log_access(cls):
    class LogWrapper(cls):
        def __getattribute__(self, name):
            print(f"Log: 读取 {name}")
            return super().__getattribute__(name)
        def __setattr__(self, name, value):
            print(f"Log: 写入 {name}")
            super().__setattr__(name, value)
    return LogWrapper

def validate_input(cls):
    class ValidateWrapper(cls):
        def __setattr__(self, name, value):
            if isinstance(value, str) and len(value) == 0:
                raise ValueError("字符串不能为空")
            super().__setattr__(name, value)
    return ValidateWrapper

@log_access
@validate_input
class DataModel:
    def __init__(self):
        self.name = "Test"
        self.data = "Valid"

model = DataModel()
model.name = "New Name"  # 先经过 validate_input，再经过 log_access

上述代码中，validate_input 位于内层，负责数据校验；log_access 位于外层，负责日志记录。这种组合模式极大地增强了系统的可观测性和健壮性。

性能考量与最佳实践

虽然装饰器提供了强大的元编程能力，但滥用也会带来性能开销。

1. 性能影响

重写 __getattribute__ 会对每个属性访问产生额外开销。对于高频调用的热点代码路径，建议仅针对特定属性进行拦截，或使用 __slots__ 减少字典查找成本。

2. 避免递归陷阱

在 __getattribute__ 中，务必使用 super().__getattribute__ 或 object.__getattribute__ 来获取属性，切勿直接访问 self.attr，否则会导致无限递归栈溢出。

3. 与 @property 的区别

• @property 是描述符，用于单个属性的 getter/setter，语法简洁，适合局部逻辑。
• 类装饰器 + __getattribute__ 适用于全局策略，如自动序列化、加密存储或跨类统一审计。

4. 推荐用法

• 仅在确实需要全局拦截时使用类装饰器。
• 优先使用 __getattr__ 而非 __getattribute__ 以减少性能损耗，除非必须拦截所有访问。
• 结合类型提示（Type Hints）确保代码可读性。

总结

Python 装饰器为程序员提供了灵活的工具，能够动态地修改函数或类的行为，其中包括对类中公有和私有属性的访问和设置行为进行控制。本文深入探讨了装饰器在这方面的应用。

通过基础的装饰器概念引入，了解了装饰器如何扩展函数和类的功能而不改变其本身。随后，文章重点讨论了泛化公有和私有属性的需求。对于程序员来说，控制公有和私有属性的访问行为对于代码的安全性和可维护性至关重要。

本文详细介绍了如何使用装饰器监控和修改公有属性的访问和设置行为，以及如何对私有属性的访问行为进行定制化。示例代码演示了装饰器如何拒绝或修改对类属性的访问，确保程序在访问和设置属性时更加安全和可控。

最后，通过展示装饰器的嵌套应用，强调了多重控制的灵活性。本文的目的是帮助大家理解并应用装饰器，探索其在 Python 类中对公有和私有属性行为控制方面的重要性。装饰器为代码提供了更多的灵活性和可扩展性，使得程序更具鲁棒性，值得进一步深入研究和应用。

在实际项目中，合理运用属性访问控制装饰器，可以有效降低耦合度，提升系统的安全性。希望读者能根据具体业务场景，选择合适的方案，构建高质量的 Python 应用程序。