Flaks框架(Flask请求响应，session，闪现，请求扩展，中间件，蓝图)

目录

• 一:Flask请求响应
  • 1.请求相关信息
  • 2.flask新手四件套
  • 3.响应相关信息（响应response增加数据返回）
• 二:session
  • 1.session与cookie简介
  • 2.在使用session之前必须现在设置一下密钥
  • 3.dajngo中session与Flask的session差别
  • 4.session使用
  • 5.set_cookie其他参数
  • 6.整体代码
• 三:源码分析SecureCookieSessionInterface
  • 1.f'lask框架session源码分析
  • 2.分析SecureCookieSessionInterface
  • 3.分析save_seesion响应与open_session请求来的时候
  • 4.整体代码
• 四:闪现
  • • 1.示例：
• 五:请求扩展
  • 1 before_request
  • 2 after_request
  • 3 before_first_request
  • 4 teardown_request
  • 5 errorhandler
  • 6 template_global
    • • 自定义标签
  • 7 template_filter
    • • 自定义过滤器
  • 8.总结：
• 六:中间件（了解）
• 蓝图
  • 1.使用步骤
  • 2.不使用蓝图，自己分文件
  • 3.使用蓝图之中小型系统
  • 4.使用蓝图之大型系统
• 七:flask 项目演示

一:Flask请求响应

# 导入模块
from flask import Flask,jsonify
from flask import views

from flask import Flask
from flask import request
from flask import render_template
from flask import redirect
from flask import make_response
app = Flask(__name__)
app.debug=True

@app.route('/login.html', methods=['GET', "POST"])
def login():

1.请求相关信息

request.method  				# 提交的方法
print(request.args.get('name'))   # get请求提交的数据---GET
print(request.form)               # post请求提交数据----POST
print(request.values)             # get和post的汇总
print(request.query_string)       # b'name=lqz&age=19'

request.args  # get请求提及的数据
request.form   # post请求提交的数据
request.values  # post和get提交的数据总和
request.cookies  # 客户端所带的cookie
request.headers  # 请求头
request.path     # 不带域名，请求路径
request.full_path  # 不带域名，带参数的请求路径
request.url           # 带域名带参数的请求路径
request.base_url		# 带域名请求路径
request.url_root      # 域名
request.host_url		# 域名
request.host			# 127.0.0.1:500
request.files          # 获取文件对象
obj = request.files['the_file_name']  # .files获取文件对象
obj.save('/var/www/uploads/' + secure_filename(f.filename))

2.flask新手四件套

return "字符串"
return render_template('html模板路径',**{})
return redirect('/index.html')
return jsonify({'k1':'v1'})  # 返回json格式

3.响应相关信息（响应response增加数据返回）

# 将render_template('index.html')生成对象，写到make_response对象内
response = make_response(render_template('index.html'))
response = make_response('hello')
# response是flask.wrappers.Response类型
response.delete_cookie('session')
response.set_cookie('name', 'lqz')
response.headers['X-Something'] = 'A value'
return response
# return "内容"

if __name__ == '__main__':
    app.run(port=8888)

二:session

1.session与cookie简介

cookie:存放在客户端的键值对
session：存放在客户端的键值对
token:存放在客户端，通过算法来校验

2.在使用session之前必须现在设置一下密钥

app.secret_key="asdas" #值随便

3.dajngo中session与Flask的session差别

# 1.在django中发什么三件事:
1，生成一个随机的字符串 2 往数据库存 3 写入cookie返回浏览器

# 2.在flask中没有数据库，但session是怎样实现的？
	1.生成一个密钥写入这个cookie,然后下次请求的时候，通过这个cookie解密，然后赋值给session

4.session使用

-增：session['name']=lqz
-查:session.get('name')
-删:session.pop('name')

5.set_cookie其他参数

key, 键
value='', 值
max_age=None, 超时时间 cookie需要延续的时间（以秒为单位）如果参数是\ None`` ，这个cookie会延续到浏览器关闭为止
expires=None, 超时时间(IE requires expires, so set it if hasn't been already.)
path='/', Cookie生效的路径，/ 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问，浏览器只会把cookie回传给带有该路径的页面，这样可以避免将cookie传给站点中的其他的应用。
domain=None, Cookie生效的域名 你可用这个参数来构造一个跨站cookie。如， domain=".example.com"所构造的cookie对下面这些站点都是可读的：www.example.com 、 www2.example.com 和an.other.sub.domain.example.com 。如果该参数设置为 None ，cookie只能由设置它的站点读取
secure=False, 浏览器将通过HTTPS来回传cookie
httponly=False 只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）

6.整体代码

from flask import Flask,jsonify
from flask import views

from flask import Flask,session
from flask import request
from flask import render_template
from flask import redirect
from flask import make_response
app = Flask(__name__)
app.debug=True
app.secret_key='sdfsdfsadfasdf'

app.session_interface

@app.route('/login.html', methods=['GET', "POST"])
def login():
    session['name']='lqz'
    response=make_response('hello')
    # response.set_cookie('name', 'lqz')
    return response

@app.route('/index', methods=['GET', "POST"])
def index():
    print(session.get('name'))
    return '我是首页'
if __name__ == '__main__':
    app.run(port=8080)

三:源码分析SecureCookieSessionInterface

1.f'lask框架session源码分析

2.分析SecureCookieSessionInterface

3.分析save_seesion响应与open_session请求来的时候

1.save_seesion
	-响应的时候，把session中的值加密序列化放大到了cookie中，返回到浏览器中  

# save_session
"""
# 将session设置成字典类型序列化转换成json字符串
val = self.get_signing_serializer(app).dumps(dict(session))
 # 1.响应对象内设置session
response.set_cookie(
	# 2.session的id
    app.session_cookie_name,
    # 3.session的value
    val,
    expires=expires,
)
"""

2.open_session
	-请求来了，从cookie中取出值，反解，生成session对象，以后再视图函数中直接用sessoin就可以了。

# open_session
"""
# 1.取出request.cookies中的value值
val = request.cookies.get(app.session_cookie_name)
# 2.将session的value值取出来反序列化
data = s.loads(val, max_age=max_age)
# 3.返回session(data)
return self.session_class(data)
"""

4.整体代码

from flask import Flask,jsonify
from flask import views

from flask import Flask,session
from flask import request
from flask import render_template
from flask import redirect
from flask import make_response
app = Flask(__name__)
app.debug=True
app.secret_key='sdfsdfsadfasdf'

app.session_interface

@app.route('/login.html', methods=['GET', "POST"])
def login():
    session['name']='lqz'
    response=make_response('hello')
    # response.set_cookie('name', 'lqz')
    return response

@app.route('/index', methods=['GET', "POST"])
def index():
    print(session.get('name'))
    return '我是首页'
if __name__ == '__main__':
    app.run(port=8080)

四:闪现

-设置:flash('aaa')
-取值：get_flashed_message()

-假设在a页面操作出错，跳转到b页面，在b页面显示a页面的错误信息

1.示例：

from flask import Flask,flash,get_flashed_messages,request,redirect

app = Flask(__name__)
app.secret_key = 'asdfasdf'

@app.route('/user', methods=['GET', "POST"])
def login():
    try:
        a=[1,2,3]
        print(a[9])
    except Exception as e:
        print(e)
    # 闪现普通使用(放在某个位置)
    flash(str(e))
    # 高级使用(闪现分类)
    flash('超时错误', category="x1")
    flash('xx错误', category="x3")
    return response

@app.route('/error', methods=['GET', "POST"])
def error():
    # 1.取出闪现(错误信息)
    errors=get_flashed_messages()
	# 2.取出闪现(高级使用分类)
    errors=get_flashed_messages(category_filter=['x1'])
    return render_template('error.html',errors=errors)

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

五:请求扩展

1 before_request

# 请求来了会先走before_request
1.类比django中间件中的process_request,写多个执行顺序是从上往下

#基于它做用户登录认证
@app.before_request
def process_request(*args,**kwargs):
    if request.path == '/login':
        return None
    user = session.get('user_info')
    if user:
        return None
    return redirect('/login')

2 after_request

# 从下往上，执行完了，响应走的时候执行
1.类比django中间件中的process_response，每一个请求之后绑定一个函数，如果请求没有异常

@app.after_request
def process_response1(response):
    print('process_response1 走了')
    return response

3 before_first_request

# 只会执行一次，程序启动以后，第一个访问的会触发，以后再也不会了
1.第一次请求时,跟浏览器无关

@app.before_first_request
def first():
    pass

4 teardown_request

# 不管当次请求是否出异常，都会执行，出了异常，e就是异常对象，debug=False模式下,必须在上线模式下，False
1.每一个请求之后绑定一个函数，即使遇到了异常

# 作用:日志记录，

@app.teardown_request
def ter(e):
    pass

5 errorhandler

# 只要是404错误，都会走它
1.路径不存在时404，服务器内部错误500

@app.errorhandler(404)
def error_404(arg):
    return "404错误了"

6 template_global

自定义标签

@app.template_global()
def sb(a1, a2):
    return a1 + a2
#{{sb(1,2)}}

7 template_filter

自定义过滤器

@app.template_filter()
def db(a1, a2, a3):
    return a1 + a2 + a3
#{{ 1|db(2,3)}}

8.总结：

1 重点掌握before_request和after_request，

2 注意有多个的情况，执行顺序

3 before_request请求拦截后（也就是有return值），response所有都执行

六:中间件（了解）

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello World!'
# 模拟中间件
class Md(object):
    def __init__(self,old_wsgi_app):
        self.old_wsgi_app = old_wsgi_app

    def __call__(self,  environ, start_response):
        print('开始之前')
        ret = self.old_wsgi_app(environ, start_response)
        print('结束之后')
        return ret

if __name__ == '__main__':
    #1我们发现当执行app.run方法的时候，最终执行run_simple，最后执行app(),也就是在执行app.__call__方法
    #2 在__call__里面，执行的是self.wsgi_app().那我们希望在执行他本身的wsgi之前做点事情。
    #3 所以我们先用Md类中__init__，保存之前的wsgi,然后我们用将app.wsgi转化成Md的对象。
    #4 那执行新的的app.wsgi_app，就是执行Md的__call__方法。
    #把原来的wsgi_app替换为自定义的，

    app.wsgi_app = Md(app.wsgi_app)
    app.run()

请求所有的流程

ctx = self.request_context(environ)
        error = None
        try:
            try:
                ctx.push()
                #根据路径去执行视图函数，视图类
                response = self.full_dispatch_request()
            except Exception as e:
                error = e
                response = self.handle_exception(e)
            except:  # noqa: B001
                error = sys.exc_info()[1]
                raise
            return response(environ, start_response)
        finally:
            #不管出不出异常，都会走这里
            if self.should_ignore_error(error):
                error = None
            ctx.auto_pop(error)

蓝图

对程序进行目录结构划分

1.使用步骤

1.实例化得到一个蓝图对象(可以指定直接的静态文件和模板路径)
2.在app中注册蓝图（可以指定前缀）
3.以后再写路由装饰器，使用蓝图对象的.route

2.不使用蓝图，自己分文件

目录结构：

-templates
-views
	-__init__.py
    -user.py
    -order.py
-app.py

app.py

from views import app
if __name__ == '__main__':
    app.run()

init.py

from flask import Flask,request
app = Flask(__name__)
#不导入这个不行
from . import account
from . import order
from . import user

user.py

from . import app
@app.route('/user')
def user():
    return 'user'

order.py

from . import app
@app.route('/order')
def order():
    return 'order'

3.使用蓝图之中小型系统

详见代码：pro_flask_简单应用程序目录示例.zip

目录结构：

-flask_pro
	-flask_test
    	-__init__.py
    	-static
        -templates
        -views
        	-order.py
            -user.py
     -manage.py 

_init.py

from flask import  Flask
app=Flask(__name__)
from flask_test.views import user
from flask_test.views import order
app.register_blueprint(user.us)
app.register_blueprint(order.ord)

manage.py

from flask_test import  app
if __name__ == '__main__':
    app.run(port=8008)

user.py

from flask import Blueprint
us=Blueprint('user',__name__)

@us.route('/login')
def login():
    return 'login'

order.py

from flask import Blueprint
ord=Blueprint('order',__name__)

@ord.route('/test')
def test():
    return 'order test'

4.使用蓝图之大型系统

详见代码：pro_flask_大型应用目录示例.zip

总结：

1 xxx = Blueprint('account', **name**,url_prefix='/xxx') ：蓝图URL前缀，表示url的前缀，在该蓝图下所有url都加前缀

2 xxx = Blueprint('account', name,url_prefix='/xxx',template_folder='tpls')：给当前蓝图单独使用templates，向上查找，当前找不到，会找总templates

3 蓝图的befort_request，对当前蓝图有效

4 大型项目，可以模拟出类似于django中app的概念

七:flask 项目演示

# 1 创建一个库movie
# 2 手动把表同步进去
	-modes.py,解开注释，右键执行

# 3 安装项目依赖
	-flask-sqlalchemy
    -flask_script
    -flask_redis
    -flask_wtf
# 4 命令行中运行
python3 manage.py runserver
# 5 后台管理中rbac控制