Flask二：路由,配置参数,蓝图,特殊装饰器

一：Flask 中路由系统

Flask中的路由系统其实我们并不陌生了,从一开始到现在都一直在应用

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

为什么要这么用?其中的工作原理我们知道多少?

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

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

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

strict_slashes : url地址结尾符"/"的控制 False : 无论结尾 "/" 是否存在均可以访问 , True : 结尾必须不能是 "/"

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


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

redirect_to : url地址重定向


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

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

subdomain : 子域名前缀 subdomian="DragonFire" 这样写可以得到 DragonFire.oldboyedu.com 前提是app.config["SERVER_NAME"] = "oldboyedu.com"


app.config["SERVER_NAME"] = "oldboy.com"

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

# 访问地址为:  DragonFire.oldboy.com/info

1.2：动态参数路由:

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 Old boy {nid}"  # Python3.6的新特性 f"{变量名}"


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

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

3.路由正则:

一般不用,如果有特殊需求,不怕麻烦的话,这个东西还是挺好用的,前提是你的正则玩儿的很6

二：实例化Flask的参数 及 对app的配置

Flask 是一个非常灵活且短小精干的web框架 , 那么灵活性从什么地方体现呢?

有一个神奇的东西叫 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中应该存在的,如果不再存在的话,它会默认无用,就这么放着

2.1：config参数

config中有多少有用的key 呢?

{
    'DEBUG': False,  
    # 是否开启Debug模式 
    # 编码阶段,代码重启,日志输出级别很低,页面中会显示错误,代码错误
    
    'TESTING': False,  
    # 是否开启测试模式   交给测试的时候打开
    # 日志输出级别较高,无线接近线上环境 ,错误不打印在页面上 不开debug模式就是test模式
    
    
    'PROPAGATE_EXCEPTIONS': None,  # 异常传播(是否在控制台打印LOG) 当Debug或者testing开启后,自动为True
    'PRESERVE_CONTEXT_ON_EXCEPTION': None,  # 一两句话说不清楚,一般不用它
    
    'SECRET_KEY': None,  # 之前遇到过,在启用Session的时候,一定要有它
    "PERMANENT_SESSION_LIFETIME": timedelta(days=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
    '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,
}

2.2：修改配置的方式

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

修改配置的方式大约是两种

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

app.config["DEBUG"] = True


2.使用类的方式导入

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

class FlaskSetting:
    DEBUG = True
    SECRET_KEY = "DragonFire"
然后我们在Flask的启动文件中就可以这么写

from flask import Flask


app = Flask(__name__)  # type:Flask
app.config.from_object("settings.FlaskSetting")
这叫做类导入配置

2.3：初始配置

这是针对一个已经实例化的app进行的配置

那么在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 目录

app = Flask(__name__)
template_folder="templatess" # 更改模板存放目录 默认值是 templates
static_folder="statics",	# 静态文件存放路径  默认值是 static
static_url_path="/static"   # 静态文件访问路径 - 默认是 "/"+static_folder
区分 static_folder 和 static_url_path 之间的关系



app = Flask(__name__,template_folder="templatess",static_folder="statics",static_url_path="/statics")
# 备注
# 模板文件名为 templatess
# 静态文件名为 statics
# HTML中的标签为 <img src="/statics/1.jpg">

#记住这些就好了,一般的项目中,只修改这些参数

三：蓝图(BluePrint)

3.1：core.py

from flask import Flask,redirect
from settings import DebugSetting
from settings import TestingSetting

# 从blue文件中导入以下三个蓝图
from blue.login import loginapp
from blue.student import studentapp
from blue.studentdetail import studentdetailapp

app = Flask(__name__)
app.config.from_object(DebugSetting)
# app.config.from_object(TestingSetting)

@app.errorhandler(404)
def error404(error_message):
    print(error_message)    
    return redirect("https://passport.lagou.com/lagouhtml/a44.html")

# 把导入的蓝图对象注册
app.register_blueprint(loginapp)
app.register_blueprint(studentapp)
app.register_blueprint(studentdetailapp)



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

3.2：blue文件

login.py

from flask import Blueprint, request, render_template, session, redirect

loginapp = Blueprint("loginapp", __name__)


@loginapp.before_request
def a():
    print("aaaaa")
    return None


@loginapp.route("/login", methods=["POST", "GET"])
def login():
    if request.method == "GET":
        return render_template("login.html")

    if request.method == "POST":
        username = request.form.get('username')
        password = request.form.get('pwd')
        if username == "123" and password == "456":
            session["username"] = username
            session["password"] = password
            return redirect("/student")
        else:
            return render_template("login.html")

student.py

from flask import Blueprint,request,render_template,session,redirect

studentapp = Blueprint("studentapp",__name__)

STUDENT_DICT = {
    1: {'name': 'Old', 'age': 38, 'gender': '中'},
    2: {'name': 'Boy', 'age': 73, 'gender': '男'},
    3: {'name': 'EDU', 'age': 84, 'gender': '女'},
}


@studentapp.route("/student/")
def student():
    return render_template("student.html",stu_info = STUDENT_DICT)

studentdetail.py

from flask import Blueprint,request,render_template,session,redirect

studentdetailapp = Blueprint("studentdetailapp",__name__)

STUDENT_DICT = {
    1: {'name': 'Old', 'age': 38, 'gender': '中'},
    2: {'name': 'Boy', 'age': 73, 'gender': '男'},
    3: {'name': 'EDU', 'age': 84, 'gender': '女'},
}


@studentdetailapp.route("/student/detail/<int:id>")
def student_detail(id):
    sid = id
    # id  = request.args.get('id')
    # stu_detail = STUDENT_DICT.get(int(id))
    stu_detail = STUDENT_DICT.get(int(sid))
    return render_template("student_detail.html",stu_detail=stu_detail,sid=sid)

3.3：templates文件

login.html

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>Title</title>

</head>
<body>
<form action="/login" method="post">
    用户名：<input type="text" name="username">
    密码：<input type="password" name="pwd">
    <input type="submit">
</form>


</body>
</html>

student.html

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>Title</title>

</head>
<body>
<table border="1px">
    <thead>
    <tr>
        <td>序号</td>
        <td>姓名</td>
        <td>点击详情</td>
    </tr>
    </thead>
    <tbody>
    {% for id,info in stu_info.items() %}
        <tr>
            <td>{{ id }}</td>
            <td>{{ info.name }}</td>
            <td><a href="/student/detail/{{ id }}">点击详情</a></td>
        </tr>

    {% endfor %}


    </tbody>

</table>


</body>
</html>

student_detail.html

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>Title</title>

</head>
<body>

<table border="1px">
    <thead>
    <tr>
        <td>序号</td>
        <td>姓名</td>
        <td>年龄</td>
        <td>性别</td>
    </tr>
    </thead>
    <tbody>


    {% if stu_detail %}
        <tr>
            <td>{{ sid }}</td>
            <td>{{ stu_detail.name }}</td>
            <td>{{ stu_detail.age }}</td>
            <td>{{ stu_detail.gender }}</td>
        </tr>

    {% endif %}


    </tbody>

</table>


</body>
</html>

3.4：settings.py

class DebugSetting(object):
    DEBUG = True
    SECRET_KEY = "WJJASNA787AS"
    SESSION_COOKIE_NAME = "I am debug session"


class TestingSetting(object):
    TESTING = True
    SECRET_KEY = "iuhasfiuhas"
    SESSION_COOKIE_NAME = "I am Not session"

3.Flask 蓝图 Blueprint
	当成是一个不能够被run的Flask对象
	蓝图中是不存在Config
	
	蓝图需要注册在 app 实例上的
	
	app.register_blueprint(Blueprint实例)

四：before_request 和 after_request

Flask我们已经学习很多基础知识了,现在有一个问题

我们现在有一个 Flask 程序其中有3个路由和视图函数,如下:
    
from flask import Flask

app = Flask(__name__)  # type:Flask


@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)

如果登陆了,就可以访问 index 和 home 页面,如果没登录就跳转到 login 登录

要怎么解决呢, session 对, 用 session 除了 Login 函数之外的所有函数里面全校验 session 是否登录了

太麻烦了,现在咱们只有3个函数,如果成百上千个怎么整啊

装饰器,对没错,装饰器是一个很好的方案,但是啊,我现在还是成败上千个函数,我要在每一个函数定义的时候加上@装饰器,还是很麻烦

那么就引出了我们要学习的第一个知识点:

4.1：@app.before_request

1.@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 = "DragonFire"


@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 也是一个装饰器,他所装饰的函数,都会在请求进入视图函数之前执行

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

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

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

4.2：@app.after_request

2. @app.after_request 在响应(response)返回客户端之前执行 , 结束视图函数之后

@app.after_request
def foot_log(environ):
    if request.path != "/login":
        print("有客人访问了",request.path)
    return environ

#很少应用,但是要了解有这么个东西

4.Flask 特殊装饰器
	1.before_request 请求进入进入视图函数之前进行处理 return None 继续执行 否则阻断
	2.after_request 视图函数结束 响应客户端之前
	正常周期: be1 - be2 - be3 - vf - af3 - af2 - af1
	异常周期: be1 - af3 - af2 - af1