Flask之session,路由,配置,蓝图, before/after

Flask内的session

Flask中的session会将sessionID存放在客户端的Cookie中

1. Flask中的session是急需要secret_key的

from flask import session
app = Flask(__name__)
app.secret_key = "自定义字符串"

　　secret_key实际上是用来加密字符串的, 如果在实例化的app中内有secret_key, 在开启session一定会抛异常的.

2. session基本使用

@app.route("/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        if request.form["username"] == USER["username"] and request.form["password"] == USER["password"]:
            session["user"] = USER["username"]
            return redirect("/student_list")
        return render_template("login.html", msg="用户名密码错误")

    return render_template("login.html", msg=None)  # 如果前端Jinja2模板中使用了msg,这里就算是传递None也要出现msg

　　session["user"] = USER["username"] 代表这个请求带上来的session中保存了一个user=name

　　如果想要验证session的话, 可以使用这种方法.

3. cookies中的session

　　cookie中的session存储的是通过secret_key加密后的key, 通过这个key从flask程序的内存中找到

4. 使用session进行验证.

@app.route("/student_list")
def student():
    if session.get("user"):
        return render_template("student_list.html", student=STUDENT_DICT)

    return redirect("/login")

Flask中的路由系统

路由 : @app.route("/",methods=["GET","POST"])

1. @app.route() 装饰器中的参数

　　methods : 当前 url 地址,允许访问的请求方式

@app.route("/info", methods=["GET", "POST"])
def student_info():
    stu_id = int(request.args["id"])
    return f"Hello boy {stu_id}"  # Python3.6的新特性 f"{变量名}"

　　endpoint : 反向url地址,默认为视图函数名 (url_for)

from flask import url_for


@app.route("/info", methods=["GET", "POST"], endpoint="r_info")
def student_info():
    print(url_for("r_info"))  # /info
    stu_id = int(request.args["id"])
    return f"Hello boy {stu_id}"  # Python3.6的新特性 f"{变量名}"

　　defaults : 视图函数的参数默认值{"nid":1}

from flask import url_for


@app.route("/info", methods=["GET", "POST"], endpoint="r_info", defaults={"nid": 100})
def student_info(nid):
    print(url_for("r_info"))  # /info
    # stu_id = int(request.args["id"])
    print(nid)  # 100
    return f"Hello boy {nid}"  # Python3.6的新特性 f"{变量名}"
---------------------------------------------------------------------------
<int:nid> 只能接受数字或者数字+字符串两种类型的nid参数, 接受纯字符串类型或报错
<string:nid> 可以接受数字或者数字+字符串或者字符串类型的参数
<nid> 默认相当于<string:nid>

　　strict_slashes : url地址结尾符"/"的控制

　　False : 无论结尾 "/" 是否存在均可以访问 ,

　　True : 结尾必须不能是 "/"

# 访问地址 : /info 
@app.route("/info", strict_slashes=True)
def student_info():
    return "Hello boy info"


# 访问地址 : /infos  or  /infos/
@app.route("/infos", strict_slashes=False)
def student_infos():
    return "Hello boy infos"

　　redirect_to : url地址重定向

# 访问地址 : /info 浏览器跳转至 /infos
@app.route("/info", strict_slashes=True, redirect_to="/infos")
def student_info():
    return "Hello boy info"

@app.route("/infos", strict_slashes=False)
def student_infos():
    return "Hello boy infos"

　　subdomain : 子域名前缀 subdomian="car" 这样写可以得到 https://car.autohome.com.cn

　　前提是app.config["SERVER_NAME"] = "autohome.com.cn"

app.config["SERVER_NAME"] = "autohome.com.cn"

@app.route("/info",subdomain="car")
def student_info():
    return "Hello boy info"

# 访问地址为:  autohome.com.cn

　　动态路由参数 :

from flask import url_for


# 访问地址 : http://127.0.0.1:5000/info/1
@app.route("/info/<int:nid>", methods=["GET", "POST"], endpoint="r_info")
def student_info(nid):
    print(url_for("r_info",nid=2))  # /info/2
    return f"Hello boy {nid}"  # Python3.6的新特性 f"{变量名}"
-----------------------------------------------------------------------

<int:nid> 就是在url后定义一个参数接收

但是这种动态参数路由,在url_for的时候,一定要将动态参数名+参数值添加进去,否则会抛出参数错误的异常

Flask中app的配置

Flask之所以很灵活, 有一个原因是因为Flask的配置很多

from flask import Flask

app = Flask(__name__)  # type:Flask
app.config["DEBUG"] = True

　　app.config["DEBUG"] = True 表示只要代码发生改变, 自动重启Flask程序(app.run)

　　也就是DEBUG模式(调试模式)

Flask的配置就是在app.config中添加一个键值对, 但是存进去的键必须是config中应该存在的,如果不再存在的话,它会默认无用,就这么放着

config中可以更改的键值对如下 :

{
    'DEBUG': False,  # 是否开启Debug模式
    'TESTING': False,  # 是否开启测试模式
    'PROPAGATE_EXCEPTIONS': None,  # 异常传播(是否在控制台打印LOG) 当Debug或者testing开启后,自动为True
    'PRESERVE_CONTEXT_ON_EXCEPTION': None,  # 一两句话说不清楚,一般不用它
    'SECRET_KEY': None,  # 之前遇到过,在启用Session的时候,一定要有它
    'PERMANENT_SESSION_LIFETIME': 31,  # days , Session的生命周期(天)默认31天
    'USE_X_SENDFILE': False,  # 是否弃用 x_sendfile
    'LOGGER_NAME': None,  # 日志记录器的名称
    'LOGGER_HANDLER_POLICY': 'always',
    'SERVER_NAME': None,  # 服务访问域名
    'APPLICATION_ROOT': None,  # 项目的完整路径
    'SESSION_COOKIE_NAME': 'session',  # 在cookies中存放session加密字符串的名字
    'SESSION_COOKIE_DOMAIN': None,  # 在哪个域名下会产生session记录在cookies中
    'SESSION_COOKIE_PATH': None,  # cookies的路径
    'SESSION_COOKIE_HTTPONLY': True,  # 控制 cookie 是否应被设置 httponly 的标志，
    'SESSION_COOKIE_SECURE': False,  # 控制 cookie 是否应被设置安全标志
    'SESSION_REFRESH_EACH_REQUEST': True,  # 这个标志控制永久会话如何刷新
    'MAX_CONTENT_LENGTH': None,  # 如果设置为字节数， Flask 会拒绝内容长度大于此值的请求进入，并返回一个 413 状态码
    'SEND_FILE_MAX_AGE_DEFAULT': 12,  # hours 默认缓存控制的最大期限
    'TRAP_BAD_REQUEST_ERRORS': False,
    # 如果这个值被设置为 True ，Flask不会执行 HTTP 异常的错误处理，而是像对待其它异常一样，
    # 通过异常栈让它冒泡地抛出。这对于需要找出 HTTP 异常源头的可怕调试情形是有用的。
    'TRAP_HTTP_EXCEPTIONS': False,
    # Werkzeug 处理请求中的特定数据的内部数据结构会抛出同样也是“错误的请求”异常的特殊的 key errors 。
    # 同样地，为了保持一致，许多操作可以显式地抛出 BadRequest 异常。
    # 因为在调试中，你希望准确地找出异常的原因，这个设置用于在这些情形下调试。
    # 如果这个值被设置为 True ，你只会得到常规的回溯。
    'EXPLAIN_TEMPLATE_LOADING': False,
    'PREFERRED_URL_SCHEME': 'http',  # 生成URL的时候如果没有可用的 URL 模式话将使用这个值
    'JSON_AS_ASCII': True,
    # 默认情况下 Flask 使用 ascii 编码来序列化对象。如果这个值被设置为 False ，
    # Flask不会将其编码为 ASCII，并且按原样输出，返回它的 unicode 字符串。
    # 比如 jsonfiy 会自动地采用 utf-8 来编码它然后才进行传输。
    'JSON_SORT_KEYS': True,
    #默认情况下 Flask 按照 JSON 对象的键的顺序来序来序列化它。
    # 这样做是为了确保键的顺序不会受到字典的哈希种子的影响，从而返回的值每次都是一致的，不会造成无用的额外 HTTP 缓存。
    # 你可以通过修改这个配置的值来覆盖默认的操作。但这是不被推荐的做法因为这个默认的行为可能会给你在性能的代价上带来改善。
    'JSONIFY_PRETTYPRINT_REGULAR': True,
    'JSONIFY_MIMETYPE': 'application/json',
    'TEMPLATES_AUTO_RELOAD': None,
}

　　以上这些Key,都可以被改写,当然他们也都是有默认值存在的,如果没有特殊情况,不要改写它的默认值

修改配置的方式大概为两种 :

　　1. 直接对app.config进行修改

app.config["DEBUG"] = True

　　2.使用类的方式导入

　　　　首先要有一个settings.py的文件

class FlaskSetting:
    DEBUG = True
    SECRET_KEY = "xd"

然后再Flask的启动文件内使用 :

from flask import Flask


app = Flask(__name__)  # type:Flask
app.config.from_object("settings.FlaskSetting")

　　这是类导入配置

Flask的实例化配置

在Flask实例化的时候, 传递的参数究竟是什么呢

其实可以理解为对Flask实例进行的初始配置,这里面的参数是非常好理解

static_folder = 'static',  # 静态文件目录的路径 默认当前项目中的static目录
static_host = None,  # 远程静态文件所用的Host地址,默认为空
static_url_path = None,  # 静态文件目录的url路径 默认不写是与static_folder同名,远程静态文件时复用
# host_matching是否开启host主机位匹配,是要与static_host一起使用,如果配置了static_host, 则必须赋值为True
# 这里要说明一下,@app.route("/",host="localhost:5000") 就必须要这样写
# host="localhost:5000" 如果主机头不是 localhost:5000 则无法通过当前的路由
host_matching = False,  # 如果不是特别需要的话,慎用,否则所有的route 都需要host=""的参数
subdomain_matching = False,  # 理论上来说是用来限制SERVER_NAME子域名的,但是目前还没有感觉出来区别在哪里
template_folder = 'templates'  # template模板目录, 默认当前项目中的 templates 目录
instance_path = None,  # 指向另一个Flask实例的路径
instance_relative_config = False  # 是否加载另一个实例的配置
root_path = None  # 主模块所在的目录的绝对路径,默认项目目录

我们常用的参数有 :

static_folder = 'static',  # 静态文件目录的路径 默认当前项目中的static目录
static_url_path = None,  # 静态文件目录访问的url路径 默认不写是与static_folder同名,远程静态文件时复用
template_folder = 'templates'  # template模板目录, 默认当前项目中的 templates 目录

Flask中的蓝图

Flask中的蓝图是很宏伟的, 主要作用就是将功能和主服务分开

1. 创建一个项目然后将目录结构做成 :

　　s_view.py文件中的内容:

from flask import Blueprint  # 导入 Flask 中的蓝图 Blueprint 模块

sv = Blueprint("sv", __name__)  # 实例化一个蓝图(Blueprint)对象


@sv.route("/svlist")  # 这里添加路由和视图函数的时候与在Flask对象中添加是一样的
def view_list():
    return "svlist_view_list"

　　manager.py 文件中的内容

from flask import Flask

# 导入此前写好的蓝图模块
from student_view import s_view

app = Flask(__name__)  # type:Flask

# 在Flask对象中注册蓝图模块中的蓝图对象 s_view 中的 sv
app.register_blueprint(s_view.sv)

app.run("0.0.0.0",5000)
# 现在Flask对象中并没有写任何的路由和视图函数

　　开启服务, 访问http://127.0.0.1:5000/svlist 返回结果 : svlist_view_list

　　没有在Flask是实例化对象中添加路由, 但是注册了有路由的视图函数和sv蓝图对象, 却可以访问svlist

2. 蓝图理解

其实我们可以理解成一个没有run方法的Flask对象

蓝图实例化时候传递的参数 :

from flask import Blueprint  # 导入 Flask 中的蓝图 Blueprint 模块
from flask import render_template

sv = Blueprint("sv",
               __name__,
               template_folder="sv_template",  # 每个蓝图都可以为自己独立出一套template模板文件夹,如果不写则共享项目目录中的templates
               static_folder="sv_static"  # 静态文件目录也是可以独立出来的
               url_prefix = "/user"    # url路由的前缀(即在访问下面的路由前面加上前缀路由)
               )  # 实例化一个蓝图(Blueprint)对象


@sv.route("/svlist")
def view_list():
    return render_template("svlist.html")

Flask中的before_request和after_request(类似于django的中间件)

在Flask中如果有很多很多的视图函数, 一部分需要登陆之后才允许访问, 这个问题要怎么解决?

　　1. 使用session校验　　(额, 要多写n*n的代码)

　　2. 装饰器校验　　(每一个函数定义时都要@装饰器)

　　3. @app.before_request

@app.before_request 在请求(request)之前做出响应

from flask import Flask
from flask import request
from flask import redirect
from flask import session

app = Flask(__name__)  # type:Flask
app.secret_key = "xd"


@app.before_request
def is_login():
    if request.path == "/login":
        return None

    if not session.get("user"):
        return redirect("/login")


@app.route("/login")
def login():
    return "Login"


@app.route("/index")
def index():
    return "Index"


@app.route("/home")
def home():
    return "Login"


app.run("0.0.0.0", 5000)
-------------------------------------------------------
请求进入视图函数之前执行

在有多个@app.before_request的时候, 执行顺序和由上到下的定义顺序相同

　　@app.before_request 也是一个装饰器,他所装饰的函数,都会在请求进入视图函数之前执行

　　request.path 是来读取当前的url地址如果是 /login 就允许直接通过 return None 你可以理解成通过放行

　　校验session中是否有user 如果没有的话,证明没有登录,所以毫不留情的 redirect("/login") 跳转登录页面

　　还有一个要提的 @app.before_first_request 它与 @app.before_request 极为相似或者说是一模一样,只不过它只会被执行一次

@app.after_request 在响应(response)之前做出响应

@app.after_request
def foot_log(environ):
    if request.path != "/login":
        print("有客人访问了",request.path)
    return environ
---------------------------------------------------------
结束视图函数之后, 返回客户端之前响应
在有多个@app.after_request的时候, 执行顺序和由上到下的定义顺序相反
无论@app.before_request执行几个,@app.after_request都会执行

Flask之session,路由,配置,蓝图, before/after_request

推荐阅读