flask 请求上下文

一篇引用大牛的
https://www.cnblogs.com/zhaopanpan/p/9457343.html

### 线程安全  

```python
# 线程不安全
class Foo(object):
    pass

foo = Foo()
foo.num = 1

import time
import threading

def my_num(i):
    foo.num = i
    time.sleep(1)
    print(foo.num,threading.current_thread().ident)

for i in range(20):
    th = threading.Thread(target=my_num,args=(i,))
    th.start()
----------------------------------------------------------------------------

# 线程安全
from threading import local
class Foo(local):
    pass

foo = Foo()
foo.num = 1

import time
import threading

def my_num(i):
    foo.num = i
    time.sleep(1)
    print(foo.num,threading.current_thread().ident)

for i in range(200000):
    th = threading.Thread(target=my_num,args=(i,))
    th.start()

# 开辟新空间 - 浪费了部分资源 - 速度保证 - 保证安全
"""
{
    16232:[request],# 123
    17164:[request],# 456
    9088: [request],# 567
    16084:[request],# 789
}

Threading.local
Flask 上下文机制就是使用的 Threading.local
线程进来 开辟一个空间给这个线程，线程操作的所有任务，都会复制一份儿到空间中
"""
```

### 栈  Stack

```python
# Stack
class MyStack(object):
    data = []

    def __setattr__(self, key, value):
        self.push(key,value)

    def push(self,key,value):
        self.data.append({key:value})

    def top(self):
        return self.data.pop()

my_stack = MyStack()

my_stack.name = 666 # [{name:666}]
my_stack.name = 777 # [{name:666},{name:777}]

print(my_stack.data)

# my_stack.push(666)
# my_stack.push(777)
# my_stack.push(888)
#
# print(my_stack.top(),my_stack.data)
# print(my_stack.top(),my_stack.data)
# print(my_stack.top(),my_stack.data)
```

### 局部的栈 LocalStack 

```python
# LocalStack  安全的 栈
from threading import get_ident  # 获取当前线程的 id
import threading

class MyLocalStack(object):
    storage={}
    def push(self,item):
        try:
            self.storage[get_ident()].append(item)
        except:
            self.storage[get_ident()]=[item]

    def top(self):
        return self.storage[get_ident()].pop()

my_local_stack = MyLocalStack()

import time
def go(i):
    my_local_stack.push(i)
    time.sleep(1)
    # my_local_stack.top()

for i in range(5):
    th = threading.Thread(target=go,args=(i,))
    th.start()

print(my_local_stack.storage)
```

## flask 的 请求上下文

+ ## werkzeug 

  + flask 的 wsgi 

```python
from werkzeug.wrappers import Request,Response
from werkzeug.serving import run_simple

@Request.application
def app(environ):
    print(environ)
    return Response("200OK")

run_simple("0.0.0.0",9527,app)  

```

```python
from flask import Flask
app = Flask(__name__)

if __name__ == '__main__':
    app.run(host='0.0.0.0',port=7088)   
    app.__call__
    app.wsgi_app

```

### 上文

1. 从 **`run()`** 开始

   + 进入源码  其中的  >> `self = app = Flask()`  

   + 导入了 `from werkzeug.serving import run_simple`  执行了  `run_simple(host, port, self, **options)` 方法     

   + 看这一句   `run_simple("0.0.0.0",9527, app) ` 也就是说 

     self  会执行  >> `self = app = Flask() = self()`   

   + 也就 == app()  对象()  执行 类的  `__call__()` 方法

2. `__call__() ` 执行了 `self.wsgi_app(environ, start_redponse)`    **environ  =  request 原始信息**

3. 进入 `app.wsgi_app` 

   +  `def wsgi_app(self, environ, start_response):` >> self = app = Flask()

   +  self 执行了这个方法 `ctx = self.request_context(environ)`  方法中执行了 一个类 `RequestContext(self, environ)` ctx.py文件中  >>  这个对象中 包含了 两个 值  requset/session

     ctx = requsetcontext -->  requset/session 

   + 在这个类中 的 初始化方法 中  `def __init__(self, app, environ, request=None):`  >>  self  = RequestContext  ->request/session     app = Flask    request=None    执行方法  `request = app.request_class(environ)` 这个方法将 environ  序列化 出了 request对象  就是可以使用  request.method  requset.form ...  方法  了  

   + 执行ctx.push() 方法  

4. ctx.push() 方法   

   + 方法中执行了  `top = _request_ctx_stack.top`   --> `_request_ctx_stack = LocalStack()`   实例化时的  `__init__` 方法中 初始化了  两个 对象 >>  `self._local = {"__storage__": {}, "__ident_func__": get_ident}`       >`get_ident` 获取线程 或携程的 id  并没有执行    

   + `_request_ctx_stack = {"__storage__": {}, "__ident_func__": get_ident}`

   + `.top ` 方法  执行了  `self._local.stact[-1]`    .stack 调用 Local(object):  对象的 `__getattr__(self) 方法`    

   + 方法中  调用  `self.__storage__[self.__ident_func__()][name]`  也就是从   

     `{"__storage__": {}, "__ident_func__": get_ident}` 中的  `__storage__` 中通过key 取值 此时 `__storage__` 中为 空字典  报错  抛出异常  `AttributeError(name)`  这个异常在上面的  top 方法中 被捕获 返回 一个 None     返回 **top = None**    之后的 if 判断不成立  

   + 之后又执行了  `_request_ctx_stack.push(self)` 代码  其中的   ` _request_ctx_stack = {"__storage__": {}, "__ident_func__": get_ident}`  

   + 执行了.push(self) 方法   这个self = ctx = requset/session   进入 push（） 方法

   + `def push(self, obj)`这里面的  self 是 ` _request_ctx_stack = {"__storage__": {}, "__ident_func__": get_ident}`    obj =  ctx = requset/session    执行 :  ` rv = getattr(self._local, 'stack', None)`  `self._local = {"__storage__": {}, "__ident_func__": get_ident}`  rv = None  -> if判断 执行` self._local.stack = rv = [] rv.append(obj) `    走对象的  `__setattr__(self,name,value)`方法   返回 =>>  `{"__storage__": {7088:{"stack": rv=[] }}, "__ident_func__": get_ident}`  

   + 返回 rv.append(obj)  ==>`{"__storage__": {7088:{"stack": [ctx=>request/session] }}, "__ident_func__": get_ident}`    `rv=[ctx=>request/session]  `  并没有接收返回值  执行完之后  `self._local = {"__storage__": {7088:{"stack": [ctx=>request/session] }}, "__ident_func__": get_ident}`

   ### 下文

   + 使用时才执行  

     ```python
     @app.route("/")
     def login():
         if requset.method =='POST':
             ...
             # requset.method 之后启动下文
     ```

   +  进入 request  

     ```python
     # partial 偏函数
     request = LocalProxy(
         partial(
             _lookup_req_object, 
             'request'
         )
     )
     ```

   + `_lookup_req_object`  

     ```python
     def _lookup_req_object(name):
         top = _request_ctx_stack.top
         # _request_ctx_stack = self._local = {"__storage__": {7088:{"stack": [ctx=>request/session] }}, "__ident_func__": get_ident}  调用.top 方法
         if top is None:
             raise RuntimeError(_request_ctx_err_msg)
         return getattr(top, name)
     ```

   + .top    中 执行了  `self._local.stack[-1]`

     ```python
     # 执行 self._local的 __getattr__ 方法  
     def __getattr__(self, name):
         try:
             return self.__storage__[self.__ident_func__()][name]
         except KeyError:
             raise AttributeError(name)

     # 返回了  [ctx => request / session ]  
     ```

     执行 [-1]  得到 `ctx => request / session`

   + `top = ctx => request / session`  

   + `getattr(top, name)`  name = request   从偏函数传递过来的  方法 得到了 一个 request 对象  及 request 的真身

   + 查看` LocalProxy(偏函数没被执行的 )`   实例化  执行`def __init__(self, local, name=None):`   local  = request 的偏函数  

     ```python
     def __init__(self, local, name=None):
         object.__setattr__(self, '_LocalProxy__local', local)
         object.__setattr__(self, '__name__', name)
         if callable(local) and not hasattr(local, '__release_local__'):
             # "local" is a callable that is not an instance of Local or
             # LocalManager: mark it as a wrapped function.
             object.__setattr__(self, '__wrapped__', local)
     ```

   + request.method 执行  .方法 调用  `__getattr__()`    执行 `getattr(self._get_current_object(), name)`   

     ```python
     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__)
     ```

     `__local = local = requset偏函数执行  = requset` 

   + `getattr(request, name)`    name = method   

+ ### 查看 LocalProxy  类  包含了 所有面向对象的  特殊方法

### 应用上下文

+ 会在 离线脚本 的时候使用

+ 从  `app.wsgi_app`  中 找到   `ctx.push()` 的方法 

+ `app_ctx = _app_ctx_stack.top` 这个  就是应用上下文

  ```python
  app_ctx = _app_ctx_stack.top
  if app_ctx is None or app_ctx.app != self.app:
      app_ctx = self.app.app_context()
      app_ctx.push()
      self._implicit_app_ctx_stack.append(app_ctx)
      else:
          self._implicit_app_ctx_stack.append(None)
  ```

  1. `_app_ctx_stack  = {"__storage__": {}, "__ident_func__": get_ident}`
  2. `.top` 方法 返回的还是  None  
  3. `app_ctx = None`

+  `app_ctx = self.app.app_context()`  序列化 app  得到  AppContext(app,g) -> requestcontext(request/session)  

+  `app_ctx.push()`   得到 `self._local = {"__storage__": {7088:{"stack": [app_ctx(app, g)] }}, "__ident_func__": get_ident}`  g会在 离线脚本 的时候使用

 `current_app = LocalProxy(_find_app)` = app = Flask()

```python
def _find_app():
    top = _app_ctx_stack.top  # 拿到 app_ctx(app,g)
    if top is None:
        raise RuntimeError(_app_ctx_err_msg)
    return top.app  # 返回一个 app  独立的 app 
```

请求结束之后执行 pop 方法  删除缓存

`g = LocalProxy(partial(_lookup_app_object, 'g'))`