单例场景下如何实现Modifier链式调用时修改方法执行逻辑

核心思路是通过代理对象隔离临时修改的行为，完全不改动单例本身的状态，确保后续调用不受影响。

实现步骤 #

1. 定义一个代理类，仅重写需要修改行为的do_something方法，其他方法直接转发给原单例。
2. 在Foo类中添加modifier方法，返回该代理对象而非修改单例自身。

完整代码示例 #

from functools import partial
# 这里假设使用Django的transaction，替换为你实际用的事务API即可
from django.db import transaction

class FooModifierProxy:
    def __init__(self, foo_instance):
        self.foo = foo_instance  # 持有原单例引用

    def do_something(self, key=None, value=None):
        # 链式调用时的逻辑：绑定默认参数并交给事务提交钩子
        return transaction.on_commit(
            partial(self.foo.do_something, key='a', value=1)
        )

    # 代理所有未重写的方法，保证原单例的其他功能正常使用
    def __getattr__(self, name):
        return getattr(self.foo, name)

class Foo:
    # 单例实现
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def modifier(self):
        # 返回代理对象，不修改原单例任何状态
        return FooModifierProxy(self)

    def do_something(self, key=None, value=None):
        # 正常调用逻辑：执行业务任务并返回结果
        return self.some_job(key, value)

    def some_job(self, key, value):
        # 实际业务逻辑，根据需求替换
        return f"Processed {key}:{value}"

使用方式 #

• 正常调用（无事务延迟）：

foo = Foo()
print(foo.do_something(key='b', value=2))  # 输出: Processed b:2

• 链式调用modifier（事务延迟执行）：

# 该调用会返回事务提交钩子，事务提交后自动执行foo.do_something(key='a', value=1)
foo.modifier().do_something()

方案优势 #

• 完全不修改单例的状态，后续所有对原单例的调用都保持原有逻辑。
• 线程安全：每个链式调用的代理对象都是独立实例，不会出现多线程状态干扰问题。
• 扩展性强：如果后续需要修改其他方法的临时行为，只需在代理类中添加对应重写即可。

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