python Flask web框架

目录:

--> Flask
　　--> 配置文件
　　　　--> 配置文件解析
　　　　--> 配置文件导入

　　--> 路由
　　　　--> 路由参数
　　　　--> 常用路由匹配

　　--> 请求相关 & 响应
　　　　--> request 参数
　　　　--> response 参数
　　　　--> 打包模板和参数

　　--> 模板 jinja2
　　　　--> 模板导入/继承
　　　　--> 前段/后端 安全渲染
　　　　--> 前段自定义函数 macro
　　　　--> 后端自定义前段函数
　　　　　　--> @app.template_global()
　　　　　　--> @app.template_filter()

　　--> 请求扩展
　　　　--> @app.before_first_request
　　　　--> @app.before_request
　　　　--> @app.after_request

　　--> 错误页面自定制

　　--> 闪现
　　--> 蓝图
　　--> 中间件
　　--> 信号
　　--> 上下文管理
　　　　--> threading.local
　　　　--> 请求上下文(requestContext)
　　　　　　--> request
　　　　　　--> session
　　　　--> 应用上下文:AppContext
　　　　　　--> app(current_app)
　　　　　　--> g
　　　　--> 实现细节
　　　　　　--> 利用threading.local 的线程 唯一ID标识符
　　　　　　--> requestcontext对象通过localstack添加到Local 栈中
　　　　　　--> 导入request(session、current_app、g)是localproxy -> 偏函数 ->Localstack -> Local
　　　　　　--> requestcontext的auto_pop -> localstaack.pop ->local中移除
　　　　--> 多app应用
　　　　--> 技术点:LocalProxy、chain,偏函数
　　　　--> 中间件/信号 执行顺序

falsk 配置文件解析

{
    'DEBUG':                                get_debug_flag(default=False),  是否开启Debug模式
    'TESTING':                              False,                          是否开启测试模式
    'PROPAGATE_EXCEPTIONS':                 None,
    'PRESERVE_CONTEXT_ON_EXCEPTION':        None,
    'SECRET_KEY':                           None,
    'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),
    'USE_X_SENDFILE':                       False,
    'LOGGER_NAME':                          None,
    'LOGGER_HANDLER_POLICY':               'always',
    'SERVER_NAME':                          None,
    'APPLICATION_ROOT':                     None,
    'SESSION_COOKIE_NAME':                  'session',
    'SESSION_COOKIE_DOMAIN':                None,
    'SESSION_COOKIE_PATH':                  None,
    'SESSION_COOKIE_HTTPONLY':              True,
    'SESSION_COOKIE_SECURE':                False,
    'SESSION_REFRESH_EACH_REQUEST':         True,
    'MAX_CONTENT_LENGTH':                   None,
    'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),
    'TRAP_BAD_REQUEST_ERRORS':              False,
    'TRAP_HTTP_EXCEPTIONS':                 False,
    'EXPLAIN_TEMPLATE_LOADING':             False,
    'PREFERRED_URL_SCHEME':                 'http',
    'JSON_AS_ASCII':                        True,
    'JSON_SORT_KEYS':                       True,
    'JSONIFY_PRETTYPRINT_REGULAR':          True,
    'JSONIFY_MIMETYPE':                     'application/json',
    'TEMPLATES_AUTO_RELOAD':                None,
}

falsk 配置文件导入:

# flask 配置文件介绍：
# 方式一：
# Session, Cookies以及一些第三方扩展都会用到SECRET_KEY值
# app.config['SECRET_KEY'] = '123456'
# app.config['DEBUG'] = True
 
# 方式二：(只有部分可以如此操作)
# app.secret_key = '123456'
 
# 方式三：(导入配置文件的方式)
# app.config.from_pyfile('setting.py')
 
# 方式四：（推荐方式：在配置文件中写一个类，将配置写在类里面，再导入）
app.config.from_object('setting.Text')

方式四 setting文件

# 共有的
class Config(object):
    SECRET_KEY = ''
    DEBUG = False
 
class Text(Config):
    DEBUG = True
    SECRET_KEY = 'abcd'

路由参数

# 路由系统:
# 基于装饰器来实现,但是究其本质是通过下面函数实现的
# app.add_url_rule(rule='/路径',endpoint='别名',view_func='视图函数',methods='访问的类型/["GET","POST"]')
 
# CBV 的flask 方式:
# from flask import views
# 配置视图
# class Text(views.MethodView):
#     methods = ['GET','POST']
#     # 登录装饰器
#     # decorators = [login_required,]
#
#     def get(self):
#         return 'Text_Class_get'
#
#     def post(self):
#         return 'Text_Class,post'
#
# 配置路由
# app.add_url_rule(rule='/text/',view_func=Text.as_view(name='text'))
 
# app.add_url_rule 和 app.route
# 参数:
# rule: url 规则
# view_func 视图函数名称
# defaults=None 默认值,当url中没有参数
# endpoint=None 反向生成url,不能重名,在使用装饰器时,没有导入@wraps(func)则需要区分
# methods=None 允许的请求方式,如:['GET','POST']
# strict_slashes=None 对URL最后的 / 符号是否严格要求
# redirect_to=None 重定向地址
# subdomain=None 子域名访问,需要配合域名使用

常用路由匹配方式

# 常用路由方式:
# @app.route('/user/<username>')
# @app.route('/user/<int:post_id>')
# @app.route('/user/<float:post_id>')
# @app.route('/user/<path:PATH>')
# @app.route('/user/',methods=['GET','POST'])

请求相关 & 响应

request

# request
# request.method
# request.args
# request.form
# request.values
# request.cookies
# request.headers
# request.path
# request.full_path
# request.script_root
# request.url
# request.base_url
# request.url_root
# request.host_url
# request.host
 
# request.files
# obj = request=files['the_file_name']
# obj.save('/var/www/uploads'+secure_filename(f.filename))

response

# response
# return "字符串"
# render_templates('html模板',返回参数)
# return redirect('/index.html')
 
# 打包模板和参数
# response = make_response(render_template("index.html"))
# response 是flask.wrappers.Response类型
# response.delete_cookie("key")
# response.set_cookie("key",'value')
# response.headers['X-something'] = 'A value'
# return response

模板 jinja2

# 模板:(模板也支持导入,继承)
# 跟 django 都是使用的jinja2 模板
# 前段 安全渲染 {func | safe }
# 后端 安全渲染  import Markup 函数
 
# # 新增功能
# {% macro 自定义函数名(参数,参数N) %}
#     <span>{{参数}}---{{参数n}}</span>
#     <span>{{参数}}---{{参数n}}</span>
#     <span>{{参数}}---{{参数n}}</span>
# {% endmacro%}
#
# # 调用上面的函数
# {{自定义函数(参数)}}
 
# ------------
 
# 模板内自定义函数(类似django simple_tag)
# @app.template_global()
# def sb(a1,a2):
#     return a1 + a2
 
# 模板中使用方法:
# {{sb(1,2)}}
 
# ------------
# 后端自定义前段函数
# @app.template_filter()
# def sb2(a1,a2,a3):
#     return a1 + a2 + a3
 
# 模板中使用方法:
# {{1|sb2(2,3)}}
 
# url_for('参数')  参数指向的书 views 视图中的函数名,而不是路由名

请求扩展

# 请求扩展 (django中的中间件)
 
# 第一次访问执行:
# @app.before_first_request
# def first(*args,**kwargs)
#     pass
 
# # 先进后出
# @app.before_request
# def preocess_request(*args,**kwargs):
#     # 这里可以做登录认证
#     print('request_1')
#
# @app.before_request
# def preocess_request2(*args,**kwargs):
#     # 这里可以做登录认证
#     print('request_2')
#
# @app.after_request
# def preocess_response(response):
#     print('response_1')
#     return response
#
# @app.after_request
# def preocess_response2(response):
#     print('response_2')
#     return response

错误页面自定制

# # 错误页面 自定制
#
# @app.errorhandler(404)
# def error_404(arg):
#     return "页面不存在!"

闪现

# # 闪现 : 临时数据操作 如:显示错误信息
# from flask import flash,get_flashed_messages
#
# @app.route('/get')
# def get():
#     data = get_flashed_messages()
#     # data = get_flashed_messages(category_filter=['l1']) 分类取数据
#     print(data)
#     return "get"
#
# @app.route('/set')
# def set():
#     flash('aaaaaa')
#     # flash('aaaaaa',category='l1') #可以数据分类
#     return "set"

上下文管理

# 上下文管理:
# 1.知道flask 依赖的组件: WSGI、jinja2、Werkzeug,flask 框架是组装件的粘合剂
# client --- wsgi -----flask --- jinja2 ----werkzeug
# 2.flask 用threading.local 做了一个Local对象 存放请求信息
 
# 引入步骤:
# Flask()实例化 -> 将请求数据传入Flask实例 -> 将数据push 至 _request_ctx_stack,_request_ctx_stack实质是 LocalStack()
# LocalStack() 初始化时 又实例化了 Local() ,local初始化 最终以类似列表的方式 保存object.__setattr__(self, '__storage__', {})
 
# 请求到来:
#   --ctx = 封装requestContext(request,ssision)
#   --ctx放进Local中
# 执行视图时
#   --导入request
#   --request   ---> LocalProxy对象中 __getattr__获取对应的请求
#       ---调用 _lookup_req_object函数:去local 中酱requestcontext 将获取到,再去requestcontext中获取request或session
# 请求结束
#   --ctx.auto_pop()
#   --ctx从local中移除
 
# --> 上下文管理
#       --> threading.local
# --> 请求上下文(requestContext)
#       --> request
#       --> session
# --> 应用上下文: AppContext
#       --> app(current_app)
#       --> g
# --> 实现细节
#       --> 利用threading.local的线程唯一ID标识符
#       --> requestcontext对象通过localstack添加到Local栈中
#       --> 导入request(session、current_app、g)是localproxy -> 偏函数 ->Localstack -> Local
#       --> requestcontext的auto_pop -> localstaack.pop ->local中移除

信号

# # 示例一:(自定义信号)
# from flask.signals import _signals
#
# xinhao = _signals.signal('before-render-template')#创建信号
#
# #定义函数
# def wahaha(*args,**kwargs):
#     print("111",args,kwargs)
#
# # 将函数注册到信号中,添加到这个列表
# xinhao.connect(wahaha)
#
# @app.route("/zzz")
# def zzz():
#     # 信号是通过send 方法 出发的!!!!!!!!!
#     xinhao.send(sender='xxx',a1=123,a2=456)  #触发这个信号，执行注册到这个信号列表中的所有函数,此处的参数个数需要与定义的函数中的参数一致
#     print("ok")
#     return "OK"
 
# ---------------------------------------------------------------
 
# # 示例二:(内置信号使用)
# from flask.signals import _signals
#
# bf = _signals.signal('before-render-template')
# bf2 = _signals.signal('template-rendered')
#
# def text(*args,**kwargs):
#     print("111")
#
# bf.connect(text)
# bf2.connect(text)

信号与中间件的执行顺序

# 信号 依赖于 blinker 模块 (信号只执行记录,并不能中断流程,而中间件可以中断)
# pip install blinker
 
# 内置信号 以及执行顺序:
# --> a 中间件:before_first_request
# --->1 appcontext_pushed = _signals.signal('appcontext-pushed')  # 请求app上下文push时执行
# --->2 request_started = _signals.signal('request-started')  # 请求到来前执行
 
# --> b 中间件:before_request
# --->3 before_render_template = _signals.signal('before-render-template')  # 模板渲染前执行
# --->4.template_rendered = _signals.signal('template-rendered')  # 模板渲染后执行
 
# --> c 中间件:after_request
# -->   session.save_session()
# --->5 request_finished = _signals.signal('request-finished')  # 请求结束后执行
# --->6.request_tearing_down = _signals.signal('request-tearing-down')  # 请求执行完毕后自动执行（无论成功与否）
 
# --->7.appcontext_tearing_down = _signals.signal('appcontext-tearing-down')  # 请求上下文执行完毕后自动执行（无论成功与否）
# --->8.appcontext_popped = _signals.signal('appcontext-popped')  # 请求上下文pop时执行
 
# 发生在2 / 3 / 4 / 5或不执行
# got_request_exception = _signals.signal('got-request-exception')  # 请求执行出现异常时执行
 
# message_flashed = _signals.signal('message-flashed')  # 调用flask在其中添加数据时，自动触发

多APP 应用

# 多APP 应用
# web 访问多app应用时,上下文管理是如何实现的?
 
# from werkzeug.wsgi import DispatcherMiddleware
# from werkzeug.serving import run_simple
#
# app01 = Flask('app01')
# app02 = Flask('app02')
#
# @app01.route('/index')
# def app01_index():
#     return "app01"
#
# @app02.route('/index')
# def app02_index():
#     return "app02"
#
# app = DispatcherMiddleware(app01,{
#     '/app02前缀':app02,
# })
#
# if __name__=="__main__":
#     run_simple('localhost',8002,app)

session 相关

#&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
# 使用session 前 必须配置SECRET_KEY!!!
# session 操作:(session就相当于是一个字典!)
# session['类型'] = 值
# session.pop['类型']
# del session['类型']
#&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

session 第三方组件(自定制session保存位置)

# flask session 机制
'''
->请求刚进来:获取随机字符串,存在,则去容器 中获取原来的个人数据,否则创建一个空的容器
    ->对象(随机字符串,{请求数据})
->视图:读取内存中对象
->响应:内存对象 将对象数据保存到数据库(没有指定数据库的话 保存在内存中),把随机字符串写到用户cookie中
'''
# 使用 方式一
# flask-session 组件
# from flask_session import Session
# import pymongo
#
# app.config['SESSION_TYPE'] = 'mongodb'  # session类型为redis
#
# app.config['SESSION_MONGODB'] = pymongo.MongoClient('localhost',27017)
# app.config['SESSION_MONGODB_DB'] = 'text'
# app.config['SESSION_MONGODB_COLLECT'] = 'col'
#
# app.config['SESSION_PERMANENT'] = True  # 如果设置为True，则关闭浏览器session就失效。
# app.config['SESSION_USE_SIGNER'] = False  # 是否对发送到浏览器上session的cookie值进行加密
# app.config['SESSION_KEY_PREFIX'] = 'session:'  # 保存到session中的值的前缀
#
# Session(app)
 
# 使用 方式二
 
# from flask_session import MongoDBSessionInterface
# app.session_interface = MongoDBSessionInterface("参数!")

一些问答

# &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
# 问题1 多线程时如何体现的?
# 问题2 flask的local 中保存数据时,使用列表创建出来的栈,为什么用栈?
#       --如果写web程序,web运行环境,栈中永远保存1条数据(可以不用栈)
#       --写脚本获取app信息,可能存在app上下文嵌套关系
 
'''
from  flask import Flask,current_app,globals,_app_ctx_stack
 
app1=Flask('app01')
app1.debug = False
 
app2=Flask('app02')
app2.debug = False
 
with app1.app_context():
    print(_app_ctx_stack._local.__storage__)
    print(current_app.config['DEBUG'])
 
    with app2.app_context():
    print(_app_ctx_stack._local.__storage__)
    print(current_app.config['DEBUG'])
 
'''
# &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

flask 实现装饰器方式:引入(wraps)

from functools import wraps
# flask 实现登录装饰器的功能
def login_required(func):
    @wraps(func)
    # @wraps(view_func)的作用:     不改变使用装饰器原有函数的结构(如__name__, __doc__)
    # 不使用wraps可能出现的ERROR:   view_func...endpoint...map...
    def wrapper(*args,**kwargs):
        if session.get('user'):
            return func(*args,**kwargs)
        else:
            return redirect('/')
    return wrapper
 
# 装饰器实现的方式：
@app.route('/index/',methods=['GET'])
@login_required                                         # flask 登录装饰器
def index():
    return render_template('index.html',u_list=data)
 
@app.route("/detail/<int:id>",methods=['GET'])
def detail(id):
    return str(id)