16_Flask请求上下文

最新推荐文章于 2022-11-09 17:10:45 发布

Masked5

最新推荐文章于 2022-11-09 17:10:45 发布

阅读量146

点赞数

分类专栏： Flask

原文链接：https://www.cnblogs.com/xiaoyuanqujing/category/1561311.html

版权

Flask 专栏收录该内容

18 篇文章 5 订阅

订阅专栏

文章目录

0 阅读flask上下文前夕补充
1 首先分析请求上下文对象(ctx)创立
2 把请求对象(ctx)添加到local中（入栈）
3 找到视图函数并且使用导入request对象
4 请求结束时从Local中移除上下文对象（出栈）
总结：

0 阅读flask上下文前夕补充

预读源码必要了解的知识点

在阅读源码之前，源码中会涉及到很多python类的特殊的用法以及类写好的功能组件，所以这里我们做一个补充，以便于接下来源码的阅读

0.1 偏函数

当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

from functools import partial
def func(a1,a2,a3):
    print(a1,a2,a3)


new_func1 = partial(func,a1=1,a2=2)
new_func1(a3=3)

new_func2 = partial(func,1,2)
new_func2(3)

new_func3 = partial(func,a1=1)
new_func3(a2=2,a3=3)

注意：partial括号内第一个参数是原函数，其余参数是需要固定的参数

效果图：

0.2 `add`的使用

如果一个类里面定义了 __add__方法，如果这个类的对象 +另一个对象，会触发这个类的__add__方法，换个说法如果 对象1+对象2 则会触发对象1的 __add__方法，python在类中有很多类似的方法，对象会在不同情况下出发对应的方法。

class Foo:
    def __init__(self):
        self.num = 1

    def __add__(self, other):
        if isinstance(other, Foo):
            result = self.num + other.num
        else:
            result = self.num + other
        return result


fo1 = Foo()
fo2 = Foo()
v1 = fo1 + fo2
v2 = fo1 + 4
print(v1, v2)

效果图：

0.3 chain函数

chain函数来自于itertools库，itertools库提供了非常有用的基于迭代对象的函数，而chain函数则是可以串联多个迭代对象来形成一个更大的迭代对象。

实例1：

from itertools import chain

l1 = [1, 2, 3]
l2 = [4, 5]

new_iter = chain(l1, l2)  # 参数必须为可迭代对象
print(new_iter)
for i in new_iter:
    print(i)

效果图：

实例2：

from itertools import chain


def f1(x):
    return x + 1


def f2(x):
    return x + 2


def f3(x):
    return x + 3


list_4 = [f1, f2]
new_iter2 = chain([f3], list_4)
for i in new_iter2:
    print(i)

效果图：

在分析上下问之前，要做好一个心理准备，因为设计到的代码会很多，需要不懂的要跟着文档自己去翻阅源码。

首先把涉及到的主要的类或者设计到的py页面展示如下图。下面我会以对应类或者页面去讲解flask源码

之前我们已经论述过了，每次请求过来都会触发app()，所以会触发FLask类的__call__方法，__call__方法会触发Flask类的wsgi_app()方法。然后所有的请求的整个生命周期都在整个wsgi_app()里面了。

根据上图类和序号来完成我们的分析流程。

1 首先分析请求上下文对象(ctx)创立

1.0 FLask 类中的wsgi_app()中的 ctx = self.request_context(environ）

1.1 RequestContext类中的 __init__

实例化出请求上下文对象ctx

并且关注：

if request is None:
    request = app.request_class(environ)
self.request = request

1.2 Request类中的 __init__
- 该类的 __init__方法实例化出reqeust对象
这三部完成了初始化一个用户请求相关的数据，也就是请求上下文对象。

1.0中的ctx就是RequestContext对象，请求上下文对象ctx中初始化所有请求所有内容，并且其内部封装着Request对象，Request对象把请求过来的信息格式化并且储存起来。

2 把请求对象(ctx)添加到local中（入栈）

2.0 FLask 类中的wsgi_app()中的 ctx.push()
2.1 RequestContext 类中的 push() 下
- 只关注_request_ctx_stack.push(self)
2.2 LocalStack类中的 push()方法
- 只关注 self._local.stack = rv = [] ，触发2.3执行。
- 在实现了2.3的基础上，关注本方法中的 rv.append(obj) , rv就是2.3中stack的value值，此obj就是ctx对象，相当于为Local类中的storage里面的当前线程或携程唯一标识里的stack对应的value值，添加了球队上下文对象ctx，这个对象里面包含了所有请求过来的信息。
{

线程或携程唯一标识:{

stack:[请求上下文对象ctx]。

}，

}
2.3 Local类中的 __setattr__方法实现了创建了
- storage = {
  
  线程或携程唯一标识:{
  
  stack: [ ]
  
  }，
  
  }

3 找到视图函数并且使用导入request对象

3.0 FLask 类中的wsgi_app()中 response = self.full_dispatch_request()的找到视图函数并执行

3.1 找到了视图函数并且执行request.method方法。

@app.route('/')
def index():
    v = request.method
    return  v

3.2 须知：request = LocalProxy(partial(_lookup_req_object, 'request')) 用于在视图函数里导入的request对象
- 偏函数：partial(_lookup_req_object, ‘request’) 不懂可以翻阅之前的文章
3.3 触发了LocalProxy类中的 __getattr__
- 关注：return getattr(self._get_current_object(), name) # name是‘method’，去Request类中查询‘method’属性，
3.4 触发了LocalProxy类中的 _get_current_object()
- 关注 return self.__local() #返回了Request对象
  
  在LocalProxy类实例化的时候使得self.__local的值就是实例化时传入偏函数。所以会返回偏函数运行结果。
3.5 触发了globals.py 里的 _lookup_req_object()运行。
- 关注 top = _request_ctx_stack.top # 触发3.6执行
- return getattr(top, name) # name = ‘request’，所以返回了Request对象
3.6 触发了LocalStack类中的top()方法：
- 关注 return self._local.stack[-1] # 返回了请求上下文ctx对象。
3.7 触发了Local类中的__getattr__（）方法
- 关注return self.__storage__[self.__ident_func__()][name] #返回了当前线程或携程的stack对应的value值，可以理解为返回了 [ctx对象]

4 请求结束时从Local中移除上下文对象（出栈）

经过了添加请求上下文到Local的storage中，以及视图函数的运行返回相应对象，我们现在进行把请求上下文对象从storage中移除。

4.0 FLask 类中的wsgi_app()中 ctx.auto_pop()
4.1 触发了 RequestContext类中的 auto_pop()
- 关注 self.pop()
4.2 触发了 RequestContext类中的 pop() 方法
- rv = _request_ctx_stack.pop()

4.3 触发了 LocalStack类中的pop()的pop方法

elif len(stack) == 1: # 证明push过一次 添加过了一次对象
    release_local(self._local) # 在这里pop掉该线程。release_local pop掉的是一个字典
    return stack[-1]

4.4 触发了 Local类中的__release_local__() 方法

self.__storage__.pop(self.__ident_func__(), None) #在Local对象中删除掉了当前线程或者携程的请求上下文对象，

总结：

其实操作flask的请求上下文就是操作Local中的字典__storage__
1. 通过REquestContext类首先实例化ctx请求上下文对象，其内部包含请求对象
2. 入栈，通过请求上下文对象的类的push()方法触发了LocalStack类的push() 方法，从而添加到Local类中的字典里。
3. 观察导入的request源码，通过观察LocalProxy的源码，最后触发了LocalStack的top()方得到上下文对象，再的到请求对象，从而实现reuqest的功能。
4. 出站，和入栈原理相同通过请求上下文对象的类的方法，触发了LocalStack的的pop()方法从而从字典中删除掉当前线程或当前携程的请求信息。