一、插件的使用

1.1 缓存插件`flask-caching`

1.1.1 安装

在我们的虚拟环境中安装即可

pip install flask-caching

1.1.2 初始化

用法如下

# 1. 导入包
from flask_caching import Cache

# 2. 配置初始化，且指定缓存类型
cache = Cache(config={
    'CACHE_TYPE':'simple',
})

# 3. 与app绑定实现初始化
cache.init_app(app=app)

在我们代码中修改exts.py文件即可

# 插件管理
# 如何使用插件
# 1. 导包
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

from flask_caching import Cache

# 2. 初始化
db = SQLAlchemy()  # 这个就是ORM
migrate = Migrate()  # 数据迁移

# 初始化
cache = Cache(config={
    'CACHE_TYPE': 'simple',
})


# 3. 和app对象绑定

def init_exts(app):
    # 初始化数据库
    db.init_app(app=app)
    # 初始化数据迁移
    migrate.init_app(app=app, db=db)

    # 绑定缓存
    cache.init_app(app=app)

1.1.3 使用

在视图函数上添加缓存

# 在视图文件中，导入cache
from .exts import cache

@blue.route('/')
@cache.cached(timeout=30)
def home():
    print('加载数据')
    return 'home'

1.2 如何找Flask扩展呢

打开网站 https://pypi.org/，点击browse projects

进入到如下页面，点击Framework

再点击Flask，就是Flask相关的扩展了

二、中间件(钩子)

2.1 什么中间件Middleware

钩子或叫钩子函数，是指在执行函数和目标函数之间挂载的函数，框架开发者给调用方提供一个point-挂载点是一种AOP切面编程思想

2.2 常用的钩子函数

before firstrequest: 处理第一次请求之前执行
before_request: 在每次请求之前执行，通常使用这个钩子函数预处理一些变量，实现反爬等
after_request:注册一个函数，如果没有未处理的异常抛出，在每次请求之后运行.
teardown_appcontext: 当APP上下文被移除之后执行的函数,可以进行数据库的提交或者回滚

# 这里是钩子函数的使用
@blue.before_request
def before_request():
    # 在钩子函数中可以得到很多Flask的内置对象，例如request
    print(request.path)

三、Flask内置对象

3.1 `g`全局对象

global全局对象
g对象是专门用来保存用户的数据的
g对象在一次请求中的所有的代码的地方，都是可以使用的突破变量存储位置限制，为数据传递添加了新的方式，比如我们before_request产生一个数据在后面需要使用，可以保存在g对象中，在其他视图函数中就可以使用这个数据

3.2 request 请求对象

请求对象，可以获取客户端提交过来的所有请求信息

3.3 session 会话对象

会话技术，服务端会话技术的接口

3.4 `current_app` Flask应用对象

app的配置信息，app对象获取，current_app
使用获取当前app需要注意，一定要在程序初始化完成之后.

3.5 如何使用

这四个内置对象，导入后，可以在任意位置使用，通过使用这些的对象的属性来获取相应的信息

四、配置templates和static

在settings.py文件中添加BASE_DIR:

import osBASE DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file_)))

在__init__.py文件中添加static路径和templates路径

static_path = os.path.join(settings.BASE DIR，'static')
template_path = os.path.join(settings.BASE DIR,'templates')
app = Flask( name,static_folder=static_path,template_folder=template_path)

在views.py文件中访问模板:

@blue.route('/hello/')
def he1lo():
    return render_template( 'hello.html')

在模板中使用静态资源:

<link rel="stylesheet" href="{{ url_for('static',filename='css/hello.css') }}">

五、前后端分离

前后端分离与模板技术的区别是：前端的代码可以通过vue、react等编写的程序，通过网络调用直接调用后端接口，后端接口一般返回json返回给前段。
后端返回给前段的时候，例如是Flask的时候，需要通过jsonify()方法把后端的数据转换成json格式的数据返回给前段。前段通过获取json格式的返回数据进行数据渲染。

5.1 `flask-restful`插件实现前后端分离

5.1.1 安装

pip install flask-restful

5.2 项目结构如下

5.2.1 `init.py`

# __init__ 初始化文件，创建Flask应用
# 由于这个模块在App文件夹下，所以App文件夹就是一个App模块

from flask import Flask

from .exts import init_exts

# 把路由引入
from .urls import *


# 创建应用，并且返回app
def create_app():
    app = Flask(__name__)

    # 初始化插件
    init_exts(app)

    return app

5.2.2 apis.py

这哩是一个类视图文件

from flask_restful import Resource


#  类视图 CBV
# 继承Resource后，请求类型与方法名字一致
class HelloResource(Resource):
    # 处理get请求
    def get(self):
        return 'get请求'

    # 处理post请求
    def post(self):
        return 'post请求'

5.2.3 exts.py

from flask_restful import Api

# 2. 初始化

# restful
api = Api()


# 3. 和app对象绑定

def init_exts(app):
    # resultful
    api.init_app(app=app)

5.2.4 apis.py

这个就是路由文件，根据访问的路由，指定到对于的类视图

# 路由文件

# 从扩展中导入api对象
from .exts import api

# 从api中导入所有
from .apis import *

# 路由
api.add_resource(HelloResource, '/hello/')

5.2.5 app.py

启动文件

# 启动文件
# 从App模块下引入的文件，这个App模块就是App文件夹
from App import create_app

app = create_app()

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

5.3 启动启动

访问路径http://localhost:5000/hello/后，访问到/hello/的路由，会在apis.py文件中会找到对于的类视图HelloResource。在指定的类视图中处理对应的方法请求。

5.4 字段格式化(后端返回数据)

fields进行定义marshal_with进行使用

5.4.1 特性

显示我们设计的数据结构
默认返回的数据如果在预定义结构中不存在，数据会被自动过滤
如果返回的数据在预定义的结构中存在，数据会正常返回如果
返回的数据比预定义结构中的字段少，预定义的字段会呈现一个默认值

5.4.2 定义字段输出

使用字段进行定义
常用都是基本类型，String，Integer

# 格式化字段
user_fileds={
    'msg'：fields.String,
    'status':fields.Integer,
    'data':fields.String(attribute='private_data'),
    'default_data':fields.String(default='1')

}

定义好的格式通过装饰器进行使用

@marshal_with(需要返回的数据格式)，return返回字段就可以了。

class Users(Resource):
    @marshal_with(user_fields)
    def get(self):
        return {'msg'：'操作完成',
    'status':200,
    'data':'',
    'default_data':'1'}

5.4.3 级联数据：嵌套字典

# 格式化字段
user_fileds={
    'id':fields.Integer,
    'name':fields.String
}

user_all_fields={
    'msg':fields.String(default='200'),
    'status':fields.Integer(default=1),
    'data':fields.Nested(user_fileds)
}

5.4.4 结构允许嵌套列表

fields.List(fields.Nested)

# 格式化字段
user_fileds={
    'id':fields.Integer,
    'name':fields.String
}

user_all_fields_list={
    'msg':fields.String(default='200'),
    'status':fields.Integer(default=1),
    'data':fields.List(fields.Nested(user_fileds))
}

5.5 解析前段传递的数据

5.5.1 代码

# 定义解析前端数据的规范
parser = reqparse.RequestParser()
parser.add_argument('name', type=str, required=True, help='name是必须的参数')


class HelloResource(Resource):
    def get(self):
        # 使用规范
        args = parser.parse_args()
        name = args.get('name')
        return {'name': name}

    def post(self):
        return 'post请求'

5.5.2 前端访问

如果直接在url中访问，会提示如下

如果通过其他请求工具，增加上需要的类型，例如requests

import requests
request.get('http://127.0.0.1:5000/hello/',
           json={'name','lisi'},
           headers={'Content-Type':'application/json'}
           )