Flask 框架 （上）

配置文件

默认配置

flask支持多种方式进行配置项的新增和修改，默认配置项如下。同 django框架大差不差

{        '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,
}

配置项的加载与使用

from  flask import Flask,jsonifyapp=Flask(__name__)# 方式一：直接配置--->能够配的参数少
app.secret_key='asdfasdf'   # secret_key 用来加密解密的密钥 
app.debug=True 			# 修改了代码，只需要保存，自动热加载# 方式二：通过app.config字典，配置，这个字典中放了所有的配置
app.config['DEBUG']=False # 都要大写
app.config['MYSQL_HOST'] = '127.0.0.1'# 方式三：通过settings.py 配置文件--->用得少，django 框架的使用方式
app.config.from_pyfile("settings.py")# 方式四：通过类来加载对象
class Config(object):DEBUG = FalseTESTING = FalseDATABASE_URI = 'sqlite://:memory:'app.config.from_object("Config")# 方式五：通过加载json格式配置文件
app.config.from_json("settings.json")# 方式六：通过环境变量配置
app.config.from_envvar("环境变量名称")# 方式七：服务(项目)多了，配置文件多了---》配置中心 nacos 阿波罗
m={}
m=request.get('url')  # m的值是dict类型 
app.config.from_mapping(m)

路由系统

demo

@app.route('/detail/<int:nid>',methods=['GET'],endpoint='detail')

路由本质

django 中的路由在 urls.py 文件中进行管理 flask 中路由基于装饰器进行管理。实际上，无论是在django 还是 flask 中，只要你愿意，咋样都行

flask 注册路由的两种方式
1. @app.router('/')  推荐使用def index():...2. app.add_url_rule('/', view_func=index)app.router()--->本质上就是self.add_url_rule，self就是flask对象app  

CBV写法

在flask 中，cbv 可以选择继承 View (django 继承的是View) 和 MethodView 两个类

如果继承 View 类，需要重写 dispatch 方法

如果继承 MethodView 类，直接写 get , post 方法即可

class HomeView(MethodView):methods = ['GET']   # 允许请求方式decorators = [auth, ]  # 加载装饰器def get(self):print(request.path)return 'cbv的homeview'
# 添加路由
# name 是路由别名，跟endpoint一个作用，但是cbv必须传name  也可将路由的加载放在类中
app.add_url_rule('/home',view_func=HomeView.as_view(name='home'))

路由的参数

# app.add_url_rule的参数
1 rule, URL规则,  可以使用转换器 <int:pk>2 endpoint, 当前路由的别名，如果不传， 默认已函数名作为endpoint，如果函数名重名，就会有两个	重名的地址，报错,主要用来反向解析源码:  endpoint = _endpoint_from_view_func(view_func)用于反向生成URL，即： url_for('名称')  # url_for 通过 endpoint 的值反向解析出 url多个视图函数，如果加同一个装饰器，如果不写endpoint，就会报错 3 view_func, 视图函数名称 如果是cbv  视图类.as_view(name='xx')4 defaults = None, 默认值, 当URL中无参数，函数需要参数时，使用defaults = {'k': 'v'}
为函数提供参数,就是django中的kwargs5 methods = None, 允许的请求方式，如：["GET", "POST"]6 strict_slashes = None
对URL最后的 / 符号是否严格要求7 redirect_to = None,   redirect_to='/home'
#重定向到指定地址8 子域名访问
subdomain = None, 

请求与响应

请求

# http请求中有的东西，都能取出来
print(request.method)
# request.method  提交的方法
# request.args  get请求提及的数据
print(request.args)
# request.form   post请求提交的数据
print(request.form)
# request.values  post和get提交的数据总和
print(request.values)
# request.cookies  客户端所带的cookie
print(request.cookies)
# request.headers  请求头
print(request.headers)
# request.path     不带域名，请求路径
print(request.path)
# request.full_path  不带域名，带参数的请求路径
print(request.full_path)
# request.url           带域名带参数的请求路径
print(request.url)
# request.base_url		带域名请求路径
# request.url_root      域名
# request.host_url		域名
# request.host			127.0.0.1:500
print(request.host)  
# request.files    接受文件
obj = request.files['the_file_name']
obj.save('/var/www/uploads/' + secure_filename(f.filename))

响应

# 4 件套
return "字符串"  # 放回字符串
return render_template('html模板路径',**{})   # 返回html文件
return redirect('/index.html')    # 重定向
return jsonify({'k1':'v1'})		# json 格式字符串	# 响应头中加东西,四件套都可以使用make_response包裹成响应对象，等同于django中的HTTPResponse
res=make_response('字符串')
res.headers['name']='yxh'
return res# 设置cookie
response = make_response('字符串')
response.set_cookie('key', 'value')
return response

session

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

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

app.secret_key="asdas" # 值随便写

除请求对象之外，还有一个 session 对象。它允许你在不同请求间存储特定用户的信息。它是在 Cookies 的基础上实现的，并且对 Cookies 进行密钥签名要使用会话，你需要设置一个密钥。 (app.session_interface对象)

设置：session['username'] ＝ 'xxx'
# 在django中发什么三件事，1，生成一个随机的字符串 2 往数据库存 3 写入cookie返回浏览器
# 在flask中他没有数据库，但session是怎样实现的？# 生成一个密钥写入这个cookie,然后下次请求的时候，通过这个cookie解密，然后赋值给session# 我们通过app.session_interface来查看删除：session.pop('username', None)

app.session_interface中save_session的参数（设置cookie的参数）

源码:response.set_cookie(name,val,  # type: ignoreexpires=expires,httponly=httponly,domain=domain,path=path,secure=secure,samesite=samesite,)name, 键
val , 值
expires=None, 超时时间(IE requires expires, so set it if hasn't been already.)
httponly=False 只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）domain=None, Cookie生效的域名 你可用这个参数来构造一个跨站cookie。如， domain=".example.com"所构造的cookie对下面这些站点都是可读的：www.example.com 、 www2.example.com 和an.other.sub.domain.example.com 。如果该参数设置为 None ，cookie只能由设置它的站点读取                
path='/', Cookie生效的路径，/ 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问，浏览器只会把cookie回传给带有该路径的页面，这样可以避免将cookie传给站点中的其他的应用。
secure=False, 浏览器将通过HTTPS来回传cookie
samesite=None  将cookie的范围限制为仅附加到“相同站点”的请求

session源码的执行流程

处理session，有个一个类SecureCookieSessionInterface()，有俩重要方法 
-save_seesion1 把sesion对象，当字典 转成字符串，使用秘钥加密 val = self.get_signing_serializer(app).dumps(dict(session))2 写入cookie返回浏览器 session=加密的字符串response.set_cookie(app.session_cookie_name,val, # 加密字符串 )
-open_session1 根据sessionid取出加密字符串val = request.cookies.get(app.session_cookie_name)2 通过秘钥解密，组装成 sessiondata = s.loads(val, max_age=max_age)self.session_class(data)3 在视图函数中才能正常使用session['name']取值，赋值，删除值可以自定义一个类SecureCookieSessionInterface，重写open_session和save_session，把session存到数据库，redis里	

闪现（django 中 message）

-设置: flash('aaa')
-取值：get_flashed_message()
-
-假设在a页面操作出错，跳转到b页面，在b页面显示a页面的错误信息# 本质：
如果在同一次请求中，放到request对象中即可
如果在不同请求中，放到session中，所以使用闪现一定配置秘钥# 使用
设置：flash('诱惑美女')
获取：res=get_flashed_messages()# 高级使用  按分类设置和获取
设置：
flash('诱惑美女',category='man')
flash('诱惑帅哥',category='wonmen')
获取：
res=get_flashed_messages(with_categories=True，category_filter=["man"])

demo

@app.route('/index')
def index():# 从某个地方获取设置过的所有值，并清除。val = request.args.get('v')if val == 'oldboy':return 'Hello World!'flash('超时错误',category="x1")return "ssdsdsdfsd"# return redirect('/error')@app.route('/error')
def error():"""展示错误信息:return:如果get_flashed_messages(with_category=True)"""data = get_flashed_messages(category_filter=['x1'])if data:msg = data[0]else:msg = "..."return "错误信息：%s" %(msg,)if __name__ == '__main__':app.run()

请求扩展

和django中间件差不多的玩意，但是可以通过蓝图定义给部分接口使用

1 before_request
类比django中间件中的process_request，在请求收到之前绑定一个函数做一些事情# 基于它做用户登录认证
@app.before_request
def process_request(*args,**kwargs):if request.path == '/login':return Noneuser = session.get('user_info')if user:return Nonereturn redirect('/login')2 after_request
类比django中间件中的process_response，每一个请求之后绑定一个函数，如果请求没有异常@app.after_request
def process_response1(response):print('process_response1 走了')return response3 before_first_request
第一次请求时,跟浏览器无关@app.before_first_request
def first():pass4 teardown_request
每一个请求之后绑定一个函数，即使遇到了异常@app.teardown_request 
def ter(e):pass
5 errorhandler
路径不存在时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)}}总结：1 重点掌握before_request和after_request，2 注意有多个的情况，执行顺序3 before_request请求拦截后（也就是有return值），response所有都执行

flask 中间件

flask 中间件 和 before_request 和 after_request 实现效果类似。

from flask import Flaskapp = Flask(__name__)@app.route('/')
def index():return 'Hello World!'# 模拟中间件
class Md(object):def __init__(self,old_wsgi_app):self.old_wsgi_app = old_wsgi_appdef __call__(self,  environ, start_response):print('开始之前')  ret = self.old_wsgi_app(environ, start_response)print('结束之后')return retif __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()

蓝图

视图是一个应用对请求进行响应的函数。 Flask 通过模型把进来的请求 URL 匹配到 对应的处理视图。视图返回数据， Flask 把数据变成出去的响应。 Flask 也可以反 过来，根据视图的名称和参数生成 URL 。

简单点说就是对 不同 app进行路由管理，当前蓝图下的请求扩展只对当前蓝图有效。

# 第一步：定义蓝图对象
user = Blueprint('user', __name__)
# 第二步：使用蓝图写路径，写请求扩展(只针对于当前蓝图生效)
@user.route('/index')
# 第三步：把蓝图注册进app中
app.register_blueprint(user)

使用蓝图结构案例

目录结构：

-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'

总结：

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的概念

g对象

g对象 是global的缩写，类似于 django 框架中的 request.context 属性。目的都是为了在不污染 request 对象前提下，实现在同一个请求中，传递数据,上下文传递，赋值取值只针对于当次请求生效。

from flask import g# 设置值
g.name = "yxh"
# 取值
name = g.name  
name = g.get("name")--------
from flask import Flask, gapp = Flask(__name__)def test_g():print(g.get('name', None))g.name = '李四'@app.route('/test')
def test():g.name = '张三'test_g()  # 控制台会打印'张三'print(g.name)  # 李四return 'test'if __name__ == '__main__':app.run()

g对象和session的区别

session对象是可以跨request的，只要session还未失效，不同的request的请求会获取到同一个session，但是g对象不是，g对象不需要管过期时间，请求一次就g对象就改变了一次，或者重新赋值了一次