关于ORM一种实现方法——自定义元类模拟

ORM——对象关系映射(Object Relational Mapping) 

简单一句话就是通过面向对象技术实现和数据库的联系并操作

这里以python面向对象和mysql为例，通过代码对每个步骤进行对应的解释，最后再总结关联起来

 

这是我连接数据库的部分(这里的代码不做解释)

import pymysql

class Mysql(object):
    _instance = None

    def __init__(self):
        self.conn = pymysql.connect(
            host='127.0.0.1',
            port=3306,
            user='root',
            password='123',
            database='day41',
            charset='utf8',
            autocommit=True
        )
        self.cursor = self.conn.cursor(pymysql.cursors.DictCursor)

    def close_db(self):
        self.cursor.close()
        self.conn.close()

    def select(self, sql, args=None):
        self.cursor.execute(sql, args)
        res = self.cursor.fetchall()  # 注意一点:fetchall拿到的数据结构是一个列表套字典[{},{},{}]
        return res

    def execute(self, sql, args):
        try:
            self.cursor.execute(sql, args)
        except BaseException as e:
            print(e)

    @classmethod
    def singleton(cls):
        if not cls._instance:
            cls._instance = cls()
        return cls._instance

 

正文内容：

# 数据库中表的字段通常需要有的属性字段名，字段类型，是否是主键，默认值
class Field(object):
    def __init__(self,name, column_type, primary_key, default):
        self.name = name
        self.column_type = column_type
        self.primary_key = primary_key
        self.default = default


# 定义varchar字段类型
class StringField(Field):
    # 这里的StringField是继承了Field类属性，相当于是Field子类
    # 这里需要注意的是，这时候StringField类也只是走了__init__()方法，它自己本身还没有实例化，自然也就不存在拥有了name, column_type等这些属性
    # 因此下面的方法走完，子类和父类都只是绑定了属性，它们两个类都没有真正拥有属性，因此在实例化前，通过MyMetaClass自定义的元类来为这两个类添加我们想要的功能
    # 如果对面向对象的实例化过程不是很了解，可以参考我的这篇文章先了解一下：https://www.cnblogs.com/SlookUp/p/15097671.html
    def __init__(self, name, column_type='varchar(32)', primary_key=False, default=None):
        super().__init__(name,column_type,primary_key,default)


# 定义int字段类型，原理和上面的StringField类一样
class IntegerField(Field):
    def __init__(self, name, column_type='int', primary_key=False, default=0):
        super().__init__(name, column_type, primary_key, default)


# 这个MyMetaClass就是给需要用到的类提供对应的一些功能，这里我们是要实现通过面向对象的方法来获取和修改数据库
class MyMetaClass(type):
    # 这个type类算是所有类的祖先，类创造属性的工具就是它
    def __new__(cls, class_name, class_bases, class_attrs):
        # 我们定义的元类是用来拦截模型表的创建过程，而models并不是一张模型表，所以不需要它的创建过程
        # __new__方法可以传过来很多参数，可以把它看成是type类的__init__
        if class_name == 'Models':
            return type.__new__(cls,class_name,class_bases,class_attrs)
        # 这里做条件判断，是配合了下面的modle类的__getattr__和__setattr__方法，如果已经存在了已经定义好的modle类，直接返回就可以
        table_name = class_attrs.get('table_name',class_name)
        # 这里很明显就知道class_attrs其实就是接收我们上面定义的两个子类的所有属性(即表的类型)
        # class_name接收类的名字；class_bases就比较复杂，比如python语言中只要使用了关键字class,底层逻辑就是运行class_bases去创建一个对象
        primary_key = None
        mappings = {}
        # 下面的for循环需要做两件事
        # 1.将单个单个的字段整合成一个
        # 2.确定当前表到底哪个字段是主键
        for k,v in class_attrs.items():  # k:id,name   v:IntegerField(),StringField()
            # 拿出所有自己定义的表的字段属性
            # 所以这就是为什么要子类要先走supper().__init__()，如果不提前绑定的话这里就拿不到父类拥有的子类，在定义的子类个数未知的情况下，只能通过这个方法，这也是supper()方法在python最多应用的地方
            if isinstance(v,Field):
                # 将所有的自己定义的表的字段(子类)存入字典中
                mappings[k] = v
                if v.primary_key:
                    # 健壮性校验一张表不能有多个主键
                    if primary_key:
                        raise TypeError("一张表只能有一个主键")
                    primary_key = v.name
        # 循环mapping拿到所有的自定义字段名
        for k in mappings.keys():
            # 将单个单个的字段删除
            # 要删除的原因是，我们填写数据库的时候要填入的各种类型，每种类型大概率不止一个，但是字典的性质key值是唯一的，所以得分别删除然后归纳到一起，通过一个key值取到所有的类型字段
            class_attrs.pop(k)
        # 校验用户自定义的模型表是否指定了主键字段
        if not primary_key:
            raise TypeError("一张表必须要有主键")
        # 将表示表的特征信息 表名，表的主键字段，表的其他字段都塞到类的名称空间中
        class_attrs['table_name'] = table_name
        class_attrs['primary_key'] = primary_key
        class_attrs['mappings'] = mappings
        # 这里的mappings就是对应了表里的字段，到这里基本就完成了一半将面向对象映射到数据库
        return type.__new__(cls, class_name, class_bases, class_attrs)
        # 这里要注意的是，返回的是type的__new__方法，不是我们自定义的def __new__()方法，
        # 实际上MyMetaClass类在继承type的时候，只是相当于一个拥有基础功能的普通类
        # 只有通过返回type.__new__的方法后，这个自定义的类才正式可以叫做类的类，也就是元类，成为了type的一个子类
        # 然后这个元类返回数据，有需要使用这个元类的，它就会根据返回的结果去匹对要用它的类，匹对成功后便完成这个类的重新改造(本质相当于重新为__init__修改或添加了功能)

# 要指定使用元类，必须要通过metaclass方法来引用
class Models(dict, metaclass=MyMetaClass):
    def __init__(self, **kwargs):
        # 在走完上面一行的代码后，Python是不会进入下面这行代码的，而是先运行__getattr__方法和__setattr__方法
        super().__init__(**kwargs)
        # 这里就是把需要对元类返回的结果进行重新绑定给modles

    def __getattr__(self, item):
        return self.get(item,'没有该键!')

    def __setattr__(self, key, value):
        self[key] = value
    # 每次我们要获取或者新建字段名，就分别走__getattr__方法和__setattr__方法，然后每次都会重新走super().__init__(**kwargs)，重新对元类返回的结果进行查询或修改
    @classmethod
    def select(cls,**kwargs):  # id=1,name='SlookUP',password='123'
        ms = Mysql.singleton()
        if not kwargs:
            sql = "select * from %s"%cls.table_name
            res = ms.select(sql)
        else:
            k = list(kwargs.keys())[0]
            v = kwargs.get(k)
            sql = "select * from %s where %s=?"%(cls.table_name,k)  # select * from user where id=?
            sql = sql.replace('?','%s') # select * from user where id=%s
            res = ms.select(sql,v)
        if res:
            return [cls(**r) for r in res]  # [obj1,obj2,obj3]
if __name__ == '__main__':
    class Teacher(Models):
        table_name = 'teacher'
        tid = IntegerField(name='tid',primary_key=True)
        tname = StringField(name='tname')
        # 走到这里，子类实现了实例化，它的父类Field也就顺理成章地也拥有了子类所拥有的所有属性，从而可以通过面向对象方法获取到数据库的数据
    res1 = Teacher.select(tname='王老师')
    print(res1)
    obj1 = res1[0]
    print(type(obj1))

 

所以关于ORM，其实本质是怎么样使我们自己定义的类，和数据库产生关系，数据库的表名、类型，甚至上面没有设计的编码类型，都可以通过我们通过类的各种属性来对其进行模拟对应

ORM是一种思想，在这个思想下，通过自定义元类的来实现具体的功能是一种很常见的方法，所以熟悉并运用metaclass，可以实现非常多的python底层功能，但也正是由于python对元类的构建几乎没有什么约束性，又是开发的一把双刃剑