在一个Web App中，所有数据，包括用户信息、发布的日志、评论等，都存储在数据库中。在awesome-python3-webapp中，我们选择MySQL作为数据库。
Web App里面有很多地方都要访问数据库。访问数据库需要创建数据库连接、游标对象，然后执行SQL语句，最后处理异常，清理资源。这些访问数据库的代码如果分散到各个函数中，势必无法维护，也不利于代码复用。
所以，我们要首先把常用的SELECT、INSERT、UPDATE和DELETE操作用函数封装起来。
由于Web框架使用了基于asyncio的aiohttp，这是基于协程的异步模型。在协程中，不能调用普通的同步IO操作，因为所有用户都是由一个线程服务的，协程的执行速度必须非常快，才能处理大量用户的请求。而耗时的IO操作不能在协程中以同步的方式调用，否则，等待一个IO操作时，系统无法响应任何其他用户。
这就是异步编程的一个原则：一旦决定使用异步，则系统每一层都必须是异步，“开弓没有回头箭”。
幸运的是aiomysql为MySQL数据库提供了异步IO的驱动。
一、 创建连接池
我们需要创建一个全局的连接池，每个HTTP请求都可以从连接池中直接获取数据库连接。使用连接池的好处是不必频繁地打开和关闭数据库连接，而是能复用就尽量复用。
连接池由全局变量__pool存储，缺省情况下将编码设置为utf8，自动提交事务：
@asyncio.coroutine
def create_pool(loop, **kw):
logging.info('create database connection pool...')
global __pool
__pool = yield from aiomysql.create_pool(
host=kw.get('host', 'localhost'),
port=kw.get('port', 3306),
user=kw['user'],
password=kw['password'],
db=kw['db'],
charset=kw.get('charset', 'utf8'),
autocommit=kw.get('autocommit', True),
maxsize=kw.get('maxsize', 10),
minsize=kw.get('minsize', 1),
loop=loop
)
二、 封装select方法
要执行SELECT语句，我们用select函数执行，需要传入SQL语句和SQL参数：
@asyncio.coroutine
def select(sql, args, size=None):
log(sql, args)
global __pool
with (yield from __pool) as conn:
cur = yield from conn.cursor(aiomysql.DictCursor) # 光标，都是套路样式了
yield from cur.execute(sql.replace('?', '%s'), args or ()) # select后面参数为sql,args均在这句里，这里定义的是select函数，实例必须用的时候传入sql,args值后实现
if size: # 默认值为None
rs = yield from cur.fetchmany(size) # size可以决定取几条
else:
rs = yield from cur.fetchall()
yield from cur.close()
logging.info('rows returned: %s' % len(rs))
return rs
SQL语句的占位符是?，而MySQL的占位符是%s，select()函数在内部自动替换。注意要始终坚持使用带参数的SQL，而不是自己拼接SQL字符串，这样可以防止SQL注入攻击。
注意到yield from将调用一个子协程（也就是在一个协程中调用另一个协程）并直接获得子协程的返回结果。
如果传入size参数，就通过fetchmany()获取最多指定数量的记录，否则，通过fetchall()获取所有记录。
三、 封装execute方法(update,insert,delete)
除了select方法要返回查询内容，要执行INSERT、UPDATE、DELETE语句，可以定义一个通用的execute()函数，因为这3种SQL的执行都需要相同的参数，以及返回一个整数表示影响的行数：
@asyncio.coroutine
def execute(sql, args):
log(sql)
with (yield from __pool) as conn:
try:
cur = yield from conn.cursor()
yield from cur.execute(sql.replace('?', '%s'), args) # 这句这么解读，execute 已经换过占位符的sql 和 args
affected = cur.rowcount # 返回结果数
yield from cur.close()
except BaseException as e:
raise
return affected
execute()函数和select()函数所不同的是，cursor对象不返回结果集，而是通过rowcount返回结果数。
开始前的思考
编程中有个思想叫做”自顶向下“。所以当你对如何设计ORM无从下手的时候，你可以假设已经有一个ORM框架，你想怎么用？
# 我们期待ORM后 要的效果，不是ORM的程序代码
class Model(object): # 假设
async def find(self):
pass
class User(Model):
# 注意这里的都是类属性
__table__="users"
id=StringField(...)
name=StringField(...)
user=User(id="10001",name="Andy")
user.save()
有没有发现，这样看User类，很清楚，对应user表，这个表有哪些字段，一目了然。然后让子类继承父类，实现对find,save...等方法的复用。真是完美，可是要怎么实现呢？
一、 正式开始 ORM
有了基本的select()和execute()函数，我们就可以开始编写一个简单的ORM了。
设计ORM需要从上层调用者角度来设计。
我们先考虑如何定义一个User对象，然后把数据库表users和它关联起来。
# 我们期待ORM后 要的效果，不是ORM的程序代码
from orm import Model, StringField, IntegerField
class User(Model):
__table__ = 'users'
id = IntegerField(primary_key=True)
name = StringField()
注意到定义在User类中的__table__、id和name是类的属性，不是实例的属性。所以，在类级别上定义的属性用来描述User对象和表的映射关系，而实例属性必须通过__init__()方法去初始化，所以两者互不干扰：
# 创建实例: # 我们期待ORM后 要的效果，不是ORM的程序代码
user = User(id=123, name='Michael')
# 存入数据库:
user.insert()
# 查询所有User对象:
users = User.findAll()
二、 定义Model
首先要定义的是所有ORM映射的基类Model：
class Model(dict, metaclass=ModelMetaclass):
# 让Model继承dict,主要是为了具备dict所有的功能，如get方法
# metaclass指定了Model类的元类为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) # r 正则里的转义字符，忽略字符串的转义
def __setattr__(self, key, value):
self[key] = value
# 实现__getattr__与__setattr__方法，可以使引用属性像引用普通字段一样 如self['id']
def getValue(self, key):
return getattr(self, key, None)
def getValueOrDefault(self, key): # 取默认值，上面字段类不是有一个默认值属性嘛，默认值也可以是函数
value = getattr(self, key, None)
if value is None:
field = self.__mappings__[key]
if field.default is not None:
value = field.default() if callable(field.default) else field.default
logging.debug('using default value for %s: %s' % (key, str(value))) #default值可以设置为值或调用对象（无法设置值时，如default = time.time 插入当前时间）
setattr(self, key, value)
return value
# 往Model类添加实例方法，就可以让所有子类调用实例方法
# ser类现在就可以通过类方法实现主键查找
# 一步异步，处处异步，所以这些方法都必须是一个协程
#下面 self.__mappings__,self.__insert__等变量据是根据对应表的字段不同，而动态创建
@asyncio.coroutine
def save(self):
args=list(map(self.getValueOrDefault,self.__mappings__))
yield from execute(self.__insert__,args)
@asyncio.coroutine
def remove(self):
args=[]
args.append(self[self.__primaryKey__])
print(self.__delete__)
yield from execute(self.__delete__,args)
@asyncio.coroutine
def update(self,**kw):
print("enter update")
args=[]
for key in kw:
if key not in self.__fields__:
raise RuntimeError("field not found")
for key in self.__fields__:
if key in kw:
args.append(kw[key])
else:
args.append(getattr(self,key,None))
args.append(getattr(self,self.__primaryKey__))
yield from execute(self.__update__,args)
# 类方法
@classmethod #根据主键查找数据库
@asyncio.coroutine
def find(cls,pk):
rs = yield from select('%s where `%s`=?' % (cls.__select__, cls.__primaryKey__), [pk], 1)
if len(rs) == 0:
return None
return cls(**rs[0]) # 返回的是一个实例对象引用
@classmethod
@asyncio.coroutine
def findAll(cls,where=None,args=None):
sql=[cls.__select__]
if where:
sql.append('where')
sql.append(where)
if args is None:
args=[]
rs=yield from select(' '.join(sql),args)
return [cls(**r) for r in rs] # 将返回的结果迭代生成类的实例，返回的都是实例对象, 而非仅仅是数据
三、 定义字段 Field
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 # 有无默认值
def __str__(self):
return '<%s, %s:%s>' % (self.__class__.__name__, self.column_type, self.name)
# 映射varchar的StringField
class StringField(Field):
def __init__(self, name=None, primary_key=False, default=None, ddl='varchar(100)'):
super().__init__(name, ddl, primary_key, default)
# 其它字段略，一个道理，一个模式
四、 ModelMetaclass
注意到Model只是一个基类，如何将具体的子类如User的映射信息读取出来呢？答案就是通过metaclass：ModelMetaclass：
class ModelMetaclass(type):
# 元类必须实现__new__方法，当一个类指定通过某元类来创建，那么就会调用该元类的__new__方法
# 该方法接收4个参数
# cls为当前准备创建的类的对象
# name为类的名字，创建User类，则name便是User
# bases类继承的父类集合,创建User类，则base便是Model
# attrs为类的属性/方法集合，创建User类，则attrs便是一个包含User类属性的dict
def __new__(cls, name, bases, attrs):
# 排除Model类本身:
if name=='Model':
return type.__new__(cls, name, bases, attrs)
# 因为Model类是基类，所以排除掉，如果你print(name)的话，会依次打印出Model,User,Blog，即所有的Model子类，因为这些子类通过Model间接继承元类
# 获取table名称:
tableName = attrs.get('__table__', None) or name # 取出表名，默认与类的名字相同
logging.info('found model: %s (table: %s)' % (name, tableName))
# 获取所有的Field和主键名:
mappings = dict() # 用于存储所有的字段，以及字段值
fields = [] # 仅用来存储非主键意外的其它字段，而且只存key
primaryKey = None
# 仅保存主键的key
for k, v in attrs.items():
# 注意这里attrs的key是字段名，value是字段实例，不是字段的具体值
# 比如User类的id=StringField(...) 这个value就是这个StringField的一个实例，而不是实例化
# 的时候传进去的具体id值
if isinstance(v, Field): # attrs同时还会拿到一些其它系统提供的类属性，我们只处理自定义的类属性，所以判断一下
logging.info(' found mapping: %s ==> %s' % (k, v)) # isinstance 方法用于判断v是否是一个Field
mappings[k] = v
if v.primary_key:
# 找到主键:
if primaryKey:
raise RuntimeError('Duplicate primary key for field: %s' % k)
primaryKey = k
else:
fields.append(k)
if not primaryKey: # 保证了必须有一个主键
raise RuntimeError('Primary key not found.')
for k in mappings.keys(): # 记录到了mappings,fields，等变量里，而我们实例化的时候，如user=User(id='10001') ，为了防止这个实例变量与类属性冲突，所以将其去掉
attrs.pop(k) # 这里的目的是去除类属性，为什么要去除呢，因为我想知道的信息已经记录下来了。
# 以下都是要返回的东西了，刚刚记录下的东西，如果不返回给这个类，又谈得上什么动态创建呢？
# 到此，动态创建便比较清晰了，各个子类根据自己的字段名不同，动态创建了自己
# 下面通过attrs返回的东西，在子类里都能通过实例拿到，如self
escaped_fields = list(map(lambda f: '`%s`' % f, fields))
attrs['__mappings__'] = mappings # 保存属性和列的映射关系
attrs['__table__'] = tableName
attrs['__primary_key__'] = primaryKey # 主键属性名
attrs['__fields__'] = fields # 除主键外的属性名
# 构造默认的SELECT, INSERT, UPDATE和DELETE语句:
attrs['__select__'] = 'select `%s`, %s from `%s`' % (primaryKey, ', '.join(escaped_fields), tableName)
attrs['__insert__'] = 'insert into `%s` (%s, `%s`) values (%s)' % (tableName, ', '.join(escaped_fields), primaryKey, create_args_string(len(escaped_fields) + 1))
attrs['__update__'] = 'update `%s` set %s where `%s`=?' % (tableName, ', '.join(map(lambda f: '`%s`=?' % (mappings.get(f).name or f), fields)), primaryKey)
attrs['__delete__'] = 'delete from `%s` where `%s`=?' % (tableName, primaryKey)
return type.__new__(cls, name, bases, attrs)
这样，任何继承自Model的类（比如User），会自动通过ModelMetaclass扫描映射关系，并存储到自身的类属性如__table__、__mappings__中。
这样，就可以把一个User实例存入数据库：
user = User(id=123, name='Mic') # 测试用，非orm代码
yield from user.save()
最后一步是完善ORM，对于查找，我们可以实现以下方法(代码中已完成)：
findAll() - 根据WHERE条件查找；
findNumber() - 根据WHERE条件查找，但返回的是整数，适用于select count(*)类型的SQL。
以及update()和remove()方法。
所有这些方法都必须用@asyncio.coroutine装饰，变成一个协程。
调用时需要特别注意：
user.save()
没有任何效果，因为调用save()仅仅是创建了一个协程，并没有执行它。一定要用：
yield from user.save()
才真正执行了INSERT操作。部分参考。
@staticmethod和@classmethod的作用与区别
一般来说，要使用某个类的方法，需要先实例化一个对象再调用方法。
而使用@staticmethod或@classmethod，就可以不需要实例化，直接类名.方法名()来调用。
这有利于组织代码，把某些应该属于某个类的函数给放到那个类里去，同时有利于命名空间的整洁。
既然@staticmethod和@classmethod都可以直接类名.方法名()来调用，那他们有什么区别呢
从它们的使用上来看,
@staticmethod不需要表示自身对象的self和自身类的cls参数，就跟使用函数一样。
@classmethod也不需要self参数，但第一个参数需要是表示自身类的cls参数。
如果在@staticmethod中要调用到这个类的一些属性方法，只能直接类名.属性名或类名.方法名。
而@classmethod因为持有cls参数，可以来调用类的属性，类的方法，实例化对象等，避免硬编码。
class A(object):
bar = 1
def foo(self):
print 'foo'
@staticmethod
def static_foo():
print 'static_foo'
print A.bar
@classmethod
def class_foo(cls):
print 'class_foo'
print cls.bar
cls().foo()
A.static_foo()
A.class_foo()
结果
static_foo
1
class_foo
1
foo