flask---day04( 请求上下文分析, 函数和方法的区别, threading.local对象, 偏函数, flask 整个生命执行流程, wtforms )

.
.

上节回顾

# 1 蓝图
    - 第一步：导入
    - 第二步：实例化得到对象，可以指定static和templates
    - 第三步：app中注册蓝图，注册蓝图时，可以指定前缀
    - 第四步：使用蓝图，注册路由，注册请求扩展


# 2 g对象
	-当次请求的全局对象，在当次请求中可以放值和取值
	-跟session的区别是


# 3 flask中使用mysql数据库
	-pymysql，在一个视图函数中，创建一个连接对象，操作，操作完就关闭连接
	-连接对象不要用单例，可能会出现数据错乱问题


# 4 数据库连接池
	-dbutils
    -使用步骤：
    	1 第一步：导入，实例化得到一个对象， pool
        2 第二步：pool做成单例，以模块导入
        3 第三步：从pool中拿到一个连接 conn = pool.connection()
        3 第四步：使用连接获得游标，使用游标操作数据库
                 cursor = conn.cursor(pymysql.cursors.DictCursor)
                 cursor.execute('select id,name,`desc` from app01_article where id<3')
                 res = cursor.fetchall()


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

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

.
.
.
.
.
.
.
.

补充： 导出项目的依赖

# 之前 pip freeze >requirments.txt 把当前解释器环境下的所有第三方依赖都导出来（适用于虚拟环境下）


# 使用第三方模块pipreqs，更精确的导出依赖，这样项目可以不运行在虚拟环境，直接在本地环境写项目
# 然后用pipreqs模块，导出项目中用到的第三方模块
	第一步：安装 pip3 install pipreqs
	第二步：使用命令，导出项目依赖  pipreqs ./
		win由于编码问题可能会出错  pipreqs ./ --encoding=utf8
		mac，linx没有问题

	第三步：命令执行完，就会在项目根路径下生成：requirements.txt
	里面有该项目所需的所有依赖包

.
.
.
.
.

今日内容

1 请求上下文分析（源码：request对象及session对象的原理）

1.1 函数和方法的区别

------------------------------------------------------

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


函数就是普通的函数，有几个参数就要传几个参数
方法：绑定给对象的方法，绑定给类的方法，绑定给谁的，由谁来调用，会自动把自身传入


# 类的绑定方法，对象可以来调用，会自动把类传入

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

------------------------------------------------------


print(callable(对象名))  检查一个对象，是不是可调用


isinstance 判断一个对象，是不是一个类的对象
print(isinstance(5, int))  # True


issubclass 判断一个类，是不是另一个类的子类
print(issubclass(Warning, Exception))  # True

------------------------------------------------------
------------------------------------------------------

from types import MethodType, FunctionType


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

    @classmethod
    def test(cls):
        pass

    @staticmethod
    def test1():
        pass



class Foo2(Foo):
    pass


class Foo3():
    pass


def add():
    pass

------------------------------------------

a = Foo()
print(isinstance(a, Foo))    # True   判断一个对象，是不是一个类的对象
print(isinstance('a', Foo))   # False


print(issubclass(Foo2, Foo))  # True   判断一个类，是不是另一个类的子类
print(issubclass(Foo3, Foo))  # False


# 类来调用对象的绑定方法，
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，静态方法，就是普通函数，对象和类都可以调用，有几个值就传几个值


----------------------------------------------------------

.
.
.
.
.
.
.
.
.
.
.

1.2 threading.local 的对象

多个线程修改同一个数据，复制多份变量给每个线程用

多线程并发改同一个数据，数据不会发生错乱的核心原因：
为每个线程开辟一块空间进行数据存储，每个线程操作自己的那部分数据，

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

# 使用threading模块提供的local对象，多线程并发操作时也不需要加锁，也不会出现数据错乱

----------------------------------------------------------

# 本质原理：
多个线程修改同一个数据，复制多份变量给每个线程用,
为每个线程开辟一块空间进行数据存储，每个线程操作自己的那部分数据

----------------------------------------------------------

# 1 数据错乱问题
from threading import Thread, get_ident
# 每个线程在 Python 中都有一个唯一的标识符（identifier），
# 可以通过 get_ident() 方法获取它。线程标识符是一个整数，用于标识不同的线程。
import time

num = 0

def task(kkk):
    global num
    num = kkk
    time.sleep(2)
    # 我们本意是想每个线程打印自己传入的kkk，但是由于sleep了，
    # 等cpu再调度该线程执行是，num被改成了 9 ，所有人打印出来都是9，数据错乱了
    print('线程id:%s--------'%get_ident(),num)

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

# 不用sleep 代码能正常执行，每个线程打印自己传入的arg  打印出的lqz分别为 0 1 2 3 4 5 。。。
# 但是由于sleep了，cpu会切换执行其他的线程， 等cpu再调度该线程执行时，
# lqz被改成了9 ，所有线程打印出来都是9，数据错乱了

----------------------------------------------------------
----------------------------------------------------------

# 使用互斥锁解决这个问题,解决数据并发安全的问题
# 多进程的时候，加锁的代码，都在串行操作

from threading import Thread, get_ident
from threading import Lock

import time

num = -1
mutex = Lock()


def task(arg):

    # 很多行其他代码
    mutex.acquire()
    global num
    num = arg
    time.sleep(2)  # 我们本意是想每个线程打印自己传入的arg，但是由于sleep了， 等cpu再调度该线程执行是，lqz被改成了 9 ，所有人打印出来都是9，数据错乱了
    print('线程id为：%s----->' % get_ident(), lqz)
    mutex.release()
    # 只有抢锁放锁的区域，是串行，其他区域都是并发运行
    # 很多行其他代码


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

----------------------------------------------------------

.
.
.
.
.
.

# 使用local对象，不会出现并发安全问题

from threading import Thread
from threading import local
import time
from threading import get_ident

# 特殊的对象
obj = local()
# 为每个线程开辟一块空间进行数据存储，每个线程操作自己的那部分数据. 核心原因


def task(kkk):
    obj.arg = kkk
    time.sleep(1)
    print('线程id为：%s----->' % get_ident(), obj.arg)
    # 虽然用的都是obj这个变量，但是所有线程用的都是自己的那部分数据


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

# local对象为每一个线程建立一组键值对，值对应一个小字典，小字典里放该线程放进去的数据！！！
-------------------------------------------------

# flask中的request就是用了local对象
# 但是,它只能区分线程,不能区分协程！！！ 在协程情况下，还是会出并发数据安全的情况
# flask自己写了个local类,兼容线程和协程



# 本质是个大字典，里面放了一个个线程id号对应的小字典，flask自己写了个local类就是这么实现的
# 该小字典里面就是线程执行过程中，放在local类的对象里面的数据
    {'线程id号':{'arg':1},'线程id号':{'arg':2},'线程id号':{'arg':3}}



# 对于协程而言，里面放到就是协程id号来区分的，
    {'协程id号':{'arg':1},'协程id号':{'arg':2},'协程id号':{'arg':3}}

----------------------------------------------------------

.
.
.
.
.
.
.
.

通过双下getattr与双下setattr 构造一个local类的加强版

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

try:
    # 尝试导入greenlet试一下，如果导入不进来
    # 说明解释器根本没有装greenlet，这句话就会报错，如果该模块没有装，说明就没有用到协程
    # 一旦装了该模块，无论使用不使用协程，用getcurrent都能拿到协程id号，就不会再用线程号了

    # 导入取协程id号的方法getcurrent，并重命名为get_ident,这样有协程号就用协程号区分，
    # 没有就用线程号区分
    from greenlet import getcurrent as get_ident

except Exception as e:
    from threading import get_ident   # 导入取线程id号的方法


from threading import Thread
import time


# 自定义一个Local类
class Local(object):
    # storage={}    这个init干的就是这件事
    def __init__(self):
        object.__setattr__(self, 'storage', {})
        # object类调用自己的__setattr__方法，把local对象传进去，
        # 就是往local对象里添加一个storage属性，并等于一个空字典！
        # 定义出变量名叫storage的字典，这种方法不会触发 类里面的 __setattr__方法
        # self.storage={}  # 它会触发 __setattr__,就会出现递归，所以不能这么创storage字典


    def __setattr__(self, k, v):
        ident = get_ident()  # 如果用协程，取到的是协程号，如果是线程，取到的是线程号
        if ident in self.storage:

            # 此时参数k接收的是属性arg的字符串了 'arg'
            # 先判断线程号或协程号在不在storage对应的字典里，在就改小字典键对应的值
            # {  '协程id号':{'arg':1},'协程id号':{'arg':2},'协程id号':{'arg':3}   }
            self.storage[ident][k] = v
        else:
           # 不在就给storage字典添加一个 id号为键  值为一个小字典 的数据
            self.storage[ident] = {k: v}


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


obj = Local()


def task(i):
    obj.arg = i  # 注意对象点属性=值 触发__setattr__方法后，k接收的已经变成属性的字符串了！！！
    time.sleep(1)
    print(obj.arg , get_ident())



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


----------------------------------------------------------

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

1.3 偏函数

# 可以提前传值

# from functools import wraps   这个wraps方法 放在装饰器函数的内存函数上@wraps(func_name)
# 打印func_name名的__name__ 打印出来的就是该函数的真实名字！！


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

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

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

p_obj=partial(add,2)  # 和上面add(2, 3, 4)效果是一样的，只是它可以分步传值

# 干了很多事

print(p_obj(3,4))

.
.
.
.
.
.
.
.
.
.
.
.

1.4 flask 整个生命执行流程（ 以1.1.4版本为例 了解了解 有点难 ）

2.2.2版本源码有改动，在wsgi_app方法里的 ctx.push() 方法里面 有点不一样了，暂时没有研究

1.flask会根据请求的路径和请求方式调用相应的视图函数处理请求，
这些视图函数通常由@app.route()装饰器指定

2.当flask找到对应的视图函数时，会将请求对象作为参数传递给它，由视图函数进行处理，完成相关的业务

3.在视图函数中返回的响应对象会被封装成符合HTTP协议的数据格式，包括HTTP状态码，响应头和响应体等

4.在请求过程中，flask会为每个请求创建一个请求上下文对象，在请求处理完成后，请求上下文对象会被销毁

5.在flask初始化过程中，会创建一个应用上下文对象，用于保存flask应用的全局信息


6.在请求过程中，可以使用flask的中间件进行对请求或响应信息处理，
常用中间件包括Debug中间件、静态文件中间件等

.
.
.
.
.
.

from flask import Flask,request

app = Flask(__name__)

app.config['DEBUG'] = True


@app.route('/article')
def article( ):
    return 'hhh'


if __name__ == '__main__':
    app.run()  # 本质调用了 werzeug包下面的serving.py文件里的run_simple方法

    # from werkzeug.serving import run_simple
    # run_simple(t.cast(str, host), port, self, **options)
    # 运行该函数会执行 self()  就是app对象加括号  触发Flask类里面的双下call方法
    # def __call__(self, environ: dict, start_response):
    #     return self.wsgi_app(environ, start_response)
    # 本质就是在执行 self.wsgi_app(environ, start_response)  这是请求来了整个的入口
    # wsgi_app函数的返回值 response(environ, start_response)

---------------------------------

# 请求来了---》app()----->Flask.__call__--->self.wsgi_app(environ, start_response)

    # Flask类的2495行
    def wsgi_app(self, environ, start_response):

        # 下面这些代码是每一个请求从进来，到请求出去，整个flask的生命周期
        # 来一个请求，就会执行下面的代码，下面代码干了什么事？
        # 包装了请求对象request，执行了请求扩展，根据路由匹配视图函数
        # 执行视图函数，视图函数返回，整个过程结束
        # http请求，经过了符合wsgi协议的web服务器，才进入到了框架
        # web服务器将http请求的数据，组织成了一个environ字典，传到框架里面去了
        # ctx对象是 RequestContext类的对象，就是请求上下文对象！！！
      # 该对象里面有当次请求的request对象，app对象，当次请求的session对象，当次请求的flashes对象等
        # 这个类很重要，375行就是请求来了触发执行open_session方法的位置！！！

        ctx = self.request_context(environ)
      # 该函数的返回值 return RequestContext(self, environ)  触发了这个类生成对象赋值给ctx变量名
        # 在ctx.py文件里面，RequestContext类里面，308行，__init__方法中，
        # 判断request参数是否为None，为None就会触发 Request(environ)
        # 就把environ字典传到Request类的对象里面去了，request = app.request_class(environ)
        # 所以我们用的request对象，就是Request类拿environ字典的数据，实例化成的对象！！！
        # 所以http请求里的所有数据，都能从request对象里面取出来！！！

        error = None
        try:
            try:
                # 执行ctx RequestContext类 push方法
                # 最终 wsgi_app 函数里的ctx.push代码执行的结果就是把ctx对象放到了
                # 一个大字典里，该大字典里，用线程或协程号作为键 对应的小字典里面作为值
                # ctx对象就放在了小字典里面了！！！
                ctx.push()


                # 路由匹配成功后，执行视图函数
    # response = self.finalize_request(rv)  # 这个rv就是我们写的视图函数里面的返回值
    # finalize_request(rv)函数里面 response = self.make_response(rv)  最后又返回了response变量
    # 所以最后就是 response = make_response(rv)  视图函数的返回值传到make_response函数里并运行
    # make_response函数最后的返回值是  Response类传rv与headers等参数，实例化的对象
                response = self.full_dispatch_request()



            except Exception as e:
                error = e
                response = self.handle_exception(e)  # 执行过程有异常，执行异常处理函数
            except:
                error = sys.exc_info()[1]
                raise

            # 最后无论是否异常，都返回了response对象加括号
            return response(environ, start_response)
        finally:
            if self.should_ignore_error(error):
                error = None
            ctx.auto_pop(error)  # 请求结束执行 把ctx移除掉 ！！！！！！

--------------------------------------------------------------

# RequestContext :ctx.push

def push(self):
	# _request_ctx_stack = LocalStack()
	# ------》push(ctx对象)
    _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对象
class LocalStack:
    def __init__():
        self._local = Local()  # _local是Local类的对象,该对象可以根据线程协程区分数据

    def push(self, obj):
        rv = getattr(self._local, "stack", None)
        # _local对象一开始是空的，所以stack一开始没有值  所以rv 一开始是None

        if rv is None:
            rv = [ ]
            self._local.stack = rv
            # self._local.stack  根据不同线程用的是自己的数据
            # _local对象会点stack= rv 就会触发Local类里面的__setattr__方法
            # storage一开始是个空字典，
            # 然后判断线程号或协程号在不在字典里面，从而往里面放值或改值
            # self.storage[ident][k] = v      改值
            # self.storage[ident] = {k: v}    或放值
            # 就会把stack作为小字典的里面键，rv一开始是个空列表
            # 空列表里面又添加了ctx对象对象

        rv.append(obj)  # self._local.stack.append(obj)

        # 所以最终_local类对象里面的数据是如下这样的：
        # {  '线程id号'：{ 'stack'：[ctx] } , '线程id号2'：{ 'stack'：[ctx] }   }
        # ctx对象包含了当次请求的 requets对象，app对象，session对象等
        # 然后又把ctx对象，放到了用线程或协程号区分的小字典里面去了
        # 所以再回过头看 wsgi_app 函数里的ctx.push代码执行的结果就是把ctx对象放到了
        # 一个大字典里，并用线程或协程号作为键区分的小字典里，并且小字典里面以'stack'作为键
        return rv

--------------------------------------------------------------

.
.
.
.

# 再往后执行，就会进入到路由匹配，执行视图函数
	from flask import Flask,request
	# 全局导入的request是LocalProxy类的对象！！！

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


# 所以 print(request)   会执行LocalProxy类的__str__方法
                        __str__ = _ProxyLookup(str)   # 新版代码


# 所以 request.method 执行LocalProxy类的__getattr__方法
                       __getattr__ = _ProxyLookup(getattr)  # 新版代码
    def __getattr__(self, name): # name 是 method
        # self._get_current_object() 就是当次请求的request对象
        return getattr(self._get_current_object(), name)
        # 所以这句话最后获取的就是当次请求真正的request对象里面的method属性对应的值！！！


 # LocalProxy类的方法_get_current_object
   def _get_current_object(self):
        if not hasattr(self.__local, "__release_local__"):
            # 如果__local对象里面 没有 "__release_local__"字符串对应的属性名或方法名
            # 一开始__local对象里面是没有 该字符串对应的属性或方法名的，所以执行下面的代码

            # self.__local 是在LocalProxy类的__init__方法里面,放进去的

                # LocalProxy类的__init__里面
                # def __init__(self,local,name=None)
                    # object.__setattr__(self, "_LocalProxy__local", local)，
                    # local是LocalProxy类初始化传入的


            # local参数接收的就是LocalProxy类初始化传入的第一个数据
            # request = LocalProxy(partial(_lookup_req_object, "request"))
            # 所以 local就是  partial(_lookup_req_object, "request")  是偏函数


                # __local是隐藏属性
                # 所以在类外部要用该属性要通过_LocalProxy__local 才能拿到该隐藏的属性
                # 所以self.__local  取出的就是LocalProxy类初始化传入的值local
                # getattr(当次请求的reuqest, 'method')
            return self.__local()  # self中的 __local,是隐藏属性


            try:
                return getattr(self.__local, self.__name__)
                # 就是 getattr(_lookup_req_object('request'), 'method')
            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


# 总结：其实我们从from flask import Flask,request 导入的request对象
# 其实就是从 from .globals import request  导入的
# globals.py 文件里面的request就是LocalProxy类产生的对象！！！
# 但是这个对象在点属性获取值的时候，会触发LocalProxy类里面的__getattr__方法
# 然后self._get_current_object() 拿到当次请求真正的request对象
# 然后再通过反射获取，真正的request对象里面，反射字符串对应属性的值！！！


# globals.py 文件里面的request就是LocalProxy类产生的对象,是一个代理对象，类似于一个中介
# 它实际上不是真正的Request类产生的对象，但是它会去找真正的request对象拿数据
# 这就是设计模式里面的代理模式的应用
# 通过代理模式，不同请求通过代理对象（LocalProxy类产生的对象），就能拿到对应的当次请求的
# request对象与session对象！！！

.
.
.
.
.
.
.
.
.
.
.
.

有空再看看，有点东西的 ！！！

请求上下文执行流程（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()

        -3.2.3 方法的源码如下：
            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.4 _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.5 所以：print(request) 实质上是在打印当此请求的request对象的__str__


# 4 如果在视图函数中使用request对象，
        比如：print(request.method): 实质上是取到当次请求的reuquest对象的method属性

-------------------------------------------

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

其他的东西：
    -session:
        -请求来了open_session
            -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)

        -请求走了save_session
            -response = self.full_dispatch_request()
            方法内部：执行了  before_first_request，  before_request，  视图函数，
                                        after_request， save_session


         -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就是代理对象，用的就是代理模式

.
.
.
.
.
.
.
.
.
.
.
.

2 wtforms（了解）

--------------------------------------------------

# django 有forms组件
	- 生成前端模板
	- 校验数据
	- 渲染错误信息


# flask 中使用第三方的wtforms 实现像django的forms一样的功能
	- 第一步：导入，定义一个类，继承forms
	-第二步：模板中， for循环生成模板
	-第三步：视图函数中，使用form校验数据

--------------------------------------------------


# py代码
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()

# html代码
<!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>

.
.
.
.
.
.