flask_day05：信号 Django信号 flask-script sqlalchemy 创建操作数据表
目录
鲁棒性
链路，链路追踪，
上下游，大的单体应用，上游还是前端，后端是Django写的
回顾
1.导出项目依赖 pipreqs
2.函数和方法
3.local对象
并发编程中的一个对象，它可以保证多线程并发访问数据安全
本质原理是：不同的线程，操作的是自己的数据
不支持协程
4.自己定义local，支持线程和协程
注意点一：
try:
# 只要解释没有装greenlet，这句话就会报错
# 一旦装了，有两种情况，使用了协程和没用协程，无论使用不使用，用getcurrent都能拿到协程id号
from greenlet import getcurrent as get_ident
except Exception as e:
from threading import get_ident
# 注意点二：重写类的 __setattr__ 和 __getatte__
对象点属性 取值 不存在会触发 __getattr__
对象点属性 设置值 不存在时会触发 __setattr__
# 注意点三：由于重写了__setattr__个__getattr__
类内部使用 self.storage 会递归
使用类调用对象的方法，他就是普通函数，有几个值传几个值
object.__setattr__(self,'storage',{})
等同于：self.storage={}
等价于：setattr(self,'stotrage',{}) 会递归
5.flask是如何实现这个local类的
def __setattr__(self, name, value):
ident = self.__ident_func__()
storage = self.__storage__
try:
storage[ident][name] = value
except KeyError:
storage[ident] = {name:value}
def __getattr__(self, name):
try:
return self.__storage__[self.__ident_func__()][name]
except KeyError:
raise AttributeError(name)
def __getattr__(self, k):
ident = get_ident()
return self.storage[ident][k]
def __setattr__(self, k, v):
ident = get_ident() #如果用协程，这就是协程号，如果是线程，这就是线程号
if ident in self.storage: #{'协程id号':{arg:1},'协程id号':{arg:2},'协程id号':{arg:3}}
self.storage[ident][k] = v
else:
self.storage[ident] = {k: v}
6.偏函数 ：提前传值，返回一个对象，后期可以调用这个对象，传入后续的值
7.请求上下文源码分析(ctx 对象)，整个flask的执行流程
-一旦请求来了----》会执行 Flask类的对象app()---》触发Flask __call__--->self.wsgi_app(environ, start_response)
-Flask类wsgi_app 方法 大约 2417行
def wsgi_app(self, environ, start_response):
#1 返回了一个ctx，请求上下文对象，RequestContext 的对象，里面有session，request
ctx = self.request_context(environ)
try:
try:
# 2 ctx.push---->RequestContext的push---》382行
# _request_ctx_stack.push(self)--self是ctx---》是全局变量
# 是LocalStack()的对象
ctx.push()
# 匹配路由执行视图函数，请求扩展
response = self.full_dispatch_request()
except Exception as e:
error = e
response = self.handle_exception(e)
except: # noqa: B001
error = sys.exc_info()[1]
raise
# 把结果返回给wsgi服务器
return response(environ, start_response)
finally:
if self.should_ignore_error(error):
error = None
# 把当前放进去的ctx剔除，当次请求结束了
ctx.auto_pop(error)
-是LocalStack()的对象 的push ，传入了ctx
def push(self, obj):
# self._local是 Flask自己定义的兼容线程和协程的Local
#self._local中反射 stack，会根据不同线程或协程，返回不同线程的stack
#rv是None的
rv = getattr(self._local, "stack", None)
if rv is None:
# rv=[]
# self._local.stack=rv
#self._local={'协程id号1':{stack:[]},'协程id号2':{stack:[]}}
self._local.stack = rv = []
rv.append(obj)
#self._local={'协程id号1':{stack:[ctx,]},'协程id号2':{stack:[]}}
return rv
- 在视图函数中:request = LocalProxy(partial(_lookup_req_object, "request"))
-print(request.method) # 执行requets对象的 __getattr__
-LocalProxy的__getattr__-->核心：
-return getattr(self._get_current_object(), name)
-self._get_current_object() 是 ctx中的真正request对象，那method，自如就拿到当次请求的method
-def _get_current_object(self):
if not hasattr(self.__local, "__release_local__"):
#object.__setattr__(self, "_LocalProxy__local", local)，初始化传入的
# local 是 partial(_lookup_req_object, "request")
#
# getattr(_lookup_req_object('request'), 'method')
# getattr(当次请求的reuqest, 'method')
return self.__local() # self中的 __local,隐藏属性
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError("no object bound to %s" % self.__name__)
-def _lookup_req_object(name):
# 这里把当前线程下 的ctx取出来了
top = _request_ctx_stack.top
if top is None:
raise RuntimeError(_request_ctx_err_msg)
return getattr(top, name) # 去ctx中反射request，返回的就是当次请求的requets
# django flask 同步框架，部署的时候，使用uwsgi部署，uwsgi是进程线程架构，并发量不高
# 可以通过uwsgi+gevent，部署成异步程序
信号
Flask框架中的信号基于blinker(安装这个模块)，其主要就是让开发者可以在flask请求过程中定制一些用户行为，flask 和 Django都有
观察者模式，又叫发布 -订阅(Publish/Subscribe) 23种设计模式之一
安装：pip install blinker
信号：signal 翻译过来的，并发编程中学过，信号量Semaphore，是两个不同的概念
比如：用户表新增一条记录时，就记录一下日志
方案一：在每个增加后，都写一行代码 --->>> 后期要删除，比较麻烦
方案二：使用信号量，写一个函数，绑定内置信号，只要程序执行到这，就会执行这个函数
内置信号：flask少一些，Django多一些
request_started = _signals.signal('request-started') # 请求到来前执行
request_finished = _signals.signal('request-finished') # 请求结束后执行
before_render_template = _signals.signal('before-render-template') # 模板渲染前执行
template_rendered = _signals.signal('template-rendered') # 模板渲染后执行
got_request_exception = _signals.signal('got-request-exception') # 请求执行出现异常时执行
request_tearing_down = _signals.signal('request-tearing-down') # 请求执行完毕后自动执行（无论成功与否）
appcontext_tearing_down = _signals.signal('appcontext-tearing-down')# 应用上下文执行完毕后自动执行（无论成功与否）
appcontext_pushed = _signals.signal('appcontext-pushed') # 应用上下文push时执行
appcontext_popped = _signals.signal('appcontext-popped') # 应用上下文pop时执行
message_flashed = _signals.signal('message-flashed') # 调用flask在其中添加数据时，自动触发
使用内置信号量的步骤
1.写一个函数
2.绑定内置信号
3.等待被触发
自定义信号
1.定义出信号
session_set = _signals.signal('session_set')
2.写一个函数
def test1(*args, **kwargs):
print(args)
print(kwargs)
print('session设置值了')
3.绑定自定义的信号
session_set.connect(test1)
4.触发信号的执行(咱们做)
session_set.send('lqz') # 触发信号的执行
代码演示：
from flask import Flask, render_template, signals,session
from flask.signals import _signals
app = Flask(__name__)
app.secret_key='asdfasdfdas'
###自定义信号
# 1 定义出信号
session_set = _signals.signal('session_set')
# 2 写一个函数
def test1(*args, **kwargs):
print(args)
print(kwargs)
print('session设置值了')
# 3 绑定自定义的信号
session_set.connect(test1)
# 4 触发信号的执行(咱们做)
# session_set.send('lqz') # 触发信号执行
@app.route('/')
def hello_world():
session['lqz']='lqz'
session_set.send('lqz') # 触发信号执行
return 'Hello World!'
@app.route('/index')
def index():
return render_template('index.html', name='lqz')
if __name__ == '__main__':
app.run()
这里我们定义了一个信号，通过信号名称点send()的方式来触发信号的执行
如果我们像上面一样传了参数，就可以在函数的args中被接收到
在源码中内置信号是在哪触发的呢？
在Flask的full_dispatch_request方法中，我们可以找到send的执行，部分源码如下：
try:
request_started.send(self)
'这里就是触发信号'
rv = self.preprocess_request()
'这里就是执行请求扩展中的方法'
if rv is None:
rv = self.dispatch_request()
except Exception as e:
rv = self.handle_user_exception(e)
return self.finalize_request(rv)
preprocess_request源码如下：
def preprocess_request(self) -> t.Optional[ft.ResponseReturnValue]:
names = (None, *reversed(request.blueprints))
for name in names:
if name in self.url_value_preprocessors:
for url_func in self.url_value_preprocessors[name]:
url_func(request.endpoint, request.view_args)
for name in names:
if name in self.before_request_funcs:
for before_func in self.before_request_funcs[name]:
rv = self.ensure_sync(before_func)()
if rv is not None:
return rv
return None
在这里我们看到了before_request_funcs，从if里面的判断内容，我们可以猜到，他就是判断用来请求扩展的视图名称是否在里面
接着我们看请求扩展装饰器的源码，我们发现他就是把方法名称添加到before_request_funcs中去
@setupmethod
def before_request(self, f: T_before_request) -> T_before_request:
self.before_request_funcs.setdefault(None, []).append(f)
return f
总结：得出的结论，用了请求扩展装饰器的视图方法的名称，会被添加到defore_request_funcs中去，然后再触发的时候，去before_request_funcs查找名称是否在里面，在的话就执行对应的代码
Django信号
https://www.cnblogs.com/liuqingzheng/articles/9803403.html
Model signals
pre_init # django的modal执行其构造方法前，自动触发
post_init # django的modal执行其构造方法后，自动触发
pre_save # django的modal对象保存前，自动触发
post_save # django的modal对象保存后，自动触发
pre_delete # django的modal对象删除前，自动触发
post_delete # django的modal对象删除后，自动触发
m2m_changed # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
class_prepared # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
Management signals
pre_migrate # 执行migrate命令前，自动触发
post_migrate # 执行migrate命令后，自动触发
Request/response signals
request_started # 请求到来前，自动触发
request_finished # 请求结束后，自动触发
got_request_exception # 请求异常后，自动触发
Database Wrappers
connection_created # 创建数据库连接时，自动触发
django中使用内置信号
1.写一个函数
def callBack(*args, **kwargs):
print(args)
print(kwargs)
2.绑定信号
方式一：
post_save.connect(callBack)
方式二：
from django.db.models.signals import pre_save
from django.dispatch import receiver
@receiver(pre_save)
def my_callback(senderm,**kwargs):
print('对象创建成功')
print(sender)
print(kwargs)
3.等待触发
代码：
# django中使用内置信号
1 写一个函数
def callBack(*args, **kwargs):
print(args)
print(kwargs)
2 绑定信号
#方式一
post_save.connect(callBack)
# 方式二
from django.db.models.signals import pre_save
from django.dispatch import receiver
@receiver(pre_save)
def my_callback(sender, **kwargs):
print("对象创建成功")
print(sender)
print(kwargs)
3 等待触发
flask-script
django中有命令：python manage.py runserver。。。
那flask启动项目要想像Django一样，通过命令启动，需要借助于flask-script
安装：
需要注意，不同版本的flask和flask-script不一定兼容
Flask==2.2.2
Flask_Script==2.0.3
借助于：flask-script 实现
安装：pip install flask-script
使用步骤：
from flask import Flask
'步骤一导入模块中的Manager'
from flask_script import Manager
app = Flask(__name__)
'然后把app对象传入Manager'
manager=Manager(app)
app.secret_key='asdfasdfdas'
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
# app.run()
'最后修改项目的启动方式'
manager.run()
修改完代码后，我们会发现右键运行代码，已经不能让项目跑起来了，我们需要在执行文件所在目录，运行命令启动项目
命令启动
python manage.py runserver
这里的manage.py看，可以换成别的文件名称 ，同时启动时也是可以执行ip和端口号的，像python一样添加即可
自定制命令
from flask import Flask
'步骤一导入模块中的Manager'
from flask_script import Manager
app = Flask(__name__)
'然后把app对象传入Manager'
manager=Manager(app)
app.secret_key='asdfasdfdas'
#1 简单自定制命令
@manager.command
def custom(arg):
# 命令的代码，比如：初始化数据库， 有个excel表格，使用命令导入到mysql中
print(arg)
#2 复杂一些的自定制命令
@manager.option('-n', '--name', dest='name')
@manager.option('-u', '--url', dest='url')
def cmd(name, url):
# python run.py cmd -n lqz -u xxx
# python run.py cmd --name lqz --url uuu
print(name, url)
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
# app.run()
'最后修改项目的启动方式'
manager.run()
简单自定制命令
python run.py custom wyf
这里的wyf就是传进去的参数
复杂一些的自定制命令
python run.py cmd -n lqz -u xxx
python run.py cmd --name lqz --url uuu
django 中如何自定制命令？
sqlalchemy
更多：https://www.cnblogs.com/liuqingzheng/p/16005909.html
flask中没有ORM框架，对象关系映射，为方便我们快速操作数据库，flask、fastapi中用sqlalchemy居多
SQLalchemy是一个基于python实现的ORM框架，给框架建立在DB API之上，使用关系对象映射进行数据库操作，简单来说就是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果
安装SQLalchemy：pip install sqlalchemy
SQLalchemy本身是无法操作数据库的，必须使用pymysql等第三方插件，Dialact用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作
如:
MySQL-Python
mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
pymysql
mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
MySQL-Connector
mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
cx_Oracle
oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
更多：http://docs.sqlalchemy.org/en/latest/dialects/index.html
sqlalchemy快速使用
原生操作的快速使用
# 先不是orm，而是原生sql
# 第一步：导入
from sqlalchemy import create_engine
# 第二步：生成引擎对象
engine = create_engine(
"mysql+pymysql://root@127.0.0.1:3306/cnblogs",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 第三步：使用引擎获取连接，操作数据库
conn = engine.raw_connection()
cursor=conn.cursor()
cursor.execute('select * from aritcle')
print(cursor.fetchall())
创建操作数据表
# 第一步：导入
from sqlalchemy import create_engine
import datetime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
# 第二步：执行declarative_base，得到一个类
Base = declarative_base()
# 第三步：继承生成的Base类
class User(Base):
# 第四步：写字段
id = Column(Integer, primary_key=True) # 生成一列，类型是Integer，主键
name = Column(String(32), index=True, nullable=False) # name列varchar32，索引，不可为空
email = Column(String(32), unique=True)
# datetime.datetime.now不能加括号，加了括号，以后永远是当前时间
ctime = Column(DateTime, default=datetime.datetime.now)
# extra = Column(Text, nullable=True)
# 第五步：写表名 如果不写以类名为表名
__tablename__ = 'users' # 数据库表名称
# 第六步：建立联合索引，联合唯一
__table_args__ = (
UniqueConstraint('id', 'name', name='uix_id_name'), # 联合唯一
Index('ix_id_name', 'name', 'email'), # 索引
)
class Book(Base):
__tablename__ = 'books'
id = Column(Integer, primary_key=True)
name = Column(String(32))
# 第七步：把表同步到数据库中
# 不会创建库，只会创建表
engine = create_engine(
"mysql+pymysql://root@127.0.0.1:3306/aaa",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 把表同步到数据库 （把被Base管理的所有表，都创建到数据库）
Base.metadata.create_all(engine)
# 把所有表删除
# Base.metadata.drop_all(engine)
原生sqlalchemy是不支持修改的，但是可以借助第三方
现在当要修改表中字段时，要对执行表删除，再执行把表同步到数据库去
