谈谈Python中元类Metaclass(二)：ORM实践

什么是ORM？

ORM的英文全称是“Object Relational Mapping”，即对象-关系映射，从字面上直接理解，就是把“关系”给“对象”化。

对应到数据库，我们知道关系数据库（例如Mysql）的特征就是数据与数据之间存在各种各样的“关系”，这种“关系”是由Table(表)来维护和表现的。

ORM就是把关系数据库的一个"表"映射成一个"类"，然后给"类"添加各种各样的方法（比如增删改查）。

也就是说，我们要完成这样的设计：user可以根据实际需求（表的定义，比如包括哪些数据字段等）把通过ORM把"表"(table)设计成一个"类"(class)，这就需要用到Metaclass的特性: 动态的创建类(class)

这样，写代码更简单，不用直接操作SQL语句。

要编写一个ORM框架，所有的类都只能动态定义，因为我们知道，在数据库使用过程中，Mysql的“表”是由User来创建的；对应过来，那么“表”对应的类也是应该由User来创建的。

让我们来尝试编写一个ORM框架。

编写底层模块的第一步，就是先把调用接口写出来。

先搞清楚user会如何使用这个ORM框架：使用这个ORM框架，创建一个Customer类来操作对应的数据库表customer，我们期待他写出这样的代码：

class Customer(Model):
    # 定义类的属性到列的映射：
    id = IntegerField('id')
    name = StringField('username')
    email = StringField('email')
    password = StringField('password')
 
# 创建一个实例：
u = Customer(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
# 保存到数据库：
u.save()

其中，父类Model和属性类型StringField、IntegerField是由ORM框架提供的。显然，save()等方法应该由ORM提供，这样既安全又使得user不用重复定义这些方法。具体实现上，save()等全部由metaclass和基类Model自动完成。虽然metaclass和基类Model的编写会比较复杂，但ORM的使用者用起来却异常简单。

现在，我们就按上面的接口来实现该ORM。

首先搞清楚我们应该做的工作：

• 1. 既然要使得user能够通过继承Model，实现动态的创建类，那么必然要在ModelMetaclass中实现动态类的创建（比如能实现类Cutomer中的定义的attr属性们）
• 2. 在基类Model中实现save等方法。

首先来定义Field类，它负责保存数据库表的字段名和字段类型：

class Field(object):
 
    def __init__(self, name, column_type):
        self.name = name
        self.column_type = column_type
 
    def __str__(self):
        return '<%s:%s>' % (self.__class__.__name__, self.name)

在Field的基础上，进一步定义各种类型的Field，比如StringField，IntegerField等等：

class StringField(Field):
 
    def __init__(self, name):
        super(StringField, self).__init__(name, 'varchar(100)')
 
class IntegerField(Field):
 
    def __init__(self, name):
        super(IntegerField, self).__init__(name, 'bigint')

下一步，就是编写最复杂的ModelMetaclass了：

class ModelMetaclass(type):
 
    def __new__(cls, name, bases, attrs):
        if name=='Model':
            return type.__new__(cls, name, bases, attrs)
        print('Found model: %s' % name)
        mappings = dict()
        for k, v in attrs.items():
            if isinstance(v, Field):
                print('Found mapping: %s ==> %s' % (k, v))
                mappings[k] = v
        for k in mappings.keys():
            attrs.pop(k)
        attrs['__mappings__'] = mappings # 保存属性和列的映射关系
        attrs['__table__'] = name # 假设表名和类名一致
        return type.__new__(cls, name, bases, attrs)

当用户定义一个class Customer(Model)时，Python解释器首先在当前类Customer的定义中查找metaclass，如果没有找到，就继续在父类Model中查找metaclass，找到了，就使用Model中定义的metaclass的ModelMetaclass来创建Customer类，也就是说，metaclass可以隐式地继承到子类，但子类自己却感觉不到。

在ModelMetaclass中，一共做了几件事情：

1. 排除掉对Model类的修改（肯定要避免user通过调用ModelMetaclass来修改我们定义好的基类Model）；

2. 在当前类（比如Customer）中查找user定义的类(也就是例子中的Customer)的所有属性，如果找到一个Field属性，就把它保存到一个__mappings__的dict中，同时从类(Customer)的属性中删除该Field属性，否则，容易造成运行时错误（实例的属性会遮盖类的同名属性，也就是说保证Customer这个类里没有id,name等属性，从而不会影响Customer的实例的值; 这里之所以为了避免出现实例与类的同名属性，既避免运行时错误，是因为当出现类和实例的同名属性时，python会优先调用实例属性，如果没有的话则会调用类的属性，但是有时当实例属性不存在时，我们并不希望用户能调用到这个同名的类属性，比如当实例属性被删除时，再用相同的名字，就访问到了类属性了。因此才这么做）；

3. 把表名保存到__table__中，这里简化为表名默认为类名。

以及基类Model：

class Model(dict, metaclass=ModelMetaclass):
 
    def __init__(self, **kw):
        super(Model, self).__init__(**kw)
 
    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Model' object has no attribute '%s'" % key)
 
    def __setattr__(self, key, value):
        self[key] = value
 
    def save(self):
        fields = []
        params = []
        args = []
        for k, v in self.__mappings__.items():
            fields.append(v.name)
            params.append('?')
            args.append(getattr(self, k, None))
        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
        print('SQL: %s' % sql)
        print('ARGS: %s' % str(args))

在Model类中，就可以定义各种操作数据库的方法，比如save()，delete()，find()，update等等。

我们实现了save()方法，把一个实例保存到数据库中。因为有表名，属性到字段的映射和属性值的集合，就可以构造出INSERT语句。

编写代码试试：

u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
u.save()

输出如下：

Found model: User
Found mapping: email ==> <StringField:email>
Found mapping: password ==> <StringField:password>
Found mapping: id ==> <IntegerField:uid>
Found mapping: name ==> <StringField:username>
SQL: insert into User (password,email,username,id) values (?,?,?,?)
ARGS: ['my-pwd', 'test@orm.org', 'Michael', 12345]

可以看到，save()方法已经打印出了可执行的SQL语句，以及参数列表，只需要真正连接到数据库，执行该SQL语句，就可以完成真正的功能。

最终，我们实现了关系型数据库的ORM框架，user可以通过继承Model类，把各种各样的表写成对象，进行操作。

总结一下，通过ORM的这个例子，我们可以看出Metaclass的作用总结起来就三点：

1.   拦截类的创建

2.   修改类

3.   返回修改之后的类

参考链接：

深刻理解Python中的元类(metaclass)

廖雪峰 Python 教程 使用元类