【Flask】Flask快速使用 web框架原理 Flask配置文件写法路由系统源码分析

1 Flask介绍
- 1.1同步框架和异步框架的区别
- 1.2 flask介绍
2 Flask快速使用
3 web框架原理（了解）
4 flask 展示用户信息案例
5 配置文件写法
- 5.1 pycharm中开启flask调试模式
6 路由系统
7 路由本质
- 7.1 add_url_rule的参数
- 7.2转换器
练习

1 Flask介绍

# 目前python界，比较出名的web框架

    -django：大而全，web开发用的东西，它都有

        -django从3.x 改成了异步框架（伪异步）

    -Flask：小而精，只能完成请求与响应，session，cache，orm，admin。。。统统没有

    	-Flask有很多第三方框架，flask完全可以变成django

    -web.py:是一个小巧灵活的Python框架，它简单而且功能强大（国内几乎没有用的）

    ----以下是异步框架--------

    -fastapi：python的异步web框架，不少公司再用，https://fastapi.tiangolo.com/zh/

    -Sanic : python 3.6 及以上，python的异步web框架，供支持异步高并发请求的 web 服务

    -Tornado：非常少了，ptyhon2.x上，公司里用的多一些

1.1同步框架和异步框架的区别

# 同步框架和异步框架的区别

	-djagno是同步框架还是异步框架，djagno 3.x以后支持异步

    -同步框架的意思：一个线程只处理一个请求

    -异步框架的意思：一个线程可以处理多个请求

    -异步框架可以很显著的提高并发量

同一时刻来了3个人访问。请求先到达wsgi协议的web服务器。

两个uwsgi执行两个django。

一条线程就在处理用户的一个请求，称之为同步框架。异步框架可以提供项目的并发量，让一个线程可以处理到更多的请求，而不是遇到IO就阻塞，等待CPU。请求不返回，站在用户的角度，异步和同步没有区别。异步框架不一定比同步快，只是如果视图函数IO操作多，用异步框架效率高，如果都是计算型操作，异步提升不了效率。

总结：django是同步框架还是异步框架？

1.2 flask介绍

# Flask

    Flask是一个基于Python开发并且依赖jinja2模板（模板语言）和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架，开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。

    -jinja2 模板语法，django的dtl，非常像

    -Werkzeug WSGI 符合wsgi协议的web服务器，django使用的是wsgiref

“微”(micro) 并不表示你需要把整个 Web 应用塞进单个 Python 文件（虽然确实可以 ），也不意味着 Flask 在功能上有所欠缺。微框架中的“微”意味着 Flask 旨在保持核心简单而易于扩展。Flask 不会替你做出太多决策——比如使用何种数据库。而那些 Flask 所选择的——比如使用何种模板引擎——则很容易替换。除此之外的一切都由可由你掌握。如此，Flask 可以与您珠联璧合。

默认情况下，Flask 不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask 支持用扩展来给应用添加这些功能，如同是 Flask 本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask 也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用

2 Flask快速使用

# pip3 install flask

# 会一同安装依赖 MarkupSafe, Werkzeug, Jinja2, flask

from flask import Flask

app = Flask(__name__)

# 注册路由

@app.route('/index')

def index():

    return '你看到我了'

if __name__ == '__main__':

    app.run(host='127.0.0.1',port=8080)

pycharm创建flask项目：

如下提示都不是强制的，不按照要求传入参数不会报错。

快速使用：

约定俗称传_name_指定app的名字，第一个参数要传一个字符串。

开启flask服务：

代码：

from flask import Flask

app = Flask(__name__)

# app=Flask('test')

# 注册路由---->装饰器

@app.route('/index')

def index():

    return 'hello web'

@app.route('/')

def home():

    return 'hello home'

if __name__ == '__main__':

    # app.run('127.0.0.1',5000)

    app.run()

3 web框架原理（了解）

# 1 bs 架构

# 2 使用socket写一个服务端

# 都符合wsgi协议

# 3 使用wsgiref写

	-django

# 4 使用werkzeug写

	-flask

WSGI是Web服务器和Python Web应用程序之间的一套接口标准协议。

该协议规定Web程序必须有一个可调用对象，且该可调用对象接收两个参数，返回一个可迭代对象：

environ：字典，包含请求的所有信息
start_response：在可调用对象中调用的函数，用来发起响应，参数包括状态码，headers等

查看django使用的wsgiref的可调用对象（通过双下call产生）：

django请求到响应：

wsgiref写web:

使用werkzeug写web:

wsgiref、werkzeug都是作为服务器。

推荐阅读：WSGI到底是什么？ - 知乎 (zhihu.com)

4 flask 展示用户信息案例

4.1 login.html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

<form method="post">

    <p>用户名：<input type="text" name="username"></p>

    <p>密码：<input type="password" name="password"></p>

    <input type="submit" value="登录"> {{error}}

</form>

</body>

</html>

4.2 home.html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

<h1>用户列表</h1>

<table>

    {% for k,v in user_dict.items() %}

    <tr>

        <td>{{k}}</td>

        <td>{{v.name}}</td>

        <td>{{v['name']}}</td>

        <td>{{v.get('name')}}</td>

        <td><a href="/detail/{{k}}">查看详细</a></td>

    </tr>

    {% endfor %}

</table>

</body>

</html>

4.3 detail.html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

<p>名字是：{{user.name}}</p>

<p>年龄是：{{user['age']}}</p>

<p>性别是：{{user.get('gender')}}</p>

<p>{{user.text}}</p>

</body>

</html>

4.4 py文件

from flask import Flask, request, render_template, redirect, session,jsonify

app = Flask(__name__)

# 要使用session，必须设置秘钥，秘钥是配置信息

app.secret_key = 'asdfasdfa33aef3aefads'

USERS = {

    1:{'name':'张三','age':18,'gender':'男','text':"道路千万条"},

    2:{'name':'李四','age':28,'gender':'男','text':"安全第一条"},

    3:{'name':'王五','age':18,'gender':'女','text':"行车不规范"},

}

# 1 创建templates文件夹，写login.html

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

def index():

    # 没有request对象，使用全局的request

    # get请求，返回模板

    if request.method == 'GET':

        return render_template('login.html')  # 新手四件套之一：返回模板

    else:

        # post请求，校验数据

        # 取出前端传入的用户名密码，校验

        username = request.form.get('username')  # 等同于django的的request.POST

        password = request.form.get('password')

        if username == 'lqz' and password == '123':

            # 登录成功,保存登录状态 重定向到跟路径   新手四件套之一：重定向

            # 保存到session中,session是全局的

            session['name'] = username

            return redirect('/')

        else:

            return render_template('login.html', error='用户名或密码错误')  # 注意跟django的render区分，要模板渲染的数据，直接key=value传即可

@app.route('/')

def home():

    # 校验，登录成功，才能过来，不登录，重定向到登录页面

    if session.get('name'):  # 有值说明登录了，没有值说明没有登录

        return render_template('home.html',user_dict=USERS)

    else:

        return redirect('/login')

@app.route('/detail/<int:pk>')

def detail(pk):

    if session.get('name'):  # 有值说明登录了，没有值说明没有登录

        user_detail = USERS.get(pk)

        return render_template('detail.html', user=user_detail)

    else:

        return redirect('/login')

@app.route('/test')

def test():

    return jsonify([{'name':'lqz','age':19}])

if __name__ == '__main__':

    app.run()

'''

# 学到的

    1 注册路由  app.route(路径,methods=[请求方式get，post])

    2 新手四件套：

        -render_template   渲染模板 跟django有区别

        -redirect  重定向

        -return 字符串 返回字符串

        -jsonify 返回json格式

    3 请求的request对象，是全局的，直接导入使用即可，在不同视图函数中不会混乱

        request.method  请求方式

        request.form   post请求的body体的内容转成了字典

    4 session 全局的，直接导入使用即可,一定要指定秘钥app.secret_key = 'asdfasdfa33aef3aefads'

        放值：session['name']='lqz'

        取值：session.get('name')

    5 模板的渲染

        -兼容django的dtl

        -更强大，可以加括号，字典可以.get  .values()   .items()

        -{% for %}

    6 转换器@app.route('/detail/<int:pk>')

'''

如果不传参，默认只能接受get请求。

导入flask全局的request:

虽然是全局的request，但是每个视图函数用的request对象是它自己的（访问该视图函数的当次请求）。

get请求返回模板：

使用render_templates函数。

post请求使用request.form获取表单数据：

登录成功之后重定向到根路径，并且保存登录状态：

session也是全局的，需要导入。

当密码错误，需要使用模板渲染，给模板传参：

模板语法插值：

session密钥设置报错：

密钥是flask项目的配置信息，设置方法如下：

在根路径通过session中存放的值，做登录校验：

使用模板语法循环取值：

模板语法：

支持items加括号（django模板语法会报错），支持各种取值。

有名分组分出来的参数，需要在视图函数中接受：

模板语法渲染：

总结：

5 配置文件写法

# django 有个settings

# flask 也有配置问题，但是它的使用方式多种：

	# 设置的方式一：（测试用）

    # app.debug=True  # 调试模式，提示信息更详细，修改代码不需要重启，自动重启

    # app.secret_key='dasdfasdfasd'  # 秘钥，只能 放debug和secret_key

    ## 设置方式二:直接使用app.config设置

    # app.config['DEBUG']=True

    # app.config['SECRET_KEY']='sdfasdfasd'

    # print(app.config)

    ## 方式三：使用py文件（不常用）

    # app.config.from_pyfile("settings.py")

    # print(app.config)

    ## 方式四:常用的，使用类的方式

    # app.config.from_object('settings.DevelopmentConfig')

    # app.config.from_object('settings.ProductionConfig')

    # print(app.config)

    ### 其他：

    #通过环境变量配置

    # app.config.from_envvar("环境变量名称")

    # json

    # app.config.from_json("json文件名称")

    # JSON文件名称，必须是json格式，因为内部会执行json.loads

#使用分布式配置中心

import requests

res=requests.get('asdfasdfasdf').json()

app.config.from_mapping(res)

# 拓展：配置文件都在本地

# 内置的配置字段，其他可以写自己的，比如 redis的连接地址，mysql的连接地址

	-DEBUG

    -SECRET_KEY

    -SESSION_COOKIE_NAME

    -PERMANENT_SESSION_LIFETIME

设置的方式一，直接往app对象里面放，只能放两个配置：

设置的方式二，向app.config里面放：

使用中括号赋值：

通过app.config可以取出所有配置信息。

方式三：指定配置文件，然后再配置文件里面写配置

配置文件配置必须大写：

查看配置：

常用的配置方式:

在setting.py配置文件里，写多个配置类。（开发环境配置类，生产环境配置类）

使用基类，避免重复写配置。

指定使用的配置类：

其他的配置方法：

从环境变量取出配置。

从json文件取出配置。

通过字典添加配置：

配置中心会根据不同的web服务，返回不同的json配置信息。

微服务配置中心nacos:

出现的原因，分布式系统，每个项目都有自己的两套的配置文件。专门有个服务，去返回配置文件。web app服务去配置中心拿配置文件。

django做配置中心，将setting配置文件加载成json数据，然后发送给服务端。

5.1 pycharm中开启flask调试模式

在pycharm中开启flask的调试模式，仅仅使用app.config设置DEBUG=True还是无法开启，需要额外配置：

6 路由系统

# flask 的路由系统，djagno中，路由是单独的urls.py。

# flask是基于装饰器的，大部分都用装饰器来做，少量可以抽取到一个urls.py。

# 使用方式

@app.route：重要的参数

	-rule: 字符串的路径，使用转换器  <string:name>  <name>

    	'default':          UnicodeConverter,

        'string':           UnicodeConverter,

        'any':              AnyConverter,

        'path':             PathConverter,    # /xx/sss/

        'int':              IntegerConverter, # 数字

        'float':            FloatConverter,   #小数

        'uuid':             UUIDConverter,    #asdfas-asdfas-asdf

        #记住：string，int，path

    -methods: 列表，规定请求的方式，如果列表中没有，该请求方式不被支持

    -endpoint：路由别名，如果不写，会以被装饰的函数名作为别名，django中叫name

装饰器的本质：

类装饰器（加在类上的装饰器）。

类当装饰器来用。

7 路由本质

# flask中路由是使用装饰器的，但是它的本质其实是app对象(Flask)的方法self.add_url_rule(rule, endpoint, f, **options)

# 如果在视图函数上加了装饰器，其实本质是在调用self.add_url_rule

	-我们可以不加装饰器，自己调用这个方法，也能完成路由的注册

# 路由的装饰器源码分析

	# 咱们这样写

    @app.route('/login')

    def index():

        pass

    #本质是---》index=app.route('/login')(index)

    # app.route('/login')的执行结果 decorator 函数

    	-rule是路径

        -其他参数都给了options

    # 然后 decorator(index)--->在执行

    		# f是index

    		endpoint = options.pop("endpoint", None) # 目前没有endpoint，是None

            # 核心，本质--》self就是实例化得到的app对象，flask对象

            # app对象中有个方法add_url_rule，这是在添加路由

            # 不使用装饰器，自己注册路由

            self.add_url_rule(rule, endpoint, f, **options)

            return f

    def route(self, rule: str, **options: t.Any) -> t.Callable[[T_route], T_route]:

        def decorator(f: T_route) -> T_route:

            endpoint = options.pop("endpoint", None)

            self.add_url_rule(rule, endpoint, f, **options)

            return f

        return decorator

# 可以不使用装饰器的方式，注册路由

	app.add_url_rule('/', endpoint=None, view_func=home, methods=['GET'])    

# 其实跟djagno没有大的差距，只是使用装饰器来配置

7.1 add_url_rule的参数

@app.route和app.add_url_rule参数:

# rule, URL规则

# view_func, 视图函数名称

# defaults = None, 默认值, 当URL中无参数，函数需要参数时，使用defaults = {'k': 'v'}

为函数提供参数,就是djagno中得kwargs

# endpoint = None, 名称，用于反向生成URL，即： url_for('名称')，等同于django的reverse

# methods = None, 允许的请求方式，如：["GET", "POST"]

# strict_slashes 对URL最后的 / 符号是否严格要求

strict_slashes = None

    '''

        @app.route('/index', strict_slashes=False)

        #访问http://www.xx.com/index/ 或http://www.xx.com/index均可

        @app.route('/index', strict_slashes=True)

        #仅访问http://www.xx.com/index

    '''

# redirect_to 重定向到指定地址

redirect_to = None,

    '''

        @app.route('/index/<int:nid>', redirect_to='/home/<nid>')

    '''

 # 需要记住的

    # rule

    # view_func

    # defaults

    # endpoint

    # methods

比较django:

defaults相当于django的kwargs。

可以给视图函数提供分组之外，需要传入的参数。

endpoint定义的是反向解析的别名。

django path的本质就是add_url_rule。

7.2转换器

 'default':          UnicodeConverter,

 'string':           UnicodeConverter,

 'any':              AnyConverter,

 'path':             PathConverter,

 'int':              IntegerConverter,

 'float':            FloatConverter,

 'uuid':             UUIDConverter,

 # 了解：让路由支持正则（忽略掉）

练习

# 1 学过的所有内容的视频标题，列一列

	-比如：（只挑你觉得重点的）

    	-es6的导入导出语法

        -props  父传子，属性验证

        -混入

        -插件

        -scoped

        -localStorage

        -inclusion_tag

   -想象当时用这个东西做了啥？老师讲的案例是什么？

   -第一部分：个人技能部分

   -第二部分：写你那个项目，想象这部分内容能用在项目哪里

# 练习

    -登录小案例

    -配置文件使用类方式

    -研究一下路由的本质

    -使用登录认证装饰器写，登录认证，写在index和detail上

    -坑(1 顺序问题 2 需要指定endpoint)