Flask学习笔记之——蓝图、基于DBUtils实现数据库连接池、上下文管理等
面向对象知识回顾
子类继承父类的三种方式
class Dog(Animal): #子类 派生类
def __init__(self,name,breed, life_value,aggr):
# Animal.__init__(self,name,breed, life_value,aggr)#让子类执行父类的方法 就是父类名.方法名(参数),连self都得传
super().__init__(name,life_value,aggr) #super关键字 ,都不用传self了,在新式类里的
# super(Dog,self).__init__(name,life_value,aggr) #上面super是简写
self.breed = breed
def bite(self,person): #狗的派生方法
person.life_value -= self.aggr
def eat(self): #父类方法的重写
super().eat()
print('dog is eating')
对象通过索引设置值的三种方式
- 方式一:重写__setitem__方法
class Foo(object):
def __setitem__(self, key, value):
print(key,value)
obj = Foo()
obj["xxx"] = 123 #给对象赋值就会去执行__setitem__方法
- 方式二:继承dict
class Foo(dict):
pass
obj = Foo()
obj["xxx"] = 123
print(obj)
- 方式三:继承dict,重写__init__方法的时候,记得要继承父类的__init__方法
class Foo(dict):
def __init__(self,val):
# dict.__init__(self, val)#继承父类方式一
# super().__init__(val) #继承父类方式二
super(Foo,self).__init__(val)#继承父类方式三
obj = Foo({"xxx":123})
print(obj)
Flask设置配置文件的几种方式
==========方式一:============
app.config['SESSION_COOKIE_NAME'] = 'session_lvning' #这种方式要把所有的配置都放在一个文件夹里面,看起来会比较乱,所以选择下面的方式
==========方式二:==============
app.config.from_pyfile('settings.py') #找到配置文件路径,创建一个模块,打开文件,并获取所有的内容,再将配置文件中的所有值,都封装到上一步创建的配置文件模板中
print(app.config.get("CCC"))
=========方式三:对象的方式============
import os
os.environ['FLAKS-SETTINGS'] = 'settings.py'
app.config.from_envvar('FLAKS-SETTINGS')
===============方式四(推荐):字符串的方式,方便操作,不用去改配置,直接改变字符串就行了 ==============
app.config.from_object('settings.DevConfig')
----------settings.DevConfig----------
from app import app
class BaseConfig(object):
NNN = 123 #注意是大写
SESSION_COOKIE_NAME = "session_sss"
class TestConfig(BaseConfig):
DB = "127.0.0.1"
class DevConfig(BaseConfig):
DB = "52.5.7.5"
class ProConfig(BaseConfig):
DB = "55.4.22.4"
要想在视图函数中获取配置文件的值,都是通过app.config来拿。但是如果视图函数和Flask创建的对象app不在一个模块。就得通过模块导入来拿。为了解决这个麻烦的操作,Flask提供了current_app,这个就是当前的app对象,用current_app.config就能查看到了当前app的所有的配置文件。
from flask import Flask,current_app
@app.route('/index',methods=["GET","POST"])
def index():
print(current_app.config) #当前的app的所有配置
session["xx"] = "fdvbn"
return "index"
蓝图
如果代码非常多,要进行归类。不同的功能放在不同的文件,把相关的视图函数也放进去。蓝图也就是对Flask的目录结构进行分配(应用于小,中型的程序)。
小中型
manage.py
import fcrm
if __name__ == '__main__':
fcrm.app.run()
__init__.py (只要一导入fcrm就会执行__init__.py文件)
from flask import Flask
#导入accout 和order
from fcrm.views import accout
from fcrm.views import order
app = Flask(__name__)
print(app.root_path) #根目录
app.register_blueprint(accout.accout) #把蓝图注册到app里面,accout.accout是创建的蓝图对象
app.register_blueprint(order.order)
rom flask import Blueprint,render_template
accout = Blueprint("accout",__name__)
@accout.route('/accout')
def xx():
return "accout"
@accout.route("/login")
def login():
return render_template("login.html")
from flask import Blueprint
order = Blueprint("order",__name__)
@order.route('/order')
def register(): #注意视图函数的名字不能和蓝图对象的名字一样
return "order
使用蓝图时需要注意的:
大型:
数据库连接池
Flask中是没有ORM的,如果在Flask里面连接数据库有两种方式:
一:pymysql
二:SQLAlchemy
是python 操作数据库的一个库。能够进行 orm 映射官方文档 sqlchemy
SQLAlchemy“采用简单的Python语言,为高效和高性能的数据库访问设计,实现了完整的企业级持久模型”。SQLAlchemy的理念是,SQL数据库的量级和性能重要于对象集合;而对象集合的抽象又重要于表和行。
连接池原理
- BDUtils数据库链接池
- 模式一:基于threaing.local实现为每一个线程创建一个连接,关闭是
伪关闭,当前线程可以重复
- 模式二:连接池原理
- 可以设置连接池中最大连接数 9
- 默认启动时,连接池中创建连接 5
- 如果有三个线程来数据库中获取连接:
- 如果三个同时来的,一人给一个链接
- 如果一个一个来,有时间间隔,用一个链接就可以为三个线程提供服务
- 说不准
有可能:1个链接就可以为三个线程提供服务
有可能:2个链接就可以为三个线程提供服务
有可能:3个链接就可以为三个线程提供服务
PS、:maxshared在使用pymysql中均无用。链接数据库的模块:只有threadsafety>1的时候才有用
我们先来思考一个问题,为什么要有连接池这个东西呢?不用连接池有什么不好的地方呢?
先来看看我们使用pymysql时的常规做法:
import pymysql
from flask import Flask
app = Flask(__name__)
@app.route('/index')
def index():
# 连接数据库
conn = pymysql.connect(host="127.0.0.1",port=3306,user='root',password='123', database='pooldb',charset='utf8')
cursor = conn.cursor()
cursor.execute("select * from td where id=%s", [5, ])
result = cursor.fetchall() # 获取数据
cursor.close()
conn.close() # 关闭链接
print(result)
return "执行成功"
if __name__ == '__main__':
app.run(debug=True)
这种方式每次请求,反复创建数据库连接,多次连接数据库会非常耗时
解决办法:放在全局/单例模式
import pymysql
from flask import Flask
from threading import RLock
app = Flask(__name__)
CONN = pymysql.connect(host="127.0.0.1",port=3306,user='root',password='123', database='pooldb',charset='utf8')
@app.route('/index')
def index():
with RLock:
cursor = CONN.cursor()
cursor.execute("select * from td where id=%s", [5, ])
result = cursor.fetchall() # 获取数据
cursor.close()
print(result)
return "执行成功"
if __name__ == '__main__':
app.run(debug=True)
把数据库连接放在全局这种方式,如果是单线程,这样就可以,但是如果是多线程,就得加把锁。这样就成串行的了,
不支持并发。
由于上面两种方案都不完美,所以得把方式一和方式二联合一下(既让减少链接次数,也能支持并发)所有了方式三,需要
导入一个DButils模块
基于DButils实现的数据库连接池有两种模式:
模式一:为每一个线程创建一个链接(是基于本地线程来实现的。thread.local),每个线程独立使用自己的数据库链接,该线程关闭不是真正的关闭,本线程再次调用时,还是使用的最开始创建的链接,直到线程终止,数据库链接才关闭
注: 模式一:如果线程比较多还是会创建很多连接,模式二更常用 。
from flask import Flask
app = Flask(__name__)
from DBUtils.PersistentDB import PersistentDB
import pymysql
POOL = PersistentDB(
creator=pymysql, # 使用链接数据库的模块
maxusage=None, # 一个链接最多被重复使用的次数,None表示无限制
setsession=[], # 开始会话前执行的命令列表。如:["set datestyle to ...", "set time zone ..."]
ping=0,
# ping MySQL服务端,检查是否服务可用。# 如:0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
closeable=False,
# 如果为False时, conn.close() 实际上被忽略,供下次使用,再线程关闭时,才会自动关闭链接。如果为True时, conn.close()则关闭链接,那么再次调用pool.connection时就会报错,因为已经真的关闭了连接(pool.steady_connection()可以获取一个新的链接)
threadlocal=None, # 本线程独享值的对象,用于保存链接对象,如果链接对象被重置
host='127.0.0.1',
port=3306,
user='root',
password='123',
database='pooldb',
charset='utf8'
)
@app.route('/func')
def func():
conn = POOL.connection()
cursor = conn.cursor()
cursor.execute('select * from tb1')
result = cursor.fetchall()
cursor.close()
conn.close() # 不是真的关闭,而是假的关闭。 conn = pymysql.connect() conn.close()
conn = POOL.connection()
cursor = conn.cursor()
cursor.execute('select * from tb1')
result = cursor.fetchall()
cursor.close()
conn.close()
if __name__ == '__main__':
app.run(debug=True)
模式二:创建一个链接池,为所有线程提供连接,使用时来进行获取,使用完毕后在放回到连接池。
PS:假设最大链接数有10个,其实也就是一个列表,当你pop一个,人家会在append一个,链接池的所有的链接都是按照排队的这样的方式来链接的。链接池里所有的链接都能重复使用,共享的, 即实现了并发,又防止了链接次数太多。
import time
import pymysql
import threading
from DBUtils.PooledDB import PooledDB, SharedDBConnection
POOL = PooledDB(
creator=pymysql, # 使用链接数据库的模块
maxconnections=6, # 连接池允许的最大连接数,0和None表示不限制连接数
mincached=2, # 初始化时,链接池中至少创建的空闲的链接,0表示不创建
maxcached=5, # 链接池中最多闲置的链接,0和None不限制
maxshared=3, # 链接池中最多共享的链接数量,0和None表示全部共享。PS: 无用,因为pymysql和MySQLdb等模块的 threadsafety都为1,所有值无论设置为多少,_maxcached永远为0,所以永远是所有链接都共享。
blocking=True, # 连接池中如果没有可用连接后,是否阻塞等待。True,等待;False,不等待然后报错
maxusage=None, # 一个链接最多被重复使用的次数,None表示无限制
setsession=[], # 开始会话前执行的命令列表。如:["set datestyle to ...", "set time zone ..."]
ping=0,
# ping MySQL服务端,检查是否服务可用。# 如:0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
host='127.0.0.1',
port=3306,
user='root',
password='123',
database='pooldb',
charset='utf8'
)
def func():
# 检测当前正在运行连接数的是否小于最大链接数,如果不小于则:等待或报raise TooManyConnections异常
# 否则
# 则优先去初始化时创建的链接中获取链接 SteadyDBConnection。
# 然后将SteadyDBConnection对象封装到PooledDedicatedDBConnection中并返回。
# 如果最开始创建的链接没有链接,则去创建一个SteadyDBConnection对象,再封装到PooledDedicatedDBConnection中并返回。
# 一旦关闭链接后,连接就返回到连接池让后续线程继续使用。
# PooledDedicatedDBConnection
conn = POOL.connection()
# print(th, '链接被拿走了', conn1._con)
# print(th, '池子里目前有', pool._idle_cache, '\r\n')
cursor = conn.cursor()
cursor.execute('select * from tb1')
result = cursor.fetchall()
conn.close()
conn = POOL.connection()
# print(th, '链接被拿走了', conn1._con)
# print(th, '池子里目前有', pool._idle_cache, '\r\n')
cursor = conn.cursor()
cursor.execute('select * from tb1')
result = cursor.fetchall()
conn.close()
func()
threading.local
threading.local:保证每个线程都只有自己的一份数据,在操作时不会影响别人的,即使是多线程,自己的值也是互相隔离的。
import threading
import time
# 本地线程对象
local_values = threading.local()
def func(num):
"""
# 第一个线程进来,本地线程对象会为他创建一个
# 第二个线程进来,本地线程对象会为他创建一个
{
线程1的唯一标识:{name:1},
线程2的唯一标识:{name:2},
}
:param num:
:return:
"""
local_values.name = num # 4
# 线程停下来了
time.sleep(2)
# 第二个线程: local_values.name,去local_values中根据自己的唯一标识作为key,获取value中name对应的值
print(local_values.name, threading.current_thread().name)
for i in range(5):
th = threading.Thread(target=func, args=(i,), name='线程%s' % i)
th.start()
打印结果:
1 线程1
2 线程2
0 线程0
4 线程4
3 线程3