1.Flask配置文件

# session.py session源码
class SecureCookieSessionInterface(SessionInterface):
    
    #;应该应用于密钥顶部的salt,(加盐)
    #;对基于cookie的session进行签名。
    salt = ;cookie-session;
    
    #;用于签名的哈希函数。默认值为sha1
    digest_method = staticmethod(hashlib.sha1)
    
    #;其危险支持的密钥派生的名称。默认值 is hmac.
    key_derivation = ;hmac;
    #;有效负载的python序列化程序。默认为紧凑型
    #;JSON派生的序列化程序;支持一些额外的Python类型
    #;例如datetime对象或元组。
    
    # session的json序列化程序
    serializer = session_json_serializer
    # session对象
    session_class = SecureCookieSession
	
    # 生成签名
    def get_signing_serializer(
        self, app: ;Flask;
    ) -> t.Optional[URLSafeTimedSerializer]:
        # 判断secret_ket 是否配置
        if not app.secret_key:
            return None
        # 签名关键字参数 = dict(密钥派生的名称, 签名方式)
        signer_kwargs = dict(
            key_derivation=self.key_derivation, digest_method=self.digest_method
        )
        # 序列化方法(secret_key, 盐, 序列化方法, 签名关键字参数)得到session签名 
        return URLSafeTimedSerializer(
            app.secret_key,
            salt=self.salt,
            serializer=self.serializer,
            signer_kwargs=signer_kwargs,
        )

    # cookie转session
    def open_session(
        self, app: ;Flask;, request: ;Request;
    ) -> t.Optional[SecureCookieSession]:
        # s = 签名方法
        s = self.get_signing_serializer(app)
        # 判断签名方法是或为空
        if s is None:
            return None
        # val = SESSION_COOKIE_NAME 的配置信息, 默认为session, 去cookie中找键为session的值
        val = request.cookies.get(self.get_cookie_name(app))
        # 如果没有session, 则返回空的session对象 (为了后续使用session是session对象, 而不是None)
        if not val:
            return self.session_class()
        # 超时时间 默认为31天, 将31天转为以秒为单位
        max_age = int(app.permanent_session_lifetime.total_seconds())
        # 序列化器的load方法, 将cookie中保存的session签名转为不可变字典的session
        try: 
            data = s.loads(val, max_age=max_age)
            return self.session_class(data)
        # 错误签名(签名过期, cookie被改...) 返回一个空的session对象
        except BadSignature:
            return self.session_class()
	
    # session转cookie
    def save_session(
        self, app: ;Flask;, session: SessionMixin, response: ;Response;
    ) -> None:
        # 获取一个配置信息, 用于设置cookie的
        name = self.get_cookie_name(app)
        domain = self.get_cookie_domain(app)
        path = self.get_cookie_path(app)
        secure = self.get_cookie_secure(app)
        samesite = self.get_cookie_samesite(app)
        httponly = self.get_cookie_httponly(app)

        # 如果会话修改为空;请删除cookie。
        # 如果会话为空;则返回而不设置cookie。
        ;;;
        session 为空 modified的值为True时触发, 将cookie的信息删除
        modified是一个标准位, 为session设置值之后 modified的值为True
        删除session session.pop()  session为空时 modified的值为True 清除掉cookie
        ;;;
        if not session:
            if session.modified:
                response.delete_cookie(
                    name,
                    domain=domain,
                    path=path,
                    secure=secure,
                    samesite=samesite,
                    httponly=httponly,
                )

            return

        # 如果会话被访问;则添加“Vary:Cookie”头。
        if session.accessed:
            response.vary.add(;Cookie;)
		
        # 是否设置cookie
        if not self.should_set_cookie(app, session):
            return
        
	    # 获取时间
        expires = self.get_expiration_time(app, session)
        #  序列化器的dumps方法将session加密得到签名
        val = self.get_signing_serializer(app).dumps(dict(session))  # type: ignore
        response.set_cookie(
            name,
            val,  # type: ignore
            expires=expires,
            httponly=httponly,
            domain=domain,
            path=path,
            secure=secure,
            samesite=samesite,
        )

如果自定义session的存放方式, 继承SessionInterface重写几个方法即可.
在为app.session_interface属性设置为自定义类的对象即可.

保存session的时候会调用save_session, 
将session加密得到签名(不可变字典->字符串), 将签名存放到cookie中(session:签名字符串).

访问页面的时候从cookie中取出加签名字符串, 反解得到不可变字典.

Flask的闪现功能将数据存入session中, 可以在不同的视图函数中多次存储, 获取一次之后就会删除session中的数据.

存储:
falsh[;value;]

取所有值:
get_flashed_messages()

from flask import Flask, flash, get_flashed_messages

app = Flask(__name__)

# 闪现是基于session实现的, 所以要设secret_key参数
app.secret_key = ;asd;


;app.route(;/set_flash1;)
def set_flash1():
    flash(;hello;)
    return ;set_session;


;app.route(;/set_flash2;)
def set_flash2():
    flash(;world!;)
    return ;set_session;


;app.route(;/get_flash1;)
def get_flash1():
    # 获取所以的flash 中存储的数据
    print(get_flashed_messages())
    return ;get_session;


;app.route(;/get_flash2;)
def get_flash2():
    # 获取所以的flash 中存储的数据
    print(get_flashed_messages())
    return ;get_session;


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

测试: 
先访问 set_flash1	flash(;hello;) 将hello保存到session中.
再访问 set_flash1	flash(;world!;) 将world!保存到session中.
再访问 get_flash1  get_flashed_messages() 获取保存到session中的信息
再访问 get_flash2  get_flashed_messages() 已经被获取过后信息被清除了, 得到一个空列表.

分类存储:
falsh[;value;, category=;分类名;]

按分类取值:
get_flashed_messages(category_filter=;分类名;)
get_flashed_messages(category_filter=[;分类名;])

from flask import Flask, flash, get_flashed_messages

app = Flask(__name__)

# 闪现是基于session实现的, 所以要设secret_key参数
app.secret_key = ;asd;


;app.route(;/set_flash1;)
def set_flash1():
    flash(;hello;, category=;t1;)
    return ;set_session;


;app.route(;/set_flash2;)
def set_flash2():
    flash(;world!;, category=;t2;)
    return ;set_session;


;app.route(;/get_flash1;)
def get_flash1():
    # 获取所以的flash 中存储的数据
    print(get_flashed_messages(category_filter=;t1;))
    return ;get_session;


;app.route(;/get_flash2;)
def get_flash2():
    # 获取所以的flash 中存储的数据
    print(get_flashed_messages(category_filter=;t2;))
    return ;get_session;


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

测试: 
先访问 set_flash1	flash(;hello;) 将hello保存到session中, 分类为t1.
再访问 set_flash1	flash(;world!;) 将world!保存到session中, 分类为t2.
再访问 get_flash1  get_flashed_messages(category_filter=;t1;) 获取保存到session中的t1分类的信息.
再访问 get_flash2  get_flashed_messages(category_filter=;t2;) 已经被获取过后所有信息被清除了, 得到一个空列表.

请求拓展类似Django的中间件, 请求前, 请求后, 执行什么操作. 
基于装饰器实现, 绑定一个函数执行一些操作.

请求来时就会触发, 类似django的process_request.
有返回值, 一般为None, 如果直接返回response对象, 直接返回. 不往后执行.

;app.beform_requesr
def process_request(*args, **kwargs) 
	...

请求走时就会触发, 类似django的process_response.

;app.after_request
def process_response(*args, **kwargs)
	...

请求的执行顺序, 先执行before_request, 再执行视图函数, 最后执行after_request.

from flask import Flask, session, request, redirect

app = Flask(__name__)

# 参数设置
app.debug = True
app.secret_key = ;asd;


;app.before_request
def process_request(*args, **kwargs):
    # 再不知道是否有参数的时候先使用 *args, **kwargs
    print(*args, **kwargs)  # 空的什么都没有

    # 判断访问的路径, 访问login不做处理, 其他的路径都需要处理
    if request.path == ;/login;:
        return None

    # 没有session都重定向到登入页面
    if not session.get(;name;):
        # 重定向, 会想返回响应, 再由浏览器发送请求, 会先执行app.after_request 
        return redirect(;/login;)


;app.after_request  # 需要接收response对象
def process_response(response):
    # 访问index主页面的时候做处理
    if request.path == ;/index;:
        # Response对象 , from flask import Response, Response继承ResponseBase, ResponseBase中有一些方法
        print(response)  # <Response 14 bytes [200 OK]>  index主页面 英文5 ; 中文3*3 9 = 14bytes

        # 判断session中是否有值, 有则删除
        if session.get(;name;):
            session.pop(;name;)

    # 将response 返回
    return response


# 登入
;app.route(;/login;)
def login():
    session[;name;] = ;kid;
    return ;登入成功!;


# index主页面
;app.route(;/index;)
def index():
    return ;index主页面;


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

测试:
先访问 index, (这个时候session中没有值.)

第一步:
访问来时执行process_request函数, 对访问地址进行判断, 如果是;/login;直接放行, 
不是则从请求中获取session, session有值则放行, 否则重定向到登入页面. --> session没有值, 执行重定向.
第二步:
重定向时, 先经过process_response含, 对访问地址进行判断, 如果是;/index; , 判断session中是否有值, 如果有则清除.
第三步:
浏览器向服务端重新发送请求, 访问到;/login;, 先执行process_request函数, --> 放行
第四步:
执行login函数, 保存session. 返回;登入成功;, 再经过process_response, --> 放行

再次访问 index, (这个时候session中有值.)
第一步:
访问来时执行process_request函数,  session有值, --> 放行
第二步:
执行index函数, 返回;index主页面; 主页面, 再进过process_response, session中有值, 则将session值删除

在before_request中直接返回response对象, 会执行所有响应不会执行视图函数.

from flask import Flask, make_response

app = Flask(__name__)


;app.before_request
def ip_filter():
    # xx操作
    res = make_response(;你的访问被限制!;)
    # 直接返回response对象, 会执行所有响应不会执行视图函数
    return res


;app.after_request
def after1(response):
    print(;请求走了1!;)
    return response


# 执行同级别的 响应
;app.after_request
def after2(response):
    print(;请求走了2!;)
    return response


;app.route(;/;)
def index():
    return ;index;


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

before_request 从上往下执行, 
after_request  重下往上执行.

from flask import Flask
app = Flask(__name__)

# 参数设置
app.debug = True


;app.before_request
def process_request1(*args, **kwargs):
    print(1)


;app.before_request
def process_request2(*args, **kwargs):
    print(2)


;app.after_request  # 需要接收response对象
def process_response1(response):
    print(5)
    return response


;app.after_request  # 需要接收response对象
def process_response2(response):
    print(4)
    return response


# 登入
;app.route(;/;)
def index():
    print(3)
    return ;登入成功!;


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

终端显示:
1 
2
3
4
5

第一次请求时, 跟浏览器无关.
这个是django中没有的. 仅再项目启动时, 接收到第一次请求时触发, 与浏览器和用户无关.
如果写多个, 会将函数名存到一个列表中依次执行.
使用场景: 项目初始化.

;app.beffore_first_request
def first():
	pass

teardown_request注册一个在每个请求结束时要调用的函数, 无论该函数成功还是引发异常.
使用场景: 记录错误日志, 清理请求作用域对象(如数据库会话/事务)

from flask import Flask

app = Flask(__name__)

# 参数设置
app.debug = True


# 请求走时触发
;app.after_request
def process_request(response):
    print(;执行了process_request;)
    return response


# 所有请求结束时触发
;app.teardown_request
def teardown(e):
    print(;执行了teardown_request;)


# 主页面
;app.route(;/;)
def index():
    print(;index;)
    return ;index主页面;

# order页面
;app.route(;/order;)
def order():
    print(;order1;)
    # 设置一个错误
    a
    print(;order2;)
    return ;order页面;


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

测试:
访问根目录, 先执行 index函数, 再执行process_request函数, 最后执行teardown_request函数.
再次访问;/order;, 先执行index函数, 打印;order1;, 报错..., 报错前执行teardown_request函数.

出现异常的时候触发, 可以根据状态码触发对应的处理函数.

;app.errorhandler(400)
def error_400():
    pass

写一个函数, 处理所有的404响应状态码.
* 1. templates 下新建error.html页面

<!-- error.html页面 -->
<!DOCTYPE html>
<html lang=;en;>
<head>
    <meta charset=;UTF-8;>
    <title>Title</title>
</head>
<body>
{{ error_msg }}
</body>
</html>

* 2. 404状态码处理函数

from flask import Flask, render_template

app = Flask(__name__)

# 参数设置, debug模式不要开始否则不会触发errorhandler(500)
app.debug = False


;app.errorhandler(404)
def error_404(e):  # 需要接收错误信息
    # 404 Not Found: The requested URL was not found on the server. ...
    print(e)
    return render_template(;error.html;, error_msg=;404错误页面;)

;app.errorhandler(500)
def error_500(e):  # 需要接收错误信息
    # NameError: name ;a; is not defined
    print(e)
    return render_template(;error.html;, error_msg=;500错误页面;)

;app.route(;/;)
def index():
    # 触发服务器500错误
    a
    return ;index;

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

* 3. 测试: 
访问所有不存在的路由, 会返回404, 返回时,  触发errorhandler(404).
访问根路径, 会返回500, 返回时, 触发errorhandler(500).

;app.template_global() 全局标签再后端定义, 前端模板页面任何位置中可以调用.

from flask import Flask, render_template

app = Flask(__name__)


# 定义全局标签
;app.template_global()
def num_add(x, y):
    return x ; y


;app.route(;/;)
def index():
    return render_template(;index.html;)


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

<!DOCTYPE html>
<html lang=;en;>
<head>
    <meta charset=;UTF-8;>
    <title>Title</title>
</head>
<body>
<!-- 再模块页面中使用 -->
{{ num_add(1, 2) }}
</body>
</html>

;app.template_filter 全局标签再后端定义, 前端模板页面任何位置中可以调用.
* 注意传递参数的方式.

from flask import Flask, render_template

app = Flask(__name__)


;app.template_filter()
def num_add(x, y, z):
    return x ; y ; z


;app.route(;/;)
def index():
    return render_template(;index.html;)


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

<!DOCTYPE html>
<html lang=;en;>
<head>
    <meta charset=;UTF-8;>
    <title>Title</title>
</head>
<body>
<!--第一个参数再 |函数名 前面-->
{{ 1|num_add(2, 3) }}
</body>
</html>