Flask路由&视图

1 路由

 1.1app.url_map 查看所有路由

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    """定义视图函数"""
    print(app.url_map)
    return "hello flask"

@app.route('/index')
def index():
    return 'index'

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

访问127.0.0.1 ：5000

显示当前所有的路由，和每条路由的访问方式。

1.2通过method限定访问方式

给index函数添加method

@app.route('/index', methods=["post"])
def index():
    return 'index'

此时去浏览器在地址栏输入地址访问，

很显然，不让get请求，给method列表中添加get请求方式。

@app.route('/index', methods=["post", 'get'])
def index():
    return 'index'

此时就能get和post请求

1.3同一路由装饰多个视图函数

添加两个视图函数

@app.route('/test')
def test1():
    return "test1"

@app.route("/test")
def test2():
    return "test2"

在浏览器访问127.0.0.1:5000/test,返回的是test1.

修改两个函数的请求方式

@app.route('/test', methods=["post"])
def test1():
    return "test1"

@app.route("/test", methods=["get"])
def test2():
    return "test2"

再去浏览器访问127.0.0.1:5000/test,返回的是test2

1.4同一视图多个路由装饰器

添加一个func视图函数

@app.route("/func1")
@app.route("/func2")
def func():
    return "func"

在浏览器访问127.0.0.1:5000/func1和 127.0.0.1:5000/func2，返回的结果都是func。

1.5 使用url_for进行反解析

添加一个login视图函数

from flask import Flask, redirect, url_for

@app.route("/login")
def login():
    url = url_for("index")      # 使用url_for，通过视图函数的名字找到视图对应url
    return redirect(url)

访问127.0.0.1:5000/login，然后就会直接跳转到index页面。

1.6 动态路由

# 路由传递的参数默认当做string处理，这里指定int，尖括号中冒号后面的内容是动态的
@app.route('/book/<int:book_id>')
def book_detail(book_id):
    return "book detail %s" % book_id

# 路由传递的参数默认当做string处理，这里指定int，尖括号中冒号后面的内容是动态的
# @app.route('/book/<int:book_id>')
@app.route('/book/<book_id>')   # 不加转换器类型，默认时普通字符串规则，除了 / 字符
def book_detail(book_id):
    return "book detail %s" % book_id

1.7 自定义转换器

from werkzeug.routing import BaseConverter

# 1.定义自己的转换器
class RegexConverter(BaseConverter):

    def __init__(self, url_map, regex):
        # 调用父类的初始化方法
        super().__init__(url_map)
        # 将正则表达式的参数保存到对象的属性中， flask会去使用这个属性来进行路由的正则匹配
        self.regex = regex

# 2.将自定义的转换器添加到flask的应用中
app.url_map.converters["re"] = RegexConverter

# 127.0.0.1:5000/send/178456123789
@app.route("/send/<re(r'1[34578]\d{9}'):mobile>")
def send_msg(mobile):
    return "send_msg---To:%s" % mobile

1.8 转换器转换过程

自定义的转换器RegexConverter添加两个方法，他们都是父类BaseConverter的方法，现在看下他们其实是在做什么。

to_python

# 1.定义自己的转换器
class RegexConverter(BaseConverter):

    def __init__(self, url_map, regex):
        # 调用父类的初始化方法
        super().__init__(url_map)
        # 将正则表达式的参数保存到对象的属性中， flask会去使用这个属性来进行路由的正则匹配
        self.regex = regex

    def to_python(self, value):
        print(value)
        return 123

    def to_url(self, value):
        pass

# 2.将自定义的转换器添加到flask的应用中
app.url_map.converters["re"] = RegexConverter

# 127.0.0.1:5000/send/178456123789
@app.route("/send/<re(r'1[34578]\d{9}'):mobile>")
def send_msg(mobile):
    return "send_msg---To:%s" % mobile

在浏览器访问http://127.0.0.1:5000/send/17845678912，页面显示

控制台属输出17845678912。转换过程：

to_url

class RegexConverter(BaseConverter):

    def __init__(self, url_map, regex):
        # 调用父类的初始化方法
        super().__init__(url_map)
        # 将正则表达式的参数保存到对象的属性中， flask会去使用这个属性来进行路由的正则匹配
        self.regex = regex

    def to_python(self, value):
        # print(value)
        # value是在路径进行正则表达式匹配的时候提取的参数
        # return 123
        return value

    def to_url(self, value):
        print(value)
        return ""

# 2.将自定义的转换器添加到flask的应用中
app.url_map.converters["re"] = RegexConverter

# 127.0.0.1:5000/send/178456123789
@app.route("/send/<re(r'1[34578]\d{9}'):mobile>")
def send_msg(mobile):
    return "send_msg---To:%s" % mobile

@app.route("/index")
def index():
    url = url_for("send_msg", mobile="")
    return redirect(url)

访问http://127.0.0.1:5000/index, 页面显示：

控制台输出：18732141231， 转换过程：

to_url是在使用url_for方法的时候被调用。

2 获取请求参数

from flask import request

就是 Flask 中表示当前请求的 request 对象，request对象中保存了一次HTTP请求的一切信息。

from flask import Flask, request

app = Flask(__name__)

@app.route("/index", methods=["get", 'post'])
def index():
    # request中包含了前端发送过来的所有请求数据
    # form和data是用来提取请求体数据
    # 通过request.form可以直接提取请求体中的表单格式的数据， 是一个类字典的对象
    # 通过get方法只能拿到多个同名参数的第一个
    name = request.form.get("name")
    age = request.form.get("age")
    # getlist可以获取同名的所有数据
    name_list = request.form.getlist("name")
    print("request.data", request.data)     # 发送json数据

    # 127.0.0.1:5000/index?page=1 查询字符串 QueryString
    # args使用提取url中的参数(查询字符串)
    page = request.args.get("page")
    print(page)
    return "%s:%s,,%s" % (name, age, name_list)

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

2.1 上传文件 

已上传的文件存储在内存或是文件系统中一个临时的位置。你可以通过请求对象的 files 属性访问它们。每个上传的文件都会存储在这个字典里。它表现近乎为一个标准的 Python file 对象，但它还有一个 save() 方法，这个方法允许你把文件保存到服务器的文件系统上。这里是一个用它保存文件的例子:

@app.route("/upload", methods=['post'])
def upload():
    # 接收前端发送过来的文件
    file_obj = request.files.get("pic")
    # if file_obj is None:
    #     return "未上传文件"
    # # 将文件保存到本地
    # # 1.创建一个文件对象
    # f = open('./test.png', 'wb')
    # # 2.向文件写内容
    # content = file_obj.read()
    # f.write(content)
    # # 3.关闭文件
    # f.close()

    # 直接使用上传文件的对象保存
    file_obj.save("./test1.png")
    return "上传成功"

3 abort函数与自定义异常处理

3.1 abort函数

from flask import abort

@app.route("/login", methods=['get'])
def login():
    name = "hhh"
    pwd = ''
    if name != "aaa" or pwd != 123:
        # 使用abort函数可以立即终止视图函数的执行， 并可以返回了浏览器特定的信息
        # 1.传递状态码信息， 必须是标准的http状态码
        abort(404)
        # 2.传递响应体信息
        # res = Response("login failed")
        # abort(res)
    return "login success"

3.2 自定义异常处理

@app.errorhandler(404)
def handle_error(err):
    """自定义处理错误方法"""
    # 这个函数的返回值会是用户看到的最终结果
    return "首页已换， 下次记得收藏网站。。%s" % err

4 返回的响应数据

 4.1 元组

可以返回一个元组，这样的元组必须是 (response, status, headers) 的形式，且至少包含一个元素。 status 值会覆盖状态代码， headers 可以是一个列表或字典，作为额外的消息标头值。

@app.route("/index")
def index():
    # 使用元祖返回自定义的响应信息
    #           响应头                      状态码   响应头
    # return "使用元祖返回自定义的响应信息", 400, [("name", "haha")]
    # return "使用元祖返回自定义的响应信息", 400, {("name", "haha")}
    # return "使用元祖返回自定义的响应信息", 666, {("name", "haha")}
    # return "使用元祖返回自定义的响应信息", "666 mystatus", {("name", "haha")}
    # return "使用元祖返回自定义的响应信息", "666 mystatus"

4.2 make_response

from flask import make_response

@app.route("/index")
def index():
    # 使用make_response来构造响应信息
    res = make_response("使用make_response来构造响应信息")
    res.status = "666 mystatus"     # 设置状态码
    res.headers["name"] = "haha"    # 设置响应头
    return res

5 使用jsonify返回json数据

from flask import jsonify

@app.route("/index")
def index():
    data = {"title": "santi", "price": 90}
    # return json.dumps(data)     # 此时响应头的Content-Type: text/html; charset=utf-8
    # 手动设置Content-Type
    # return json.dumps(data), 200, {"Content-Type": "application/json"}
    # 使用jsonify， jsonify帮助转换json数据， 并设置响应头Content-Type": "application/json"
    # return jsonify(data)
    return jsonify(title="santi", price=90)

6 设置和读取cookie

from flask import Flask, make_response, request

app = Flask(__name__)

@app.route("/set_cookie")
def set_cookie():
    res = make_response("set_cookie")
    # 默认有效期是临时cookie， 浏览器关闭就失效
    # res.set_cookie("name", "test")
    # max_age设置有效期， 单位：秒
    # res.set_cookie("name1", "test1", max_age=3600)
    # 通过响应头设置cookie
    # res.headers["Set-Cookie"] = "name2=test2; Expires=Sun, 28-Apr-2019 12:37:29 GMT; Max-Age=3600; Path=/"
    return res

@app.route("/get_cookie")
def get_cookie():
    cook = request.cookies.get("name1")
    return cook

@app.route("/delete_cookie")
def delete_cookie():
    res = make_response("delete_cookie")
    res.delete_cookie("name1")
    return res

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

7 session

from flask import session

需要设置secret_key

from flask import Flask, session

app = Flask(__name__)

app.config["SECRET_KEY"] = "qlxmxlnmj"

@app.route("/login")
def login():
    # 设置session
    session["name"] = "test"
    return "login success"

@app.route("/index")
def index():
    # 获取session
    name= session.get("name")
    return "session ：： %s" %name

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

8 请求上下文与应用上下文

上下文：相当于一个容器，保存了Flask程序运行过程中的一些信息。

Flask中有两种上下文，请求上下文和应用上下文。

8.1 请求上下文(request context)

request和session都属于请求上下文对象。

request：封装了HTTP请求的内容，针对的是http请求。举例：user = request.args.get('user')，获取的是get请求的参数。

session：用来记录请求会话中的信息，针对的是用户信息。举例：session['name'] = user.id，可以记录用户信息。还可以通过session.get('name')获取用户信息。

8.2 应用上下文(application context)

current_app和g都属于应用上下文对象。

current_app:表示当前运行程序文件的程序实例。我们可以通过current_app.name打印出当前应用程序实例的名字。

g:处理请求时，用于临时存储的对象，每次请求都会重设这个变量。比如：我们可以获取一些临时请求的用户信息。

• 当调用app = Flask(_name_)的时候，创建了程序应用对象app；

• request 在每次http请求发生时，WSGI server调用Flask.call()；然后在Flask内部创建的request对象；

• app的生命周期大于request和g，一个app存活期间，可能发生多次http请求，所以就会有多个request和g。

• 最终传入视图函数，通过return、redirect或render_template生成response对象，返回给客户端。

区别： 请求上下文：保存了客户端和服务器交互的数据。 应用上下文：在flask程序运行过程中，保存的一些配置信息，比如程序文件名、数据库的连接、用户信息等。

9 请求钩子

在客户端和服务器交互的过程中，有些准备工作或扫尾工作需要处理，比如：在请求开始时，建立数据库连接；在请求结束时，指定数据的交互格式。为了让每个视图函数避免编写重复功能的代码，Flask提供了通用设施的功能，即请求钩子。

请求钩子是通过装饰器的形式实现，Flask支持如下四种请求钩子：

before_first_request：在处理第一个请求前运行。

before_request：在每次请求前运行。

after_request：如果没有未处理的异常抛出，在每次请求后运行。

teardown_request：在每次请求后运行，即使有未处理的异常抛出。

from flask import Flask

app = Flask(__name__)

@app.route("/index")
def index():
    print("index 被执行")
    return "index"

@app.before_first_request
def handle_before_first_request():
    """在第一次请求处理之前被执行"""
    print("handle_before_first_request 被执行")

@app.before_request
def handle_before_request():
    """在每次请求之前都被执行"""
    print("handle_before_request 被执行")

@app.after_request
def handle_after_request(response):
    """在每次请求(视图函数处理)之后都被执行， 前提是视图函数没有出现异常"""
    print("handle_after_request 被执行")
    return response

@app.teardown_request
def handle_teardown_request(response):
    """在每次请求(视图函数处理)之后都被执行， 无论视图函数是否出现异常，都被执行"""
    print("handle_teardown_request 被执行")
    return response

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

启动服务器，在浏览器访问index，控制台输出结果：

服务器不重启，再次刷新浏览器，控制台输出：

在index函数中添加一个异常，

from flask import Flask

app = Flask(__name__)

@app.route("/index")
def index():
    print("index 被执行")
    int("A")
    return "index"

@app.before_first_request
def handle_before_first_request():
    """在第一次请求处理之前被执行"""
    print("handle_before_first_request 被执行")

@app.before_request
def handle_before_request():
    """在每次请求之前都被执行"""
    print("handle_before_request 被执行")

@app.after_request
def handle_after_request(response):
    """在每次请求(视图函数处理)之后都被执行， 前提是视图函数没有出现异常"""
    print("handle_after_request 被执行")
    return response

@app.teardown_request
def handle_teardown_request(response):
    """在每次请求(视图函数处理)之后都被执行， 无论视图函数是否出现异常，都被执行，  工作在非调试模式， debug=false"""
    print("handle_teardown_request 被执行")
    return response

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

把调试模式关了， 重启服务器，在浏览器访问，控制台输出：

10 Flask-Script扩展命令行

通过使用Flask-Script扩展，我们可以在Flask服务器启动的时候，通过命令行的方式传入参数。而不仅仅通过app.run()方法中传参，比如我们可以通过python hello.py runserver --host ip地址，告诉服务器在哪个网络接口监听来自客户端的连接。默认情况下，服务器只监听来自服务器所在计算机发起的连接，即localhost连接。

pip3 install Flask-Script

from flask import Flask
from flask_script import Manager

app = Flask(__name__)

# 创建Manager管理类的对象
manager = Manager(app)

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

if __name__ == '__main__':
    # app.run()
    # 通过管理对象来启动
    manager.run()