基类自动发现场景下自定义方法注册的优化方案问询

听起来你正在设计一个行为驱动的基类——自动检测通用方法并执行，同时支持扩展自定义方法，这个场景在框架开发里太常见了！你提到的两种方案确实都有体验问题：让用户重写_register不仅要写冗余的super()调用，还得暴露内部的_router细节，完全违背了封装原则；而单纯加注册接口再遍历的话，可能会遇到注册时机混乱、方法优先级不明确这些坑。

我给你推荐两种更优雅的实现思路，既保留封装性，又能让使用者轻松扩展：

方案1：类装饰器 + 自动扫描 #

如果你的基类是要让子类继承使用，可以用类装饰器来收集子类里的自定义方法，不用用户手动注册：

class BaseHandler:
    def __init__(self):
        self._router = {}
        # 先注册通用方法
        self._register_common_methods()
    
    def _register_common_methods(self):
        # 检测并注册通用方法，比如以handle_开头的方法
        for name in dir(self):
            if name.startswith("handle_"):
                method = getattr(self, name)
                if callable(method):
                    # 这里可以根据方法名提取标识，比如handle_user -> user
                    key = name.split("_", 1)[1]
                    self._router[key] = method
    
    # 执行方法的入口
    def execute(self, key):
        return self._router.get(key, lambda: "Method not found")()

# 装饰器：收集子类的自定义方法
def register_custom_method(key):
    def decorator(method):
        # 给方法打标记，记录对应的key
        method._custom_key = key
        return method
    return decorator

# 子类使用示例
class MyHandler(BaseHandler):
    def handle_user(self):
        return "Handling user"
    
    @register_custom_method("order")
    def process_order(self):
        return "Processing order"
    
    @register_custom_method("payment")
    def handle_payment(self):
        return "Handling payment"

# 基类初始化时自动扫描标记的方法
def init_handler(handler_cls):
    original_init = handler_cls.__init__
    def new_init(self, *args, **kwargs):
        original_init(self, *args, **kwargs)
        # 扫描自定义标记的方法
        for name in dir(self):
            method = getattr(self, name)
            if hasattr(method, "_custom_key"):
                self._router[method._custom_key] = method
    handler_cls.__init__ = new_init
    return handler_cls

# 给子类应用初始化增强
MyHandler = init_handler(MyHandler)

# 测试
handler = MyHandler()
print(handler.execute("user"))      # Handling user
print(handler.execute("order"))     # Processing order
print(handler.execute("payment"))   # Handling payment

这种方式下，使用者只需要用@register_custom_method装饰自己的方法，完全不用关心基类内部的_router或者_register方法，体验非常顺滑。

方案2：实例级注册接口 #

如果需要支持运行时动态注册方法，可以给基类加一个公开的register方法，把内部的_router操作封装起来：

class BaseHandler:
    def __init__(self):
        self._router = {}
        self._register_common_methods()
    
    def _register_common_methods(self):
        # 通用方法注册逻辑同上
        for name in dir(self):
            if name.startswith("handle_"):
                method = getattr(self, name)
                if callable(method):
                    key = name.split("_", 1)[1]
                    self._router[key] = method
    
    # 公开的注册接口
    def register(self, key, method):
        if callable(method):
            self._router[key] = method
        else:
            raise ValueError("Registered object must be callable")
    
    def execute(self, key):
        return self._router.get(key, lambda: "Method not found")()

# 使用示例
handler = BaseHandler()

# 动态注册自定义方法
def custom_refund():
    return "Processing refund"

handler.register("refund", custom_refund)

# 或者用lambda
handler.register("cancel", lambda: "Canceling order")

print(handler.execute("refund"))  # Processing refund
print(handler.execute("cancel"))  # Canceling order

这个方案更灵活，支持运行时动态添加方法，而且使用者只需要调用register方法，完全不用接触基类的内部实现。

为什么这两种方案比你之前的思路更好？ #

• 封装性更强：内部的_router和_register_common_methods都是私有方法，使用者不需要了解细节
• 体验更友好：要么用装饰器声明式注册，要么用简单的register方法动态注册，没有冗余的super()代码
• 扩展性更好：可以轻松添加方法优先级、重复注册校验等逻辑，不会影响使用者的代码

如果你之前的“遍历添加所有方法”方案有具体的瑕疵（比如方法覆盖顺序、重复注册冲突），可以基于上面的思路调整——比如在注册时添加重复key的提示，或者给通用方法和自定义方法设置不同的优先级。

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