flask请求上下文分析，源码request原理，wtforms，精确导出依赖，函数和方法，threading.locl对象，偏函数，flask整个生命周期执行流程1.1.4版本

内容回顾

蓝图

第一步：导入

第二步：实例化得到对象，可以指定static和templates

第三步：app中注册蓝图，注册蓝图时，可以指定前缀

第四步：使用蓝图，注册路由，注册请求扩展

g对象

当次请求的全局对象，在当次请求中可以放值和取值

跟session的区别是session可以在多次请求中使用，g对象只在当次请求中使用

flask中使用mysql数据库

pymysql，在一个视图函数中，创建一个连接对象，操作，操作完就关闭连接

连接对象不要单例，可能回出现数据库错乱问题

数据库连接池

dbutils

使用步骤：安装

第一步：导入实例化得到一个对象，pool

第二步：pool做成单例，以模块导入

第三步：从pool中拿到一个连接pool.connection()

第四步：使用连接获得游标，使用游标操作数据库

压测接口，验证是否使用连接池

django中没有数据库连接池，可以使用第三方

内容详情

导出项目依赖

之前pip freeze > requirements.txt 把当前解释器环境下的所有第三方依赖都导出来

使用第三发模块，更精准的导出依赖 pipreqs

第一步安装

 pip install pipreqs

第二步：使用命令导出项目依赖

 pipreqs ./

win可能会出现报错指定编码即可

 pipreqs ./ --encoding=utf8

mac，linux没问题

第三步：就会在项目根路径下生成：requirements.txt

只要是导入的第三方模块无论是否使用，都会生成到文件内

函数和方法

只要会自动传值，就是方法，函数有几个参数就传几个值，否则报错

函数就是普通函数，有几个参数就要传几个参数

方法：绑定给对象的方法，绑定给类的方法，绑定给谁，由谁来调用，会自动把自身传入

类的绑定方法，对象可以来调用，会把产生这个对象的类传入

对象的绑定方法，类可以来调用，但是他就变成了普通函数，有几个值，就要传几个值，没有自动传值

MethodType检查一个对象，是不是方法

FunctionType检查一个对象，是不是函数

isinstance 判断一个对象，是不是一个类的对象

issubclass 判断一个类，是不是另一个类的子类

 # 只要会自动传值，就是方法，函数，有几个值就要传几个值，否则报错
 
 
# 函数就是普通的函数，有几个参数就要传几个参数
# 方法：绑定给对象的方法，绑定给类的方法，绑定给谁的，由谁来调用，会自动把自身传入
# 类的绑定方法，对象可以来调用，会自动把类传入
# 对象的绑定方法，类可以来调用？ 类可以调用，但是它就变成了普通函数，有几个值，就要传几个值，没有自动传值了
 
 
# MethodType检查一个对象，是不是方法
# FunctionType检查一个对象，是不是函数
# isinstance 判断一个对象，是不是一个类的对象
# issubclass 判断一个类，是不是另一个类的子类
 
from types import MethodType, FunctionType
 
 
class Foo(object):
    def fetch(self):
        pass
 
    @classmethod
    def test(cls):
        pass
 
    @staticmethod
    def test1():
        pass
 
 
# a=Foo()
# print(isinstance(a,Foo))
# print(isinstance('a',Foo))
#
# class Foo2(Foo):
#     pass
# class Foo3():
#     pass
# print(issubclass(Foo2,Foo))
# print(issubclass(Foo3,Foo))
 
 
def add():
    pass
 
 
# 类来调用对象的绑定方法，
print(isinstance(Foo.fetch, MethodType))  # False  类来调用对象的绑定方法，该方法就变成了普通函数
obj = Foo()
print(isinstance(obj.fetch, MethodType))  # True    对象来调用自己的绑定方法，fetch就是方法
print(isinstance(Foo.fetch, FunctionType))  # True   类来调用对象的绑定方法，该方法就变成了普通函数
 
print(isinstance(add, FunctionType))  # True  就是个普通函数
print(isinstance(add, MethodType))  # False  就是个普通函数
 
 
print(isinstance(Foo.test, MethodType))  # True test 是绑定给类的方法，类来调用，就是方法
 
print(isinstance(obj.test, MethodType))  # True  对象调用类的绑定方法，还是方法
 
print(isinstance(Foo.test1, MethodType))  # False 是普通函数
print(isinstance(obj.test1, MethodType))  # False 是普通函数
print(isinstance(obj.test1, FunctionType))  # True，静态方法，就是普通函数，对象和类都可以调用，有几个值就传几个值

threading.local对象

local对象

并发编程时，多个线程操作同一个变量，会出现并发安全的问题我们需要加锁

使用local对象，多线程并发操作时，不需要加锁，不会出现数据错乱threading.local

其他语言也有这个东西ThreadLoacl,java面试中会被经常问到，python没人问

本质原理

多线程修改同一个数据，复制多分变量给每个线程用，为每个线程开辟一块空间进行数据存储

每个线程操作自己的那部分数据

 # 自己封装local，实现兼容线程和协程
 
# 尝试导入greenlet试一下，如果导入不进来，说明根本没有用greenlet，就没有用协程，用了协程就不报错
try:
    from greenlet import getcurrent as get_ident
except Exception as e:
    from threading import get_ident
 
from threading import Thread
import time
 
 
class Local(object):
    def __init__(self):
        object.__setattr__(self, 'storage', {})  # 这个不会触发setattr
        # self.storage={}  # 它会触发 __setattr__,就会递归
 
    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}
 
    def __getattr__(self, k):
        ident = get_ident()
        return self.storage[ident][k]
 
 
lqz = Local()
def task(arg):
    lqz.arg = arg
    print(lqz.arg)
 
 
for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

偏函数

可以提前传值

 from functools import partial
def add(a,b,c):
    return a+b+c
 
 
# print(add(2,3,4))  # 传少了报错
 
# 现在只有一个参数，后面的俩参数，需要过一会才知道
# 借助于偏函数，先提前给他把第一个参数传入，后面知道了后面俩参数，再传后面俩
 
add=partial(add,2)
#
# # 干了很多事
#
print(add(3,4))

flask整个生命执行流程(1.1.4版本)

切入点app.run()进去》最后有一个run_simple是werkzeug的简单服务，self是我们的app对象

 run_simple(host, port, self, **options)

路由来了会执行app对象加括号，也就是执行Flask类的双下call

然后取下双下call干嘛了，看到了执行了这个方法

 # 这个environ是请求对象，start_response开始响应对象不需要关系
def __call__(self, environ, start_response):
    return self.wsgi_app(environ, start_response)

 def wsgi_app(self, environ, start_response):
    # environ 封装的请求对象，返回了RequestContext对象
            ctx = self.request_context(environ)
        error = None
        try:
            try:
                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
            return response(environ, start_response)
        finally:
            if self.should_ignore_error(error):
                error = None
            ctx.auto_pop(error)

去找这个方法

进去这个方法

 def request_context(self, environ):
    # self是app对象
    return RequestContext(self, environ)

     def __init__(self, app, environ, request=None, session=None):
        self.app = app
        # request为空
        if request is None:
            # 走到这里去找app也就是前面传来来的app对象request_class
            # from .wrappers import Request 看到是从这个里导入的 看到的是flask自己封装的Request
            request = app.request_class(environ)
        self.request = request
        self.url_adapter = None
        try:
            self.url_adapter = app.create_url_adapter(self.request)
        except HTTPException as e:
            self.request.routing_exception = e
        self.flashes = None
        self.session = session

总结就RequestContext对象

然后继续向下走走了wsgi_app函数里面的ctx.push()就是RequestContext对象里的push

 ctx.push()

进去push里面

     def push(self):
        
        
        # self 传的是ctx对象
        # _request_ctx_stack = LocalStack()是globals里面的
        _request_ctx_stack.push(self)
        
        # 拿出session
        if self.session is None:
            session_interface = self.app.session_interface
            # 看到了熟悉的open_session
            self.session = session_interface.open_session(self.app, self.request)
 
            if self.session is None:
                self.session = session_interface.make_null_session(self.app)
        if self.url_adapter is not None:
            self.match_request()

进去看，然后去看调用的push方法

 class LocalStack(object):
    # 初始化把Local()产生的对象放到到了这里面，去看这个Local类的初始化，就在上面
    def __init__(self):
        self._local = Local()

 class Local(object):
    __slots__ = ("__storage__", "__ident_func__")
 
    def __init__(self):
        # 初始化设置__storage__空字典
        object.__setattr__(self, "__storage__", {})
        # 这个是获取id的方法内存地址也放到对象里面
        object.__setattr__(self, "__ident_func__", get_ident)

然后回过头来去看LocalStack类里面的push方法

     def push(self, obj):
        """Pushes a new item to the stack"""
        # obj 是ctx也就是当次请求request对象
        # 这里刚开是的线程id对应的肯定没有，所有就是往LocalStack对象的_local也就是Local对象存request对象
        rv = getattr(self._local, "stack", None)
        if rv is None:
            self._local.stack = rv = []
        rv.append(obj)
        return rv

去看Local类中双下setattr

     def __setattr__(self, name, value):
        # 获取线程(协程)id
        ident = self.__ident_func__()
        # 拿到这个全局对象字典
        storage = self.__storage__
        try:
            # 尝试往这个字典这个线程id对应的key对象name也就是stack，value是列表进行赋值，如果存在那么会直接覆盖
            storage[ident][name] = value
        except KeyError:
            # 不存在则像这个id赋值，一个stack key对应的是空列表
            storage[ident] = {name: value}

     def push(self, obj):
        """Pushes a new item to the stack"""
        # obj 是ctx也就是当次请求request对象
        # 这里刚开是的线程id对应的肯定没有，所有就是往LocalStack对象的_local也就是Local对象存request对象
        rv = getattr(self._local, "stack", None)
        if rv is None:
            self._local.stack = rv = []
        # 这里是把RequestContext对象放到了列表里面，返回了这个列表现在的数据就是
        """
        __storage__={'线程id':{'stack':[RequestContext对象]}}
        """
        rv.append(obj)
        return rv

紧接着回到wsgi_app函数中看这个(到这里往下就是路由匹配执行视图函数那一套了，暂时可以先不看)

 # 这个里是执行视图函数，视图扩展
response = self.full_dispatch_request()

 def full_dispatch_request(self):
    # 执行请求扩展中的before_first_request
    self.try_trigger_before_first_request_functions()
    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)
  # 这里面把session加密后一并返回给了前端里面的
"""
	这个函数调用save_session()进行了加密保存以及返回了有兴趣自己可以进去看看
            response = self.process_response(response)
"""
   return self.finalize_request(rv)

dispatch_request

     def dispatch_request(self):
        # 拿到request对象
        req = _request_ctx_stack.top.request
        # routing_exception默认是None,所有不走
        if req.routing_exception is not None:
            self.raise_routing_exception(req)
        # werkzug的封装了一层这个就是路由例如/index或则/home/index
        rule = req.url_rule
        # if we provide automatic options for this URL and the
        # request came with the OPTIONS method, reply automatically
        # 这里是处理复杂请求头
        if (
                getattr(rule, "provide_automatic_options", False)
                and req.method == "OPTIONS"
        ):
            return self.make_default_options_response()
        # otherwise dispatch to the handler for that endpoint
        # 这里是真正执行路由匹配的用endpoint来进行匹配
        return self.view_functions[rule.endpoint](**req.view_args)

到这里一个请求就结束了

现在我们去看看在请求中使用request的情况

request = LocalProxy(partial(_lookup_req_object, "request"))

去看看初始化都有什么

 class LocalProxy(object):
	# 这个是注册
    __slots__ = ("__local", "__dict__", "__name__", "__wrapped__")
 
    # 这个name是None
    def __init__(self, local, name=None):
        # 这里_LocalProxy__local是给这个类对象添加私有属性，属性名叫__local
        object.__setattr__(self, "_LocalProxy__local", local)
        object.__setattr__(self, "__name__", name)

 # LocalProxy 代理类---》method---》代理类去当前线程的stack取出ctx，取出当时放进去的request
	视图函数中：print(request.method)

print(request) 执行LocalProxy类的__str__方法

request.method 执行LocalProxy类的_getattr_

然后去看__getattr__方法

     def __getattr__(self, name):
        if name == "__members__":
            return dir(self._get_current_object())
        # 从request对象里面拿出对象的method，以及其他属性
        return getattr(self._get_current_object(), name)

 def _get_current_object(self):
        # 这里取__local对象没有__release_local__
        if not hasattr(self.__local, "__release_local__"):
            # 然后就是是partial(_lookup_req_object, "request")执行了这个拿到了request对象
            return self.__local()
        try:
            return getattr(self.__local, self.__name__)
        except AttributeError:
            raise RuntimeError("no object bound to %s" % self.__name__)

执行self.__local()也就是>partial(_lookup_req_object, "request")也就是

 def _lookup_req_object(name):
    top = _request_ctx_stack.top  # 这个是伪装属性
    if top is None:
        raise RuntimeError(_request_ctx_err_msg)
    # 最终这里拿到了Local对象里面的存放的ctx对象
    return getattr(top, name)

     @property
    def top(self):
        try:
            # 这里是拿出线程id对象的存在Local对象stack里面的对象列表里最后的一个
            return self._local.stack[-1]
        except (AttributeError, IndexError):
            return None

Local类对象中getattr

     def __getattr__(self, name):
        try:
            # 获取线程(协程)对应的RequestContext对应【name=stack】
            return self.__storage__[self.__ident_func__()][name]
        except KeyError:
            raise AttributeError(name)

请求上下文执行流程(lqz分析)

 # 请求来了---》app()----->Flask.__call__--->self.wsgi_app(environ, start_response)
    def wsgi_app(self, environ, start_response):
        # environ:http请求拆成了字典
        # ctx对象：RequestContext类的对象，对象里有：当次的requets对象，app对象，session对象
        ctx = self.request_context(environ)
        error = None
        try:
            try:
                #ctx RequestContext类 push方法
                ctx.push()
                # 匹配成路由后，执行视图函数
                response = self.full_dispatch_request()
            except Exception as e:
                error = e
                response = self.handle_exception(e)
            except:
                error = sys.exc_info()[1]
                raise
            return response(environ, start_response)
        finally:
            if self.should_ignore_error(error):
                error = None
            ctx.auto_pop(error)
            
            
            
            
            
  # RequestContext :ctx.push
 def push(self):
		# _request_ctx_stack = LocalStack() ---》push(ctx对象)--》ctx:request，session，app
        _request_ctx_stack.push(self)
		#session相关的
        if self.session is None:
            session_interface = self.app.session_interface
            self.session = session_interface.open_session(self.app, self.request)
 
            if self.session is None:
                self.session = session_interface.make_null_session(self.app)
		# 路由匹配相关的
        if self.url_adapter is not None:
            self.match_request()
            
            
            
# LocalStack()  push --->obj 是ctx对象
    def push(self, obj):
        #self._local  _local 就是咱们刚刚自己写的Local的对象---》LocalStack的init初始化的_local---》self._local = Local()---》Local对象可以根据线程协程区分数据 
        rv = getattr(self._local, "stack", None)
        # 一开始没有值
        if rv is None:
            rv = []
            self._local.stack = rv  # self._local.stack 根据不同线程用的是自己的数据
        rv.append(obj)  # self._local.stack.append(obj)
        # {'线程id号'：{stack：[ctx]},'线程id号2'：{stack：[ctx]}}
        return rv
    
    
    
 # 再往后执行，就会进入到路由匹配，执行视图函数
	# request = LocalProxy(partial(_lookup_req_object, "request"))
    # LocalProxy 代理类---》method---》代理类去当前线程的stack取出ctx，取出当时放进去的request
	视图函数中：print(request.method)
    
    
# print(request) 执行LocalProxy类的__str__方法
# request.method 执行LocalProxy类的__getattr__
    def __getattr__(self, name): #name 是method
        # self._get_current_object() 就是当次请求的request
        return getattr(self._get_current_object(), name)
    
    
 # LocalProxy类的方法_get_current_object
   def _get_current_object(self):
        if not hasattr(self.__local, "__release_local__"):
            return self.__local()
        try:
            return getattr(self.__local, self.__name__)
        except AttributeError:
            raise RuntimeError("no object bound to %s" % self.__name__)
            
            
            
 # self.__local 是在 LocalProxy 类实例化的时候传入的local
 
# 在这里实例化的：request = LocalProxy(partial(_lookup_req_object, "request"))
# local 是 partial(_lookup_req_object, "request")
 
#_lookup_req_object ，name=request
def _lookup_req_object(name):
    top = _request_ctx_stack.top  # 取出了ctx，是当前线程的ctx
    if top is None:
        raise RuntimeError(_request_ctx_err_msg)
    return getattr(top, name)  #从ctx中反射出request，当次请求的request

 请求上下文执行流程（ctx）：
		-0 flask项目一启动，有6个全局变量
			-_request_ctx_stack：LocalStack对象
			-_app_ctx_stack ：LocalStack对象
			-request ： LocalProxy对象
			-session ： LocalProxy对象
		-1 请求来了 app.__call__()---->内部执行：self.wsgi_app(environ, start_response)
		-2 wsgi_app()
			-2.1 执行：ctx = self.request_context(environ)：返回一个RequestContext对象，并且封装了request(当次请求的request对象)，session,flash,当前app对象
			-2.2 执行： ctx.push()：RequestContext对象的push方法
				-2.2.1 push方法中中间位置有：_request_ctx_stack.push(self)，self是ctx对象
				-2.2.2 去_request_ctx_stack对象的类中找push方法（LocalStack中找push方法）
				-2.2.3 push方法源码：
				    def push(self, obj):
						#通过反射找self._local,在init实例化的时候生成的：self._local = Local()
						#Local()，flask封装的支持线程和协程的local对象
						# 一开始取不到stack，返回None
						rv = getattr(self._local, "stack", None)
						if rv is None:
							#走到这，self._local.stack=[],rv=self._local.stack
							self._local.stack = rv = []
						# 把ctx放到了列表中
						#self._local={'线程id1':{'stack':[ctx,]},'线程id2':{'stack':[ctx,]},'线程id3':{'stack':[ctx,]}}
						rv.append(obj)
						return rv
		-3 如果在视图函数中使用request对象，比如：print(request)
			-3.1 会调用request对象的__str__方法，request类是：LocalProxy
            # 也就是对象自身当作第一参数传入
			-3.2 LocalProxy中的__str__方法：lambda x: str(x._get_current_object())
				-3.2.1 内部执行self._get_current_object()
				-3.2.2 _get_current_object()方法的源码如下：
				    def _get_current_object(self):
						if not hasattr(self.__local, "__release_local__"):
							#self.__local()  在init的时候，实例化的，在init中：object.__setattr__(self, "_LocalProxy__local", local)
							# 用了隐藏属性
							#self.__local 实例化该类的时候传入的local（偏函数的内存地址：partial(_lookup_req_object, "request")）
							#加括号返回，就会执行偏函数，也就是执行_lookup_req_object，不需要传参数了
							#这个地方的返回值就是request对象(当此请求的request，没有乱)
							return self.__local()
						try:
							return getattr(self.__local, self.__name__)
						except AttributeError:
							raise RuntimeError("no object bound to %s" % self.__name__)
				-3.2.3 _lookup_req_object函数源码如下：
					def _lookup_req_object(name):
						#name是'request'字符串
						#top方法是把第二步中放入的ctx取出来，因为都在一个线程内，当前取到的就是当次请求的ctx对象
						top = _request_ctx_stack.top
						if top is None:
							raise RuntimeError(_request_ctx_err_msg)
						#通过反射，去ctx中把request对象返回
						return getattr(top, name)
				-3.2.4 所以：print(request) 实质上是在打印当此请求的request对象的__str__
		-4 如果在视图函数中使用request对象，比如：print(request.method):实质上是取到当次请求的reuquest对象的method属性
		
		-5 最终，请求结束执行： ctx.auto_pop(error)，把ctx移除掉
		
	其他的东西：
		-session:
			-请求来了opensession
				-ctx.push()---->也就是RequestContext类的push方法的最后的地方：
					if self.session is None:
						#self是ctx，ctx中有个app就是flask对象，   self.app.session_interface也就是它：SecureCookieSessionInterface()
						session_interface = self.app.session_interface
						self.session = session_interface.open_session(self.app, self.request)
						if self.session is None:
							#经过上面还是None的话，生成了个空session
							self.session = session_interface.make_null_session(self.app)
			-请求走了savesession
				-response = self.full_dispatch_request() 方法内部：执行了before_first_request，before_request，视图函数，after_request，savesession
				-self.full_dispatch_request()---->执行：self.finalize_request(rv)-----》self.process_response(response)----》最后：self.session_interface.save_session(self, ctx.session, response)
		-请求扩展相关
			before_first_request，before_request，after_request依次执行
		-flask有一个请求上下文，一个应用上下文
			-ctx:
				-是：RequestContext对象:封装了request和session
				-调用了：_request_ctx_stack.push(self)就是把：ctx放到了那个位置
			-app_ctx:
				-是：AppContext(self) 对象：封装了当前的app和g
				-调用 _app_ctx_stack.push(self) 就是把：app_ctx放到了那个位置
	-g是个什么鬼？
		专门用来存储用户信息的g对象，g的全称的为global 
		g对象在一次请求中的所有的代码的地方，都是可以使用的 
		
		
	-代理模式
		-request和session就是代理对象，用的就是代理模式

wtforms（了解）

django有forms组件

生成前端模板

校验数据

渲染错误信息

flask中使用第三方的wtforms实现像django的forms一样的功能

第一步：导入，定义一个类，基础forms

第二步：模板中，for循环生成模板

第三步：视图函数中，使用form校验数据

 from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets
 
app = Flask(__name__, template_folder='templates')
 
app.debug = True
 
 
class LoginForm(Form):
    # 字段（内部包含正则表达式）
    name = simple.StringField(
        label='用户名',
        validators=[
            validators.DataRequired(message='用户名不能为空.'),
            validators.Length(min=6, max=18, message='用户名长度必须大于%(min)d且小于%(max)d')
        ],
        widget=widgets.TextInput(), # 页面上显示的插件
        render_kw={'class': 'form-control'}
 
    )
    # 字段（内部包含正则表达式）
    pwd = simple.PasswordField(
        label='密码',
        validators=[
            validators.DataRequired(message='密码不能为空.'),
            validators.Length(min=8, message='用户名长度必须大于%(min)d'),
            validators.Regexp(regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}",
                              message='密码至少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符')
 
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )
 
 
 
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        form = LoginForm()
        return render_template('login.html', form=form)
    else:
        form = LoginForm(formdata=request.form)
        if form.validate():
            print('用户提交数据通过格式验证，提交的值为：', form.data)
        else:
            print(form.errors)
        return render_template('login.html', form=form)
 
if __name__ == '__main__':
    app.run()

 <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>登录</h1>
<form method="post" novalidate>
    <p>{{form.name.label}}： {{form.name}} {{form.name.errors[0] }}</p>
 
    <p>{{form.pwd.label}} {{form.pwd}} {{form.pwd.errors[0] }}</p>
    <input type="submit" value="提交">
</form>
</body>
</html>

posted @ 2023-04-06 22:34 clever-cat 阅读(37) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· flask，信号，flask-script，sqlalchemy介绍与快速使用，sqlalchemy创建操作数据表

· flask，cbv分析，模板，请求与响应，session及源码分析，闪现，请求扩展

· Flask基础【集合】

· flask之请求上下文源码和第三方模块wtforms

· 【flask】flask请求上下文分析 threading.local对象偏函数 flask1.1.4生命执行流程 wtforms

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· DeepSeek 开源周回顾「GitHub 热点速览」
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了

公告

昵称： clever-cat
园龄： 2年5个月
粉丝： 19
关注： 34

+加关注

2025年3月

日

一

二

三

四

五

六

clever-cat

flask请求上下文分析，源码request原理，wtforms，精确导出依赖，函数和方法，threading.locl对象，偏函数，flask整个生命周期执行流程1.1.4版本

内容回顾

蓝图

g对象

flask中使用mysql数据库

数据库连接池

内容详情

导出项目依赖

函数和方法

threading.local对象

偏函数

flask整个生命执行流程(1.1.4版本)

现在我们去看看在请求中使用request的情况

请求上下文执行流程(lqz分析)

wtforms（了解）

django有forms组件

flask中使用第三方的wtforms实现像django的forms一样的功能

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	# 只要会自动传值，就是方法，函数，有几个值就要传几个值，否则报错


	# 函数就是普通的函数，有几个参数就要传几个参数
	# 方法：绑定给对象的方法，绑定给类的方法，绑定给谁的，由谁来调用，会自动把自身传入
	# 类的绑定方法，对象可以来调用，会自动把类传入
	# 对象的绑定方法，类可以来调用？类可以调用，但是它就变成了普通函数，有几个值，就要传几个值，没有自动传值了


	# MethodType检查一个对象，是不是方法
	# FunctionType检查一个对象，是不是函数
	# isinstance 判断一个对象，是不是一个类的对象
	# issubclass 判断一个类，是不是另一个类的子类

	from types import MethodType, FunctionType


	class Foo(object):
	def fetch(self):
	pass

	@classmethod
	def test(cls):
	pass

	@staticmethod
	def test1():
	pass


	# a=Foo()
	# print(isinstance(a,Foo))
	# print(isinstance('a',Foo))
	#
	# class Foo2(Foo):
	# pass
	# class Foo3():
	# pass
	# print(issubclass(Foo2,Foo))
	# print(issubclass(Foo3,Foo))


	def add():
	pass


	# 类来调用对象的绑定方法，
	print(isinstance(Foo.fetch, MethodType)) # False 类来调用对象的绑定方法，该方法就变成了普通函数
	obj = Foo()
	print(isinstance(obj.fetch, MethodType)) # True 对象来调用自己的绑定方法，fetch就是方法
	print(isinstance(Foo.fetch, FunctionType)) # True 类来调用对象的绑定方法，该方法就变成了普通函数

	print(isinstance(add, FunctionType)) # True 就是个普通函数
	print(isinstance(add, MethodType)) # False 就是个普通函数


	print(isinstance(Foo.test, MethodType)) # True test 是绑定给类的方法，类来调用，就是方法

	print(isinstance(obj.test, MethodType)) # True 对象调用类的绑定方法，还是方法

	print(isinstance(Foo.test1, MethodType)) # False 是普通函数
	print(isinstance(obj.test1, MethodType)) # False 是普通函数
	print(isinstance(obj.test1, FunctionType)) # True，静态方法，就是普通函数，对象和类都可以调用，有几个值就传几个值

	# 自己封装local，实现兼容线程和协程

	# 尝试导入greenlet试一下，如果导入不进来，说明根本没有用greenlet，就没有用协程，用了协程就不报错
	try:
	from greenlet import getcurrent as get_ident
	except Exception as e:
	from threading import get_ident

	from threading import Thread
	import time


	class Local(object):
	def __init__(self):
	object.__setattr__(self, 'storage', {}) # 这个不会触发setattr
	# self.storage={} # 它会触发 __setattr__,就会递归

	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}

	def __getattr__(self, k):
	ident = get_ident()
	return self.storage[ident][k]


	lqz = Local()
	def task(arg):
	lqz.arg = arg
	print(lqz.arg)


	for i in range(10):
	t = Thread(target=task, args=(i,))
	t.start()

	from functools import partial
	def add(a,b,c):
	return a+b+c


	# print(add(2,3,4)) # 传少了报错

	# 现在只有一个参数，后面的俩参数，需要过一会才知道
	# 借助于偏函数，先提前给他把第一个参数传入，后面知道了后面俩参数，再传后面俩

	add=partial(add,2)
	#
	# # 干了很多事
	#
	print(add(3,4))

	# 这个environ是请求对象，start_response开始响应对象不需要关系
	def __call__(self, environ, start_response):
	return self.wsgi_app(environ, start_response)

	def wsgi_app(self, environ, start_response):
	# environ 封装的请求对象，返回了RequestContext对象
	ctx = self.request_context(environ)
	error = None
	try:
	try:
	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
	return response(environ, start_response)
	finally:
	if self.should_ignore_error(error):
	error = None
	ctx.auto_pop(error)

	def request_context(self, environ):
	# self是app对象
	return RequestContext(self, environ)

	def __init__(self, app, environ, request=None, session=None):
	self.app = app
	# request为空
	if request is None:
	# 走到这里去找app也就是前面传来来的app对象request_class
	# from .wrappers import Request 看到是从这个里导入的看到的是flask自己封装的Request
	request = app.request_class(environ)
	self.request = request
	self.url_adapter = None
	try:
	self.url_adapter = app.create_url_adapter(self.request)
	except HTTPException as e:
	self.request.routing_exception = e
	self.flashes = None
	self.session = session

	def push(self):


	# self 传的是ctx对象
	# _request_ctx_stack = LocalStack()是globals里面的
	_request_ctx_stack.push(self)

	# 拿出session
	if self.session is None:
	session_interface = self.app.session_interface
	# 看到了熟悉的open_session
	self.session = session_interface.open_session(self.app, self.request)

	if self.session is None:
	self.session = session_interface.make_null_session(self.app)
	if self.url_adapter is not None:
	self.match_request()

	class LocalStack(object):
	# 初始化把Local()产生的对象放到到了这里面，去看这个Local类的初始化，就在上面
	def __init__(self):
	self._local = Local()

	class Local(object):
	__slots__ = ("__storage__", "__ident_func__")

	def __init__(self):
	# 初始化设置__storage__空字典
	object.__setattr__(self, "__storage__", {})
	# 这个是获取id的方法内存地址也放到对象里面
	object.__setattr__(self, "__ident_func__", get_ident)

	def push(self, obj):
	"""Pushes a new item to the stack"""
	# obj 是ctx也就是当次请求request对象
	# 这里刚开是的线程id对应的肯定没有，所有就是往LocalStack对象的_local也就是Local对象存request对象
	rv = getattr(self._local, "stack", None)
	if rv is None:
	self._local.stack = rv = []
	rv.append(obj)
	return rv

	def __setattr__(self, name, value):
	# 获取线程(协程)id
	ident = self.__ident_func__()
	# 拿到这个全局对象字典
	storage = self.__storage__
	try:
	# 尝试往这个字典这个线程id对应的key对象name也就是stack，value是列表进行赋值，如果存在那么会直接覆盖
	storage[ident][name] = value
	except KeyError:
	# 不存在则像这个id赋值，一个stack key对应的是空列表
	storage[ident] = {name: value}

	def full_dispatch_request(self):
	# 执行请求扩展中的before_first_request
	self.try_trigger_before_first_request_functions()
	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)
	# 这里面把session加密后一并返回给了前端里面的
	"""
	这个函数调用save_session()进行了加密保存以及返回了有兴趣自己可以进去看看
	response = self.process_response(response)
	"""
	return self.finalize_request(rv)

	def dispatch_request(self):
	# 拿到request对象
	req = _request_ctx_stack.top.request
	# routing_exception默认是None,所有不走
	if req.routing_exception is not None:
	self.raise_routing_exception(req)
	# werkzug的封装了一层这个就是路由例如/index或则/home/index
	rule = req.url_rule
	# if we provide automatic options for this URL and the
	# request came with the OPTIONS method, reply automatically
	# 这里是处理复杂请求头
	if (
	getattr(rule, "provide_automatic_options", False)
	and req.method == "OPTIONS"
	):
	return self.make_default_options_response()
	# otherwise dispatch to the handler for that endpoint
	# 这里是真正执行路由匹配的用endpoint来进行匹配
	return self.view_functions[rule.endpoint](**req.view_args)

	class LocalProxy(object):
	# 这个是注册
	__slots__ = ("__local", "__dict__", "__name__", "__wrapped__")

	# 这个name是None
	def __init__(self, local, name=None):
	# 这里_LocalProxy__local是给这个类对象添加私有属性，属性名叫__local
	object.__setattr__(self, "_LocalProxy__local", local)
	object.__setattr__(self, "__name__", name)

	# LocalProxy 代理类---》method---》代理类去当前线程的stack取出ctx，取出当时放进去的request
	视图函数中：print(request.method)

	def __getattr__(self, name):
	if name == "__members__":
	return dir(self._get_current_object())
	# 从request对象里面拿出对象的method，以及其他属性
	return getattr(self._get_current_object(), name)

	def _get_current_object(self):
	# 这里取__local对象没有__release_local__
	if not hasattr(self.__local, "__release_local__"):
	# 然后就是是partial(_lookup_req_object, "request")执行了这个拿到了request对象
	return 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):
	top = _request_ctx_stack.top # 这个是伪装属性
	if top is None:
	raise RuntimeError(_request_ctx_err_msg)
	# 最终这里拿到了Local对象里面的存放的ctx对象
	return getattr(top, name)

	@property
	def top(self):
	try:
	# 这里是拿出线程id对象的存在Local对象stack里面的对象列表里最后的一个
	return self._local.stack[-1]
	except (AttributeError, IndexError):
	return None

	def __getattr__(self, name):
	try:
	# 获取线程(协程)对应的RequestContext对应【name=stack】
	return self.__storage__[self.__ident_func__()][name]
	except KeyError:
	raise AttributeError(name)

	# 请求来了---》app()----->Flask.__call__--->self.wsgi_app(environ, start_response)
	def wsgi_app(self, environ, start_response):
	# environ:http请求拆成了字典
	# ctx对象：RequestContext类的对象，对象里有：当次的requets对象，app对象，session对象
	ctx = self.request_context(environ)
	error = None
	try:
	try:
	#ctx RequestContext类 push方法
	ctx.push()
	# 匹配成路由后，执行视图函数
	response = self.full_dispatch_request()
	except Exception as e:
	error = e
	response = self.handle_exception(e)
	except:
	error = sys.exc_info()[1]
	raise
	return response(environ, start_response)
	finally:
	if self.should_ignore_error(error):
	error = None
	ctx.auto_pop(error)





	# RequestContext :ctx.push
	def push(self):
	# _request_ctx_stack = LocalStack() ---》push(ctx对象)--》ctx:request，session，app
	_request_ctx_stack.push(self)
	#session相关的
	if self.session is None:
	session_interface = self.app.session_interface
	self.session = session_interface.open_session(self.app, self.request)

	if self.session is None:
	self.session = session_interface.make_null_session(self.app)
	# 路由匹配相关的
	if self.url_adapter is not None:
	self.match_request()



	# LocalStack() push --->obj 是ctx对象
	def push(self, obj):
	#self._local _local 就是咱们刚刚自己写的Local的对象---》LocalStack的init初始化的_local---》self._local = Local()---》Local对象可以根据线程协程区分数据
	rv = getattr(self._local, "stack", None)
	# 一开始没有值
	if rv is None:
	rv = []
	self._local.stack = rv # self._local.stack 根据不同线程用的是自己的数据
	rv.append(obj) # self._local.stack.append(obj)
	# {'线程id号'：{stack：[ctx]},'线程id号2'：{stack：[ctx]}}
	return rv



	# 再往后执行，就会进入到路由匹配，执行视图函数
	# request = LocalProxy(partial(_lookup_req_object, "request"))
	# LocalProxy 代理类---》method---》代理类去当前线程的stack取出ctx，取出当时放进去的request
	视图函数中：print(request.method)


	# print(request) 执行LocalProxy类的__str__方法
	# request.method 执行LocalProxy类的__getattr__
	def __getattr__(self, name): #name 是method
	# self._get_current_object() 就是当次请求的request
	return getattr(self._get_current_object(), name)


	# LocalProxy类的方法_get_current_object
	def _get_current_object(self):
	if not hasattr(self.__local, "__release_local__"):
	return self.__local()
	try:
	return getattr(self.__local, self.__name__)
	except AttributeError:
	raise RuntimeError("no object bound to %s" % self.__name__)



	# self.__local 是在 LocalProxy 类实例化的时候传入的local

	# 在这里实例化的：request = LocalProxy(partial(_lookup_req_object, "request"))
	# local 是 partial(_lookup_req_object, "request")

	#_lookup_req_object ，name=request
	def _lookup_req_object(name):
	top = _request_ctx_stack.top # 取出了ctx，是当前线程的ctx
	if top is None:
	raise RuntimeError(_request_ctx_err_msg)
	return getattr(top, name) #从ctx中反射出request，当次请求的request

	请求上下文执行流程（ctx）：
	-0 flask项目一启动，有6个全局变量
	-_request_ctx_stack：LocalStack对象
	-_app_ctx_stack ：LocalStack对象
	-request ： LocalProxy对象
	-session ： LocalProxy对象
	-1 请求来了 app.__call__()---->内部执行：self.wsgi_app(environ, start_response)
	-2 wsgi_app()
	-2.1 执行：ctx = self.request_context(environ)：返回一个RequestContext对象，并且封装了request(当次请求的request对象)，session,flash,当前app对象
	-2.2 执行： ctx.push()：RequestContext对象的push方法
	-2.2.1 push方法中中间位置有：_request_ctx_stack.push(self)，self是ctx对象
	-2.2.2 去_request_ctx_stack对象的类中找push方法（LocalStack中找push方法）
	-2.2.3 push方法源码：
	def push(self, obj):
	#通过反射找self._local,在init实例化的时候生成的：self._local = Local()
	#Local()，flask封装的支持线程和协程的local对象
	# 一开始取不到stack，返回None
	rv = getattr(self._local, "stack", None)
	if rv is None:
	#走到这，self._local.stack=[],rv=self._local.stack
	self._local.stack = rv = []
	# 把ctx放到了列表中
	#self._local={'线程id1':{'stack':[ctx,]},'线程id2':{'stack':[ctx,]},'线程id3':{'stack':[ctx,]}}
	rv.append(obj)
	return rv
	-3 如果在视图函数中使用request对象，比如：print(request)
	-3.1 会调用request对象的__str__方法，request类是：LocalProxy
	# 也就是对象自身当作第一参数传入
	-3.2 LocalProxy中的__str__方法：lambda x: str(x._get_current_object())
	-3.2.1 内部执行self._get_current_object()
	-3.2.2 _get_current_object()方法的源码如下：
	def _get_current_object(self):
	if not hasattr(self.__local, "__release_local__"):
	#self.__local() 在init的时候，实例化的，在init中：object.__setattr__(self, "_LocalProxy__local", local)
	# 用了隐藏属性
	#self.__local 实例化该类的时候传入的local（偏函数的内存地址：partial(_lookup_req_object, "request")）
	#加括号返回，就会执行偏函数，也就是执行_lookup_req_object，不需要传参数了
	#这个地方的返回值就是request对象(当此请求的request，没有乱)
	return self.__local()
	try:
	return getattr(self.__local, self.__name__)
	except AttributeError:
	raise RuntimeError("no object bound to %s" % self.__name__)
	-3.2.3 _lookup_req_object函数源码如下：
	def _lookup_req_object(name):
	#name是'request'字符串
	#top方法是把第二步中放入的ctx取出来，因为都在一个线程内，当前取到的就是当次请求的ctx对象
	top = _request_ctx_stack.top
	if top is None:
	raise RuntimeError(_request_ctx_err_msg)
	#通过反射，去ctx中把request对象返回
	return getattr(top, name)
	-3.2.4 所以：print(request) 实质上是在打印当此请求的request对象的__str__
	-4 如果在视图函数中使用request对象，比如：print(request.method):实质上是取到当次请求的reuquest对象的method属性

	-5 最终，请求结束执行： ctx.auto_pop(error)，把ctx移除掉

	其他的东西：
	-session:
	-请求来了opensession
	-ctx.push()---->也就是RequestContext类的push方法的最后的地方：
	if self.session is None:
	#self是ctx，ctx中有个app就是flask对象， self.app.session_interface也就是它：SecureCookieSessionInterface()
	session_interface = self.app.session_interface
	self.session = session_interface.open_session(self.app, self.request)
	if self.session is None:
	#经过上面还是None的话，生成了个空session
	self.session = session_interface.make_null_session(self.app)
	-请求走了savesession
	-response = self.full_dispatch_request() 方法内部：执行了before_first_request，before_request，视图函数，after_request，savesession
	-self.full_dispatch_request()---->执行：self.finalize_request(rv)-----》self.process_response(response)----》最后：self.session_interface.save_session(self, ctx.session, response)
	-请求扩展相关
	before_first_request，before_request，after_request依次执行
	-flask有一个请求上下文，一个应用上下文
	-ctx:
	-是：RequestContext对象:封装了request和session
	-调用了：_request_ctx_stack.push(self)就是把：ctx放到了那个位置
	-app_ctx:
	-是：AppContext(self) 对象：封装了当前的app和g
	-调用 _app_ctx_stack.push(self) 就是把：app_ctx放到了那个位置
	-g是个什么鬼？
	专门用来存储用户信息的g对象，g的全称的为global
	g对象在一次请求中的所有的代码的地方，都是可以使用的


	-代理模式
	-request和session就是代理对象，用的就是代理模式

	from flask import Flask, render_template, request, redirect
	from wtforms import Form
	from wtforms.fields import simple
	from wtforms import validators
	from wtforms import widgets

	app = Flask(__name__, template_folder='templates')

	app.debug = True


	class LoginForm(Form):
	# 字段（内部包含正则表达式）
	name = simple.StringField(
	label='用户名',
	validators=[
	validators.DataRequired(message='用户名不能为空.'),
	validators.Length(min=6, max=18, message='用户名长度必须大于%(min)d且小于%(max)d')
	],
	widget=widgets.TextInput(), # 页面上显示的插件
	render_kw={'class': 'form-control'}

	)
	# 字段（内部包含正则表达式）
	pwd = simple.PasswordField(
	label='密码',
	validators=[
	validators.DataRequired(message='密码不能为空.'),
	validators.Length(min=8, message='用户名长度必须大于%(min)d'),
	validators.Regexp(regex="^(?=.[a-z])(?=.[A-Z])(?=.\d)(?=.[$@$!%?&])[A-Za-z\d$@$!%?&]{8,}",
	message='密码至少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符')

	],
	widget=widgets.PasswordInput(),
	render_kw={'class': 'form-control'}
	)



	@app.route('/login', methods=['GET', 'POST'])
	def login():
	if request.method == 'GET':
	form = LoginForm()
	return render_template('login.html', form=form)
	else:
	form = LoginForm(formdata=request.form)
	if form.validate():
	print('用户提交数据通过格式验证，提交的值为：', form.data)
	else:
	print(form.errors)
	return render_template('login.html', form=form)

	if __name__ == '__main__':
	app.run()

	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="UTF-8">
	<title>Title</title>
	</head>
	<body>
	<h1>登录</h1>
	<form method="post" novalidate>
	<p>{{form.name.label}}： {{form.name}} {{form.name.errors[0] }}</p>

	<p>{{form.pwd.label}} {{form.pwd}} {{form.pwd.errors[0] }}</p>
	<input type="submit" value="提交">
	</form>
	</body>
	</html>