flask 之(五) --- 对象|钩子|拆分

内置对象

request：　　请求的所有信息
session　　服务端会话技术的接口
config:　　当前项目的配置信息，模板中可以直接使用
g：global　　在单次请求过程中，实现全局数据共享(可以帮助开发者实现跨函数传递数据)

from flask import Blueprint, render_template, g

from .models import User

user_blue = Blueprint('user_blue',__name__,url_prefix="/users/")

@user_blue.route('/')

def hello_world():

    return 'User Index!'

@user_blue.route('/create/')

def create():

    # g的信息即使没有被返回渲染，也可以在html中获取到

    g.msg = "g的信息"

    return render_template('index.html')

 <!DOCTYPE html>

 <html lang="en">

 <head>

     <meta charset="UTF-8">

     <title>Index</title>

 </head>

 <body> # 获取全局变量的值

 <h1>{{ g.msg }}</h1>

 </body>

 </html>

config 或者app

　　config表示当前运行的项目。遍历config时是获取当前运行的App的配置 [配置应该是有价值的]

　　在python代码中current_app.config，当前运行的app。用在函数中，使用记得是在初始化完成之后

 <body>

 <ul>

     {% for foo in config %}

         <li>{{ foo }}</li>

     {% endfor %}

 </ul>

 </body>

钩子函数

编程模型：

OOP: 面向对象编程；POP: 面向过程编程
AOP:　面向切面编程；IOP:　面向接口编程

面向切面：

　　在不修改原有逻辑代码的基础上。动态的去添加一些功能或者控制逻辑（装饰器类似）

　　动态介入到既有流程中，去监控或者去获取我们想要的数据

　　蓝图和app上都有钩子函数，app上的钩子优先级更高一些；蓝图只能处理本蓝图内容的信息

重要概念：

　　切面：切开后可以获取的东西叫切面。(在flask中叫做钩子函数)

　　　　　请求前切面获取：　　request

　　　　　请求后切面获取：　　request、response

　　　　　请求异常切面获取：　exception、request

　　切点：可切的地方叫切点。请求前、请求后、请求异常

　　　　　请求前切点：　　@user_blue.before_request

　　　　　请求后切点：　　@user_blue.before_request

　　　　　请求异常切点：　@user_blue.errorhandler(500)

 """

 常用请求钩子：

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

     before_request：　　　　    在每次请求前运行。

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

     teardown_request：　　     在每次请求后运行，即使处理发生了错误。

     teardown_appcontext：　    在应用上下文从栈中弹出之前运行

 """

 # 定义钩子函数：相当于django中的中间件

 # before_request装饰的方法会加载到app的before_request_funcs列表中，按加载的顺序依次执行，不需要参数

 @app.before_request

 def test_before_request():

     print('before_request：2')

 # before_first_request装饰的函数加载到before_first_request_funcs列表中，只不过在app第一次接收到请求后执行，其他时候不再执行

 @app.before_first_request

 def test_before_first_request():

     print('before_first_request：1')

 # after_request装饰的函数加载到after_request_funcs列表中，传入的参数是response对象，可以对其进行拦截修改，必须返回一个response对象

 @app.after_request

 def test_after_request(resp):

     print(resp)

     print('after_request：3')

     return resp

 @bp.before_request

 def test_before_request():

     """

     每个视图函数执行之前，都会执行此函数

     根据业务决定是否有返回值

     :return:

     """

     print('in before request')

     g.start_time = time.time()

     # before_request 可以用在对所有请求的登录认证中

     # 1、通过session，获取用户id

     # 2、根据用户id查找用户对象

     # 3、如果用户id合法，则认为登录合法

     # 4、在后续的所有视图函数中，可以直接使用 g.user 获得当前登录的user对象

     # uid = session.get('uid')

     # user = User.query.get(uid)

     #

     # if user:

     #     g.user = user

     #     g.is_login = True

     # else:

     #     g.user = None

     #     g.is_login = False

 @bp.after_request

 def test_after_request(response):

     print('in after request')

     start_time = g.start_time

     exec_time = time.time() - start_time

     print('exec_time:', exec_time)

     return response

钩子和对象

内置蓝图钩子 [请求前]

 from flask import Blueprint, render_template, g

 from .models import User

 user_blue = Blueprint('user_blue',__name__,url_prefix="/users/")

 @user_blue.route('/')

 def hello_world():

     return 'User Index!'

 @user_blue.route('/create/')

 def create():

     print('create视图函数，在钩子函数执行之后执行')

     # 接收before钩子函数传递过来的数据

     print("before钩子函数传递过来的数据：",g.data)

     # g的信息即使没有被返回渲染，也可以在html中获取到

     g.msg = "g的信息"

     return render_template('index.html')

 # 切面 即钩子函数

 @user_blue.before_request

 def before():

     print("before钩子函数，在路由函数执行之前执行")

     # 向create视图函数中传递数据

     g.data = "钩子函数 给 视图函数 的数据"

内置蓝图钩子 [请求后]

 from flask import Blueprint

 from .models import Movie

 movie_blue = Blueprint("movie_blue",__name__,url_prefix="/movies/")

 @movie_blue.route('/')

 def index():

     return "Movie Index"

 @movie_blue.before_request

 def before():

     print("before")

 @movie_blue.after_request

 def after(resp):　　# 切开时获取到的返回值作为参数

     print("after")

     　　　　　　　　　# 切开后，需要把切之前要返回的信息接着返回出去

     return resp

内置蓝图钩子 [异常捕获]

 from flask import Blueprint

 from .models import Movie

 movie_blue = Blueprint("movie_blue",__name__,url_prefix="/movies/")

 @movie_blue.route('/')

 def index():

     return "Movie Index"

 # 请求前

 @movie_blue.before_request

 def before():

     print("before")

 # 请求后

 @movie_blue.after_request

 def after(resp):

     print("after")

     # 切开后，需要把切之前要返回的信息接着返回出去

     return resp

 # 异常捕获

 @movie_blue.errorhandler(500) 　　# 错误码

 def error500(exce): 　　　　　　　　# 获取异常参数

     print(type(exce))

     return "异常信息屏蔽，返回到首页"

　　可以在项目的目录下新建一个 middleware.py 文件。将切面编程代码编写在middleware文件中。

　　然后在__init__.py文件中把中间件middleware加载进来：load_middleware(app)。改成全局的中间件，优先级更高

　　在middleware.py 文件中，声明一个 load_mindleware(app)函数，导入相应的包，然后在此函数下写中间件视图函数

 def load_middleware(app):

     @app.before_request()

     def before():

         print("before")

项目拆分

　　在开发过程中多人合作完成，就需要考虑项目的重构性、扩展性。在一个文件中写代码，是非常不理想的。就需要对文件进行拆分。

　　拆分：

　　　　首先有一个文件的程序，名字就叫这个项目的名字。通过flask-script可以将这个文件改变成统筹管理这个项目的文件，

　　　　将此文件名字改成 manage。用它来统筹管理我们这个项目。然后新建一个名为App包文件，用来存放此项目的文件

　　　　在包文件中，通常将创建flask的过程写在 __init__.py 文件中，天然单例首先被调用。

　　　　在setting.py文件中做配置信息，在__init__ 中加载配置文件进来。

　　　　在extension.py文件中做扩展库的信息，在__init__中初始化扩展库。

　　　　在views.py文件中做视图函数信息，在__init__中初始化路由，尽量最后初始化路由（是web的入口，在启动时需要其他信息加载好）

　　　　在model.py文件中操作数据信息，views.py 文件操作 model.py ；model.py 还需要extenson扩展库文件中的db

　　总结：

　　　　配置要优先于初始化。首先初始化配置信息；然后初始化扩展库；最后初始化路由。启动项目的时候从manage.py开始启动

　　　　启动的时候首先创建Flask对象，然后对Flask对象的配置进行各种初始化，加载完初始化后去加载扩展库，最后初始化路由。

　　分析：

　　　　manager.py文件中创建Flask的app实例(对象)。通过App/__init__.py文件中的 create_app 函数来创建Flask的App实例。

　　　　　　并且把创建好的app实例交给Manager来管理

　　　　App/__init__.py文件中加载初始化各种配置：创建app实例、加载配置文件、加载扩展库文件、加载路由(蓝图)。

　　　　　　创建app实例：通过 create_app 函数来创建Flask的app实例(对象)。

　　　　　　加载配置文件：通过 config.from_object(Config) 加载对象的方式加载setting.py中创建的配置类Config对象

　　　　　　加载扩展文件：通过 init_ext(app) 函调用的方式，将app实例以参数的形式传入到扩展文件extension.py文件中的init_ext函数中。

　　　　　　　　　　　　　对app实例进行扩展信息初始化。通过这种方式避免循环导入的问题

　　　　　　加载路由文件：通过 init_blue(app) 函数调用的方式，将app实例以参数的形式传入到视图views.py文件中。在init_blue函数中，对app进行(蓝图)初始化。

　　　　　　　　　　　　　避免循环导入问题的出现

　　坑点：

　　　　在使用views文件中的视图函数创建数据库表的时候，需要将models文件中的表导入到视图文件中。

　　　　即：views.py 文件中导入：from App.models import User。不然无法识别需要创建的该表的信息。

manage.py 文件

 """ manage.py """

 import os

 from flask_script import Manager

 from App import create_app

 # 从系统环境中获取参数FLASK_ENV的值给env,判断是什么环境下的服务器

 # 避免外人修改代码，方便代码放在什么环境服务器下，就在什么环境下运行

 # 在系统终端 vim .bashrc 编写系统环境变量：#FLASK_ENV。export FLASK_ENV = "develop" 保存退出

 env = os.environ.get("FLASK_ENV") or 'default'

 # 首先创建一个flask对象、加载配置、加载扩展库、初始化路由

 app = create_app(env)

 # flask-scripy扩展

 manager = Manager(app)

 if __name__ == '__main__':

     manager.run()

__init__.py

 ''' __init__.py '''

 from flask import Flask

 from App.settings import Config, envs

 from App.extension import init_ext

 from App.views import init_blue

 def create_app(env):

     # 创建Flask对象

     app = Flask(__name__)

     # 加载初始化配置。 从类对象中加载。env参数确定在什么环境下的

     app.config.from_object(envs.get(env))

     # 加载初始化扩展库。通过懒加载的方式加载(调用函数时参数的传递)

     init_ext(app)

     # 加载初始化路由器。通过懒加载的方式加载(调用函数时参数的传递)

     init_blue(app)

     return app

settings.py

 ''' settings.py '''

 # 对连接数据库的配置信息进行格式化整理

 def get_db_uri(dbinfo):

     database = dbinfo.get("DATABASE")

     driver = dbinfo.get("DRIVER")

     user = dbinfo.get("USER")

     password = dbinfo.get("PASSWORD")

     host = dbinfo.get("HOST")

     port = dbinfo.get("PORT")

     name = dbinfo.get("NAME")

     return "{}+{}://{}:{}@{}:{}/{}".format(database,driver,user,password,host,port,name)

 # 配置信息初始化

 class Config:

     SECRET_KEY = 'asdfghjjkl'  # 随机值。系统可以基于一个密码随机生成随机值，这个值可以用来做密钥：

     DEBUG = False

     TESTING = False

     SQLALCHEMY_TRACK_MODIFICATIONS = False

 # 开发环境

 class DevelopConfig(Config):

     DEBUG = True

     # 数据库信息配置

     dbinfo = {

         "DATABASE": "mysql",

         "DRIVER":"pymysql",

         "USER": "root",

         "PASSWORD": "guoyapeng",

         "HOST": "localhost",

         "PORT": "",

         "NAME": "FlaskModel",

     }

     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)

 # 测试环境

 class TestingConfig(Config):

     TESTING = True

     # 数据库信息配置

     dbinfo = {

         "DATABASE": "mysql",

         "DRIVER":"pymysql",

         "USER": "root",

         "PASSWORD": "guoyapeng",

         "HOST": "localhost",

         "PORT": "",

         "NAME": "FlaskModel",

     }

     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)

 # 演示环境

 class StagingConfig(Config):

     # 数据库信息配置

     dbinfo = {

         "DATABASE": "mysql",

         "DRIVER":"pymysql",

         "USER": "root",

         "PASSWORD": "guoyapeng",

         "HOST": "localhost",

         "PORT": "",

         "NAME": "FlaskProject",

     }

     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)

 # 生产环境

 class ProductConfig(Config):

     # 数据库信息配置

     dbinfo = {

         "DATABASE": "mysql",

         "DRIVER":"pymysql",

         "USER": "root",

         "PASSWORD": "guoyapeng",

         "HOST": "localhost",

         "PORT": "",

         "NAME": "FlaskModel",

     }

     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)

 # 获取在什么环境下，不同环境下数据库不同

 envs = {

     "develop":  DevelopConfig,

     "texting":  TestingConfig,

     "staging":  StagingConfig,

     "product":  ProductConfig,

     "default":  ProductConfig,

 }

extension.py

 ''' extension.py '''

 from flask_sqlalchemy import SQLAlchemy

 from flask_migrate import Migrate

 db = SQLAlchemy()

 migate  = Migrate()

 # 通过写一个函数，使用函数传参数的形式将app传递过来。然后db利用app进行初始化

 def init_ext(app):

     db.init_app(app) # db需要使用传过来的参数app来进行初始化

     migate.init_app(app,db)

models.py

 ''' models.py '''

 from App.extension import db

 class User(db.Model):

     id = db.Column(db.Integer,primary_key=True,autoincrement=True)

     name = db.Column(db.String(32),unique=True)

     password = db.Column(db.String(32))

views.py

 ''' views.py '''

 from flask import Blueprint

 from App.extension import db

 from App.models import User

 blue = Blueprint('blue',__name__)

 def init_blue(app):

     app.register_blueprint(blueprint=blue)

 @blue.route('/')

 def hello_world():

     return 'Hello index!'

 @blue.route('/create/')

 def create():

     db.create_all()

     return '创建成功'

视图拆分

　　选中views.py文件，右击选择Refactor选项，然后选择Convert To Python Package选项。将原来的views.py文件转换成一个包文件。再在这个包文件中去新建需要的view视图文件。

__init.py__

 from App.views.movie_view import movie_blue

 from App.views.user_view import user_blue

 # 蓝图注册初始化

 def init_blue(app):

     app.register_blueprint(blueprint=user_blue)

     app.register_blueprint(blueprint=movie_blue)

user_view.py

 from flask import Blueprint

 from App.extension import db

 from App.models import User

 user_blue = Blueprint('user_blue',__name__,url_prefix="/users/")

 @user_blue.route('/')

 def hello_world():

     return 'User Index!'

 @user_blue.route('/create/')

 def create():

     db.create_all()

     return '创建成功'

movie_view.py

 from flask import Blueprint

 movie_blue = Blueprint("movie_blue",__name__,url_prefix="/movies/")

 @movie_blue.route('/')

 def index():

     return "Movie Index"

模型拆分

　　选中model.py文件，右击选择Refactor选项，然后选择Convert To Python Package选项。

　　将原来的model.py文件转换成一个包文件。再在这个包文件中去新建需要的model模型文件。

__init.py__

# 将各model文件导入到此文件中，作为对外的统一接口设置。

from .user_model import User

from .movie_model import Movie

user_model.py

 from App.extension import db

 class User(db.Model):

     id = db.Column(db.Integer,primary_key=True,autoincrement=True)

     name = db.Column(db.String(32),unique=True)

     password = db.Column(db.String(32))

movie_model.py

 from App.extension import db

 class Movie(db.Model):

     id = db.Column(db.Integer, primary_key=True, autoincrement=True)

     m_name = db.Column(db.String(32))

     m_detail = db.Column(db.String(32))

高级拆分方法 [推荐使用]

　　此方法推荐使用。将每一个功能模块拆分一个包文件，然后再在这个包文件中进行路由视图函数、模型的逻辑书写。今后使用直接copy后，根据需求添加修改就可以

　　day05_chaiAdvanced包文件中是此项目的各种配置。以后想加什么功能模块，就在此文件同级目录创建包文件模块，然后在工程目录下的views.py文件中注册上就可以了。

　　第一块是程序的入口，叫做：manage。

　　第二块是和工程名同名的一个包，里面有__init__.py文件、setting.py文件配置信息、extension.py文件负责扩展库、views.py文件负责路由注册

　　　　__init__.py 文件中，有一个创建app设置，在程序入口manage内调用，

　　　　__init__内：根据设置文件setting.py 加载配置；

　　　　　　　　　　根据扩展库文件extension.py 初始化第三方扩展库；

　　　　　　　　　　根据初始化路由文件views.py 进行加载路由

　　第三块是各个子模块。user包文件、movies包文件.........。各个子模块中又都有自己的 views.py文件和models.py文件

manage.py 文件中

 """ manage.py """

 import os

 from flask_migrate import MigrateCommand

 from flask_script import Manager

 from day05_chaiAdvanced import create_app

 # 从系统环境中获取参数FLASK_ENV的值给env,判断是什么环境下的服务器

 # 避免外人修改代码，方便代码放在什么环境服务器下，就在什么环境下运行

 # 在系统终端 vim .bashrc 编写系统环境变量：#FLASK_ENV。export FLASK_ENV = "develop" 保存退出

 env = os.environ.get("FLASK_ENV") or 'default'

 # 首先创建一个flask对象、加载配置、加载扩展库、初始化路由

 app = create_app(env)

 # flask-scripy扩展

 manager = Manager(app)

 manager.add_command("db",MigrateCommand)

 if __name__ == '__main__':

     manager.run()

day05_chaiAdvanced 包文件中

__init__.py

 ''' __init__.py '''

 from flask import Flask

 from day05_chaiAdvanced.settings import Config, envs

 from day05_chaiAdvanced.extension import init_ext

 from day05_chaiAdvanced.views import init_blue

 def create_app(env):

     # 创建Flask对象

     app = Flask(__name__)

     # 加载初始化配置。 从类对象中加载。env参数确定在什么环境下的

     app.config.from_object(envs.get(env))

     # 加载初始化扩展库。通过懒加载的方式加载(调用函数时参数的传递)

     init_ext(app)

     # 加载初始化路由器。通过懒加载的方式加载(调用函数时参数的传递)

     init_blue(app)

     return app

extension.py

 ''' extension.py '''

 from flask_sqlalchemy import SQLAlchemy

 from flask_migrate import Migrate

 db = SQLAlchemy()

 migate  = Migrate()

 # 通过写一个函数，使用函数传参数的形式将app传递过来。然后db利用app进行初始化

 def init_ext(app):

     db.init_app(app) # db需要使用传过来的参数app来进行初始化

     migate.init_app(app,db)

settings.py

 ''' settings.py '''

 # 对连接数据库的配置信息进行格式化整理

 def get_db_uri(dbinfo):

     database = dbinfo.get("DATABASE")

     driver = dbinfo.get("DRIVER")

     user = dbinfo.get("USER")

     password = dbinfo.get("PASSWORD")

     host = dbinfo.get("HOST")

     port = dbinfo.get("PORT")

     name = dbinfo.get("NAME")

     return "{}+{}://{}:{}@{}:{}/{}".format(database,driver,user,password,host,port,name)

 # 配置信息初始化

 class Config:

     SECRET_KEY = 'asdfghjjkl'  # 随机值。系统可以基于一个密码随机生成随机值，这个值可以用来做密钥：

     DEBUG = False

     TESTING = False

     SQLALCHEMY_TRACK_MODIFICATIONS = False

 # 开发环境

 class DevelopConfig(Config):

     DEBUG = True

     # 数据库信息配置

     dbinfo = {

         "DATABASE": "mysql",

         "DRIVER":"pymysql",

         "USER": "root",

         "PASSWORD": "guoyapeng",

         "HOST": "localhost",

         "PORT": "",

         "NAME": "FlaskModel",

     }

     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)

 # 测试环境

 class TestingConfig(Config):

     TESTING = True

     # 数据库信息配置

     dbinfo = {

         "DATABASE": "mysql",

         "DRIVER":"pymysql",

         "USER": "root",

         "PASSWORD": "guoyapeng",

         "HOST": "localhost",

         "PORT": "",

         "NAME": "FlaskModel",

     }

     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)

 # 演示环境

 class StagingConfig(Config):

     # 数据库信息配置

     dbinfo = {

         "DATABASE": "mysql",

         "DRIVER":"pymysql",

         "USER": "root",

         "PASSWORD": "guoyapeng",

         "HOST": "localhost",

         "PORT": "",

         "NAME": "FlaskProject",

     }

     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)

 # 生产环境

 class ProductConfig(Config):

     # 数据库信息配置

     dbinfo = {

         "DATABASE": "mysql",

         "DRIVER":"pymysql",

         "USER": "root",

         "PASSWORD": "guoyapeng",

         "HOST": "localhost",

         "PORT": "",

         "NAME": "FlaskModelAdvanced",

     }

     SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)

 # 获取在什么环境下，不同环境下数据库不同

 envs = {

     "develop":  DevelopConfig,

     "texting":  TestingConfig,

     "staging":  StagingConfig,

     "product":  ProductConfig,

     "default":  ProductConfig,

 }

 settings.py

settings.py

views.py

 from movies.views import movie_blue

 from users.views import user_blue

 # 创建的模块中的蓝图进行注册初始化

 def init_blue(app):

     app.register_blueprint(blueprint=user_blue)

     app.register_blueprint(blueprint=movie_blue)

movies.py 包文件中

__init__.py 空
models.py

 from day05_chaiAdvanced.extension import db

 class Movie(db.Model):

     id = db.Column(db.Integer, primary_key=True, autoincrement=True)

     m_name = db.Column(db.String(32))

     m_detail = db.Column(db.String(32))

views.py

 from flask import Blueprint

 from .models import Movie 

 movie_blue = Blueprint("movie_blue",__name__,url_prefix="/movies/")

 @movie_blue.route('/')

 def index():

     return "Movie Index"

users.py 包文件中和movies.py 包文件类似。为了实现相应的功能的视图和模型的编写