Python装饰器与工厂模式高级应用

1. Python中模块的角色与“静态类”的思考

在Python中，模块（.py文件）可以被视为组织代码的基本单元，它们确实在某种程度上类似于其他语言中的“静态类”，即无需实例化即可直接访问其内部定义的函数、变量和类。例如，我们可以直接调用 math.sqrt() 而无需创建 math 模块的实例。

当我们在模块级别定义函数和变量时，如：

# my_module.py
propA = "value"
propB = "value"

def funA():
    pass

def funB():
    global propA, propB # 修改模块级变量需要使用global
    propA = "new_value"
    pass

这种方式简洁高效，避免了在类方法中频繁使用 @staticmethod 装饰器并传递 cls 参数的繁琐。然而，当需要修改模块级别的变量时，必须显式使用 global 关键字，这有时会引入维护上的复杂性。

用户提出的核心需求是希望能够创建“模块模板”，即像C#中的泛型类一样，在导入模块时传入不同的参数，从而生成具有不同配置的模块实例。例如，一个处理SQL查询的模块，可能希望在导入时指定不同的表名，而无需修改原始模块文件。虽然Python没有直接的“装饰器导入”语法或内建的“模块模板”机制，但我们可以通过其他Pythonic模式来实现类似的效果。

2. 通过类装饰器实现批量功能应用

在面向对象编程中，如果一个类中的所有方法都需要应用相同的装饰器（例如，都变为类方法 classmethod），逐个装饰会非常冗余。Python的类装饰器提供了一种优雅的解决方案，允许我们批量地修改或增强类中的成员。

以下是一个通用的类装饰器 all_decorated_with，它可以将指定的装饰器应用于类中的所有可调用成员（非特殊方法）：

import types

def all_decorated_with(decorator):
    """
    一个类装饰器工厂，用于将指定的装饰器应用于类中的所有可调用成员。
    """
    def _decorator(cls):
        for name, obj in vars(cls).items():
            # 检查对象是否为可调用（函数、方法等），并且不是特殊方法（如__init__）
            if callable(obj) and not (name.startswith('__') and name.endswith('__')):
                # 如果是函数，直接应用装饰器
                if isinstance(obj, (types.FunctionType, types.MethodType)):
                    setattr(cls, name, decorator(obj))
                # 如果是静态方法或类方法，需要特殊处理，因为它们本身就是装饰器应用后的结果
                # 这里为了简化，我们假设decorator可以直接作用于原始函数或已有的方法对象
                # 更健壮的实现可能需要检查并提取原始函数
                elif isinstance(obj, (staticmethod, classmethod)):
                    # 对于已是staticmethod或classmethod的，通常不再重复应用
                    # 如果需要替换其内部的函数，则需要更复杂的逻辑
                    pass # 示例中不再对已装饰的进行处理
        return cls
    return _decorator

# 示例应用：将所有方法转换为类方法
@all_decorated_with(classmethod)
class Foo:
    a = None # 类属性

    def set(cls, value):
        """将类属性a设置为给定值。"""
        cls.a = value

    def get(cls):
        """获取类属性a的值。"""
        return cls.a

# 使用转换后的类方法
Foo.set(1)
print(f"Foo.a 的当前值: {Foo.get()}") # 输出: Foo.a 的当前值: 1

# 创建另一个实例，验证类属性共享
Foo.set(2)
print(f"Foo.a 的新值: {Foo.get()}") # 输出: Foo.a 的新值: 2

在这个示例中，all_decorated_with(classmethod) 自动将 Foo 类中的 set 和 get 方法转换为类方法，使得它们可以通过类本身而非实例来调用，并且第一个参数自动接收类本身。这种模式极大地减少了重复代码，提高了类的可读性和可维护性。

3. 利用类工厂模式实现“模板化”类

用户提出的“模块模板”概念，在Python中更常通过“类工厂”（Class Factory）模式来实现，尤其适用于需要根据运行时参数生成具有不同配置的类。类工厂是一个函数，它根据传入的参数动态地创建并返回一个新的类。

以下是一个 foo_factory 示例，演示如何根据传入的 v 值创建不同的 _Foo 类：

def foo_factory(v):
    """
    一个类工厂函数，根据传入的参数v动态创建并返回一个新类。
    """
    class _Foo:
        # 类属性a的值由工厂函数参数v决定
        a = v

        def __init__(self, name):
            self.name = name

        def get_value(self):
            return self.a

        def get_name(self):
            return self.name

    return _Foo

# 使用工厂函数创建两个不同的类
Foo1 = foo_factory(1)
Foo2 = foo_factory(2)

# 验证不同类实例的类属性值
print(f"Foo1.a 的值: {Foo1.a}") # 输出: Foo1.a 的值: 1
print(f"Foo2.a 的值: {Foo2.a}") # 输出: Foo2.a 的值: 2

# 也可以创建这些类的实例
instance1 = Foo1("Instance One")
instance2 = Foo2("Instance Two")

print(f"实例1的值: {instance1.get_value()}, 名字: {instance1.get_name()}")
print(f"实例2的值: {instance2.get_value()}, 名字: {instance2.get_name()}")

在这个例子中，foo_factory 函数接受一个参数 v，并在其内部定义并返回一个名为 _Foo 的新类。这个新类的类属性 a 被设置为 v 的值。每次调用 foo_factory 时，都会生成一个全新的类，即使它们具有相同的结构，但其内部的配置（如 a 的值）可以不同。

应用场景拓展：SQL查询模板

用户提到的SQL查询模板是一个非常典型的应用场景。我们可以创建一个SQL查询工厂，根据传入的表名动态生成一个包含CRUD操作方法的类：

def create_table_dao(table_name):
    """
    创建一个数据访问对象（DAO）类，用于特定表的SQL操作。
    """
    class TableDAO:
        def __init__(self, db_connection):
            self.conn = db_connection
            self.table = table_name

        def insert(self, data):
            # 示例：生成插入SQL语句
            columns = ', '.join(data.keys())
            placeholders = ', '.join(['%s'] * len(data))
            sql = f"INSERT INTO {self.table} ({columns}) VALUES ({placeholders})"
            print(f"Executing: {sql} with {list(data.values())}")
            # self.conn.execute(sql, list(data.values()))

        def select_all(self):
            # 示例：生成查询所有记录的SQL语句
            sql = f"SELECT * FROM {self.table}"
            print(f"Executing: {sql}")
            # cursor = self.conn.cursor()
            # cursor.execute(sql)
            # return cursor.fetchall()

        def update(self, condition, new_data):
            # 示例：生成更新SQL语句
            set_clause = ', '.join([f"{k} = %s" for k in new_data.keys()])
            sql = f"UPDATE {self.table} SET {set_clause} WHERE {condition}"
            print(f"Executing: {sql} with {list(new_data.values())}")
            # self.conn.execute(sql, list(new_data.values()))

    return TableDAO

# 为不同的表创建特定的DAO类
UsersDAO = create_table_dao("users")
ProductsDAO = create_table_dao("products")

# 使用这些DAO类
# 假设有一个数据库连接对象 db_conn
# db_conn = ...

users_dao = UsersDAO(None) # 实际应传入数据库连接
users_dao.insert({"name": "Alice", "email": "alice@example.com"})
users_dao.select_all()

products_dao = ProductsDAO(None) # 实际应传入数据库连接
products_dao.insert({"item": "Laptop", "price": 1200})
products_dao.select_all()

通过 create_table_dao 工厂函数，我们可以轻松地为不同的数据库表生成具有相同操作逻辑但针对特定表的DAO类，实现了高度的代码复用和配置隔离。

4. 注意事项与总结

• Pythonic哲学： Python鼓励显式优于隐式。虽然直接装饰 import 语句的想法很有趣，但它不符合Python的模块导入机制。类装饰器和类工厂模式是Python中实现代码复用和动态配置的更标准、更可读的方法。
• 可读性与维护性： 使用类装饰器可以显著减少重复代码，使类定义更简洁。类工厂模式则允许在运行时动态生成定制的类，这对于需要根据不同参数生成相似结构的情况非常有用。
• 替代方案： 对于更简单的配置，可以考虑使用函数参数、配置文件（如YAML、JSON）或环境变量来传递配置。对于复杂的结构，继承和组合也是实现代码复用的重要手段。
• 动态性与复杂性： 动态创建类或在运行时修改类结构虽然强大，但也可能增加代码的复杂性和调试难度。应权衡其带来的灵活性和潜在的维护成本。

总之，Python通过其强大的元编程能力，如装饰器和动态类创建，提供了多种途径来解决“代码模板化”和“静态类”配置的需求。理解并恰当运用这些模式，能够帮助开发者编写出更灵活、更具扩展性的Python应用程序。