1. 简介
元类是创建类的类,可以用来屏蔽一些复杂的操作,在用户使用类的时候不知不觉就应用起来。比如每个类都可以使用一些默认方法、属性,这个其实是通过type来创建类的时候就设定好了。从某种角度来看,元类就是一个类模板,其他类根据这个模板来创建类。现在python3.x的书写方式更加符合这种理解
在ORM框架的编程过程中,通过元类,可以把数据库对象和python对象的映射过程透明化,同时可以把复杂的SQL语句也屏蔽,比如保存到数据库只要使用save()即可,十分的方便。例如javaweb里面的struts2框架里面的拦截器,就可以通过这种方式来实现。之所以能这么做,也是因为每个类都必须通过type或者他的子类来创建,因此你可以无条件的再所有类创建的时候对他们做一些“手脚”。在这个ORM框架中,元类做的事情就是将创建出来的类的属性全部获取到,同时把数据库的列名和表名和这些属性关联起来,放到mappings和tables这两个对象中。而Model类是通过这个元类模板创建的,Model类主要是为了提取这些映射好的数据库对象,完成save()操作,这样就可以将sql的执行操作也透明化
2.元类定义和使用
# 元类的作用:
# 1.拦截类的创建
# 2.修改类
# 3.返回修改之后的类
#====================元类定义方法一:使用metaclass属性绑定一个函数=======================
#__metaclass__在类外面,那么在整个文件中的类都会使用元类来创建,如果在类里面则只有相应的类用元类创建
def upper_attr(future_class_name, future_class_parents, future_class_attr):
attrs = ((name, value) for name, value in future_class_attr.items()
if not name.startswith('__'))
# 将它们转为大写形式
uppercase_attr = dict((name.upper(), value) for name, value in attrs)
# 通过'type'来做类对象的创建
return type(future_class_name, future_class_parents, uppercase_attr)
class Foo(object,metaclass=upper_attr):
name = 'test meta class'
print(hasattr(Foo, 'name'))
# 输出: False
print(hasattr(Foo, 'NAME'))
# 输出:True
#===================元类定义使用方法二:使用metaclass属性绑定一个元类(继承type)=================
class UpperAttrMetaclass(type):
# __new__ 是在__init__之前被调用的特殊方法
# __new__是用来创建对象并返回之的方法
# 而__init__只是用来将传入的参数初始化给对象
# 你很少用到__new__,除非你希望能够控制对象的创建
# 这里,创建的对象是类,我们希望能够自定义它,所以我们这里改写__new__
# 如果你希望的话,你也可以在__init__中做些事情
def __new__(cls, name, bases, dct): # 这里的cls就指的是自己UpperAttrMetaclass
attrs = ((name,value) for name,value in dct.items() if not name.startswith('__'))
uppercase_attr = dict((name.upper(),value) for name,value in attrs)
# 调用父类特殊方法(一般是构函数)的方式:super(名字,类对象).__new__或者__init__
return super(UpperAttrMetaclass,cls).__new__(cls,name, bases, uppercase_attr)
# 子类只要再继承UpperAttrMetaclass即可
class TestUpperAttr(metaclass=UpperAttrMetaclass): #将元类赋值给metaclass属性
attr = 'hello world'
print(hasattr(TestUpperAttr, 'attr'))
# 输出: False
print(hasattr(TestUpperAttr, 'ATTR'))
# 输出:True
3.元类的应用
3.1 简单示例
#==================元类使用案例======================
# #P1
class Hello(object):
def hello(self, name='world'):
print('Hello ' + name)
h = Hello()
h.hello()
print(type(Hello))
# #P2
def fn(self, name='china'):
print('Hi ' + name)
# 使用type来生成新的类Hello_world
Hello_world = type('Hello_world', (object,), dict(new_hello=fn))
h = Hello_world()
h.new_hello()
# #P3
# object的特殊方法,用来控制创建类
# __new__()方法接收到的参数依次是:
#
# 当前准备创建的类的对象;
#
# 类的名字;
#
# 类继承的父类集合;
#
# 类的方法集合。
class ListMetaclass(type):
def __new__(cls, name, bases, attrs):
attrs['add'] = lambda self, value: self.append(
value) # attrs是属性和函数合集,其中的'add'是一个用lambda声明的匿名函数
for k, v in attrs.items():
print(k, v)
return type.__new__(cls, name, bases, attrs)
#
# #这里告诉类模板是基于list来创建类
class MyList(list, metaclass=ListMetaclass):
pass
L = MyList()
L.add(list('Looks good!'))
print(L)
3.2 简易ORM框架
# P4 使用元类来创建一个建议的ORM框架
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)
class StringField(Field):
def __init__(self, name):
# name保存子类域的类型
super(StringField, self).__init__(name, 'varchar(100)') # 调用父类的方法
class IntegerField(Field):
def __init__(self, name):
super(IntegerField, self).__init__(name, 'bigint')
# 这个就是一个类模板,用来实现一些魔法
class ModelMetaclass(type):
def __new__(cls, name, bases, attrs):
if name == 'Model':
return type.__new__(cls, name, bases, attrs)
print('Found model: %s' % name) # model类就是用户自己定义的模型类,现在还没和关系对象进行关联
mappings = dict()
for k, v in attrs.items():
if isinstance(v, Field): # 将用户自己定义的模型类的属性保存到一个map对象里
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)
# 在ModelMetaclass中,一共做了几件事情:
# 排除掉对Model类的修改;
# 在当前类(比如User)中查找定义的类的所有属性,如果找到一个Field属性,就把它保存到一个__mappings__的dict中
# 同时从类属性中删除该Field属性,否则,容易造成运行时错误(实例的属性会遮盖类的同名属性);
# 把表名保存到__table__中,这里简化为表名默认为类名。
# 在Model类中,就可以定义各种操作数据库的方法,比如save(),delete(),find(),update等等。
# 需要用元类创建的类Model类
class Model(dict, metaclass=ModelMetaclass):
def __init__(self, **kw):
# 把Model类利用dict的__init__初始化
super(Model, self).__init__(**kw)
# 返回相应key的value
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))
class User(Model):
# 定义类的属性到列的映射:
id = IntegerField('id')
name = StringField('username')
email = StringField('email')
password = StringField('password')
u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd')
u.save()