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 方法  大约 2417def 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.等待被触发

image-20230407231555920

自定义信号

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()

image-20230407232520576

这里我们定义了一个信号,通过信号名称点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一样添加即可
image

自定制命令

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()

image

简单自定制命令

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())

image

创建操作数据表

# 第一步:导入
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)

image

原生sqlalchemy是不支持修改的,但是可以借助第三方
现在当要修改表中字段时,要对执行表删除,再执行把表同步到数据库去

posted @   小福福  阅读(38)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· PowerShell开发游戏 · 打蜜蜂
· 在鹅厂做java开发是什么体验
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
  1. 1 原来你也在这儿 温余福
  2. 2 世间美好和你环环扣扣 温余福
  3. 3 随风起舞 温余福
  4. 4 罪恶都市 温余福
罪恶都市 - 温余福
00:00 / 00:00
An audio error has occurred, player will skip forward in 2 seconds.

作词 : 王星

作曲 : 灰鸿啊/皮皮

编曲 : 夏日入侵企画

制作人 : 邢硕

节奏吉他 : 肯尼

主音吉他 : 张伟楠

贝斯 : 皮皮

鼓 : 海鑫

和声 : 邢硕

音效制作 : 邢硕

录音 : 邢硕/夏国兴

混音 : 于昊

特别鸣谢 : 张伟楠

这城市的车流和这地表的颤抖

像一颗石子落入地心之后泛起的温柔

暗涌

河水流过转角她的楼

被梦魇

轻声呓语唤醒身后的幼兽

失效感官焦灼只剩下

麻木愚钝无从感受

共同支撑全都瓦解

只是我们现在都

已忘记到底是

谁隐藏春秋

谁在大雨之后

把旗帜插在最高的楼

过去陈旧的还在坚守

内心已腐朽

摇摇欲坠不停退后

毁灭即拯救

夏日掠夺春秋

结局无法看透

眼看这情节开始变旧

所有的城池已失守

最终无法占有

无眠辗转

伴着人间破碎的旧梦

像繁星

退却后只剩下混沌的夜空

炙热

掩盖风声鹤唳的担忧

把所有失落无助反手推入

无尽的白昼

失效感官焦灼只剩下

麻木愚钝无从感受

共同支撑全都瓦解

只是我们现在都已经忘记到底是

谁隐藏春秋

谁在大雨之后

把旗帜插在最高的楼

过去的陈旧还在坚守

内心已腐朽

摇摇欲坠不停退后

毁灭即拯救

夏日掠夺春秋

结局无法看透

眼看这情节开始变旧

所有的城池早已失守

惶恐难以接受

缠绵往复不肯放手

最终无法占有

谁隐藏春秋

谁在大雨之后

把旗帜插在最高的楼

过去的陈旧还在坚守

内心已腐朽

摇摇欲坠不停退后

毁 灭 即 拯 救

谁掠夺春秋

谁在大雨之后

把旗帜插在最高的楼

过去的陈旧还在坚守

内心已腐朽

摇摇欲坠不停退后

毁灭即拯救

夏日掠夺春秋

结局无法看透

明知城池已失守

缠绵往复不肯放手

最终无法占有

点击右上角即可分享
微信分享提示