Python 注册型装饰器

注册型装饰器自动收集函数，实现插件机制和解耦设计。

基本注册模式

# 注册到字典
registry = {}

def register(func):
    registry[func.__name__] = func
    return func  # 返回原函数，不修改行为

@register
def handler_a():
    return "Handler A"

@register
def handler_b():
    return "Handler B"

print(registry)  # {'handler_a': <func>, 'handler_b': <func>}
print(registry['handler_a']())  # Handler A

命令注册示例

commands = {}

def command(name):
    def decorator(func):
        commands[name] = func
        return func
    return decorator

@command('greet')
def greet_command(name):
    print(f"Hello, {name}")

@command('quit')
def quit_command():
    print("Goodbye")

# 调用注册的命令
commands['greet']('Alice')
commands['quit']()

路由注册模式

routes = {}

def route(path):
    def decorator(func):
        routes[path] = func
        return func
    return decorator

@route('/')
def home():
    return "Home Page"

@route('/about')
def about():
    return "About Page"

@route('/users/<int:id>')
def user(id):
    return f"User {id}"

# 路由分发
def dispatch(path):
    handler = routes.get(path)
    if handler:
        return handler()
    return "404 Not Found"

print(dispatch('/'))      # Home Page
print(dispatch('/about')) # About Page

事件处理注册

handlers = {}

def on(event_type):
    def decorator(func):
        if event_type not in handlers:
            handlers[event_type] = []
        handlers[event_type].append(func)
        return func
    return decorator

@on('click')
def handle_click():
    print("处理点击事件")

@on('click')
def log_click():
    print("记录点击日志")

@on('submit')
def handle_submit():
    print("处理提交事件")

# 触发事件
def emit(event_type):
    for handler in handlers.get(event_type, []):
        handler()

emit('click')
# 输出:
# 处理点击事件
# 记录点击日志

插件系统实现

plugins = {}

def plugin(name):
    def decorator(cls):
        plugins[name] = cls
        return cls
    return decorator

@plugin('image')
class ImagePlugin:
    def process(self, file):
        return f"处理图片: {file}"

@plugin('video')
class VideoPlugin:
    def process(self, file):
        return f"处理视频: {file}"

# 动态加载插件
def get_plugin(name):
    return plugins.get(name)

processor = get_plugin('image')
print(processor().process('test.jpg'))

类注册模式

class Registry:
    _registry = {}

    @classmethod
    def register(cls, name):
        def decorator(func):
            cls._registry[name] = func
            return func
        return decorator

    @classmethod
    def get(cls, name):
        return cls._registry.get(name)

@Registry.register('create')
def create_item():
    return "创建项目"

@Registry.register('delete')
def delete_item():
    return "删除项目"

print(Registry.get('create')())  # 创建项目

条件注册

handlers = {}

def register_if(condition):
    def decorator(func):
        if condition:
            handlers[func.__name__] = func
        return func
    return decorator

enabled = True

@register_if(enabled)
def handler_a():
    pass

@register_if(False)  # 不注册
def handler_b():
    pass

print(handlers)  # {'handler_a': <func>}

自动注册基类

class AutoRegistered:
    registry = {}

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        AutoRegistered.registry[cls.__name__] = cls

class HandlerA(AutoRegistered):
    def handle(self):
        return "Handler A"

class HandlerB(AutoRegistered):
    def handle(self):
        return "Handler B"

print(AutoRegistered.registry)
# {'HandlerA': <class HandlerA>, 'HandlerB': <class HandlerB>}

注册器清理

class CleanRegistry:
    _registry = {}

    @classmethod
    def register(cls, name):
        def decorator(func):
            cls._registry[name] = func
            return func
        return decorator

    @classmethod
    def clear(cls):
        cls._registry.clear()

    @classmethod
    def unregister(cls, name):
        cls._registry.pop(name, None)

@CleanRegistry.register('handler')
def handler():
    pass

CleanRegistry.unregister('handler')
CleanRegistry.clear()

注册模式应用

要点总结

• 注册型装饰器将函数存入字典或列表
• 返回原函数，不修改函数行为
• 支持参数化的注册名称
• 多个函数可注册到同一事件类型
• 类注册使用 __init_subclass__
• 实现插件机制、路由系统、事件处理
• 解耦函数定义和调用逻辑
• 注册型装饰器是灵活的设计模式