4. 魔方服务端项目搭建

魔方服务端项目搭建

魔方服务端项目搭建

创建虚拟环境

# 创建mofang虚拟环境
conda create -n mofang python=3.8.5

安装依赖

pip install flask==1.1.4 -i https://pypi.douban.com/simple
pip install flask-redis -i https://pypi.douban.com/simple
pip install flask-session -i https://pypi.douban.com/simple
pip install flask-script -i https://pypi.douban.com/simple
pip install flask-mysqldb -i https://pypi.douban.com/simple
pip install flask-sqlalchemy -i https://pypi.douban.com/simple

创建项目目录结构 - 1

mofangapi/                  # 项目根目录
├── docs/                   # 项目开发文档/接口等备份资料信息存储目录
├── logs/                   # 项目日志存储目录
├── application/            # 项目主要逻辑代码保存目录
|   ├── settings/           # 项目配置存储目录
│   │   ├ dev.py            # 开发阶段的配置文件
│   │   ├ prod.py           # 生产阶段的配置文件
|   |   ├ __init__.py       # 项目公共配置文件
|   ├── utils/              # 工具函数库/类库
│   │   ├ config.py         # 配置相关的辅助函数
│   ├── __init__.py         # 项目初始化文件[全局引导文件,项目入口文件，APP工厂函数]
└── manage.py               # 项目的终端管理脚本文件

在pycharm中打开项目目录mofangapi, settings中配置mofang虚拟环境, 编写manage.py启动项目的文件

manage.py

from flask import Flask
# 初始化
app = Flask(__name__)

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

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

构建全局初始化函数创建app应用对象

全局初始化文件application/__init__.py

from flask import Flask
from flask_script import Manager

# 终端脚本工具初始化
manager = Manager()

def init_app():
    """全局初始化"""
    # 创建app应用对象
    app = Flask(__name__)

    # 终端脚本工具加载配置
    manager.app = app
    
    return manager

主文件manage.py调用初始化函数

from application import init_app

# 引入终端命令实例化Manager对象
manager = init_app()
app = manager.app  # flask的实例化对象

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

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

项目运行

终端命令运行:

python manage.py runserver 
python manage.py runserver -d  # 进入调试模式
python manage.py runserver -h0.0.0.0 -p5000
python manage.py runserver -h0 -p5000

编辑,使用manage文件运行:

pycharm右上角运行标识左边下拉框manage,点击 -> Edit Configurations.. ->Paramets中添加:
	- runserver -h0 -p5000

项目加载配置

编写项目默认配置文件, application/settings/__init__.py代码:

"""公共配置"""
# 调试模式
DEBUG = True

当然, 项目开发过程完成以后肯定会项目上线,所以针对配置文件,我们可以准备不同环境下的配置

开发环境配置application/settings/dev.py

"""开发环境配置"""

# 调试模式
DEBUG = True

线上生产环境配置application/settings/prod.py

"""线上生产环境配置"""

# 调试模式
DEBUG = False

在application/utils/config.py中准备加载配置的函数代码:

"""加载配置"""

def init_config(app, config_path):
    """
    先加载默认配置，然后加载当前指定配置
    主要看传入的config_path：
        - 1.config_path = application.settings.dev
            - 加载开发环境配置
            - settings/__init__公共配置
        - 2.config_path = application.settings.prod
            - 加载线上生产环境配置
            - settings/__init__公共配置
    """
    init_path = ".".join(config_path.split('.')[:-1])
    app.config.from_object(init_path)  # 加载公共配置
    app.config.from_object(config_path) # 加载开发或生产配置

全局初始化文件application/__init__.py 中加载配置:

from flask import Flask
from flask_script import Manager
from application.utils.config import init_config

# 终端脚本工具初始化
manager = Manager()

# 全局初始化
def init_app(config_path):
    """全局初始化 - 需要传入加载开发或生产环境配置路径"""
    # 创建app应用对象
    app = Flask(__name__)

    # 开发或生产环境加载配置
    init_config(app, config_path)

    # 终端脚本工具加载配置
    manager.app = app

    return manager

主文件manage.py中, 实例化对象时设置配置

from application import init_app

# 开发环境配置路径
config_path = 'application.settings.dev'

# 引入终端命令实例化对象
manager = init_app(config_path)
app = manager.app

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

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

数据库初始化

1. SQLAlchemy初始化

默认项目配置文件中增加配置选项application/settings/__init__.py

"""公共配置"""

"""调试模式"""
DEBUG = True

"""SQLAlchem数据库配置"""
# 数据库链接
SQLALCHEMY_DATABASE_URI = ''
# 动态追踪修改设置
SQLALCHEMY_TRACK_MODIFICATIONS = False
# 查询时会显示原始SQL语句
SQLALCHEMY_ECHO = False

在mysql终端下, 创建属于当前项目的数据库管理用户, 命令如下:

# 创建项目使用的数据库
create database mofang charset=utf8mb4;

# 针对项目数据库配置账户信息,创建用户并赋予权限

# mysql8.0之前
create user mofanguser identified by 'mofang'; 
grant all privileges on mofang.* to 'mofanguser'@'%';
flush privileges;

# mysql8.0之后
create user 'mofanguser'@'%' identified with mysql_native_password by 'mofang';
GRANT ALL ON mofang.* TO 'mofanguser'@'%';

开发配置文件application/settings/dev.py中,配置数据库连接信息

"""开发环境配置"""

# 调试模式
DEBUG = True

"""SQLAlchemy数据库配置"""
# 数据库链接
SQLALCHEMY_DATABASE_URI = 'mysql://mofanguser:mofang@127.0.0.1:3306/mofang?charset=utf8mb4'
# 查询时会显示原始SQL语句
SQLALCHEMY_ECHO = True

在项目全局引导文件中,对数据库功能进行初始化,application/__init__.py

from flask import Flask
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
from application.utils.config import init_config

# 终端脚本工具初始化
manager = Manager()

# SQLAlchemy初始化
db = SQLAlchemy()

# 全局初始化
def init_app(config_path):
    """全局初始化 - 需要传入加载开发或生产环境配置路径"""
    # 创建app应用对象
    app = Flask(__name__)

    # 开发或生产环境加载配置
    init_config(app, config_path)

    # SQLAlchemy加载配置
    db.init_app(app)

    # 终端脚本工具加载配置
    manager.app = app

    return manager

2. Redis数据库初始化

默认配置文件,application/settings/__init__py,代码:

"""公共配置"""

"""调试模式"""
DEBUG = True

"""SQLAlchem数据库配置"""
# 数据库链接
SQLALCHEMY_DATABASE_URI = ''
# 动态追踪修改设置
SQLALCHEMY_TRACK_MODIFICATIONS = False
# 查询时会显示原始SQL语句
SQLALCHEMY_ECHO = False

"""redis数据库配置"""
# 默认缓存数据库 - 0号库
REDIS_URL = 'redis://:@127.0.0.1:6379/0'

开发环境配置文件，application/settings/dev.py，代码：

"""开发环境配置"""

# 调试模式
DEBUG = True

"""SQLAlchemy数据库配置"""
# 数据库链接
SQLALCHEMY_DATABASE_URI = 'mysql://mofanguser:mofang@127.0.0.1:3306/mofang?charset=utf8mb4'
# 查询时会显示原始SQL语句
SQLALCHEMY_ECHO = True

"""redis数据库配置"""
# 默认缓存数据库 - 0号库
REDIS_URL = 'redis://:@127.0.0.1:6379/0'
# 验证相关数据 - 1号库
CHECK_URL = 'redis://:@127.0.0.1:6379/1'

在全局引导文件中, 对redis数据库进行初始化,applicaiton/__init__.py,代码:

from flask import Flask
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
from application.utils.config import init_config

# 终端脚本工具初始化
manager = Manager()

# SQLAlchemy初始化
db = SQLAlchemy()

# redis数据库初始化
# - 1.默认缓存数据库对象，配置前缀为REDIS
redis_cache = FlaskRedis(config_prefix='REDIS')
# - 2.验证相关数据库对象，配置前缀为CHECK
redis_check = FlaskRedis(config_prefix='CHECK')


# 全局初始化
def init_app(config_path):
    """全局初始化 - 需要传入加载开发或生产环境配置路径"""
    # 创建app应用对象
    app = Flask(__name__)

    # 开发或生产环境加载配置
    init_config(app, config_path)

    # SQLAlchemy加载配置
    db.init_app(app)

    # redis加载配置
    redis_cache.init_app(app)
    redis_check.init_app(app)

    # 终端脚本工具加载配置
    manager.app = app

    return manager

3. 配置Session存储到redis数据库中

默认配置文件设置SECRET_KEY秘钥, application/settings/__init__.py

"""公共配置"""

"""调试模式"""
DEBUG = True

"""设置加密秘钥"""
# 设置密钥，可以通过 base64.b64encode(os.urandom(48)) 来生成一个指定长度的随机字符串
SECRET_KEY = "RvDsY4u6GRJm4srpe2NUbpxS3R8+5yZRNTcYkx7NtzHpumOK4Wq/+f+qplfxgGld"

"""SQLAlchem数据库配置"""
# 数据库链接
SQLALCHEMY_DATABASE_URI = ''
# 动态追踪修改设置
SQLALCHEMY_TRACK_MODIFICATIONS = False
# 查询时会显示原始SQL语句
SQLALCHEMY_ECHO = False

"""redis数据库配置"""
# 默认缓存数据库 - 0号库
REDIS_URL = 'redis://:@127.0.0.1:6379/0'

开发环境配置文件中.配置session储存的redis数据库 , application/settings/dev.py

"""开发环境配置"""

# 调试模式
DEBUG = True

"""SQLAlchemy数据库配置"""
# 数据库链接
SQLALCHEMY_DATABASE_URI = 'mysql://mofanguser:mofang@127.0.0.1:3306/mofang?charset=utf8mb4'
# 查询时会显示原始SQL语句
SQLALCHEMY_ECHO = True

"""redis数据库配置"""
# 默认缓存数据库 - 0号库
REDIS_URL = 'redis://:@127.0.0.1:6379/0'
# 验证相关数据 - 1号库
CHECK_URL = 'redis://:@127.0.0.1:6379/1'
# session储存数据库 - 2号库
SESSION_URL = 'redis://:@127.0.0.1:6379/2'

"""session数据储存到Redis的配置"""
# 配置session链接方式
SESSION_TYPE = 'redis'
# 如果设置session的生命周期是否是会话期, 为True，则关闭浏览器session就失效
SESSION_PERMANENT = False
# 设置session_id在浏览器中的cookie有效期
PERMANENT_SESSION_LIFETIME = 24 * 60 * 60  # session 的有效期，单位是秒
# 是否对发送到浏览器上session的cookie值进行加密
SESSION_USE_SIGNER = True
# 保存到redis的session数的名称前缀
SESSION_KEY_PREFIX = "session:"

全局引导文件中, 初始化redis数据库, application/__init__.py

from flask import Flask
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
from flask_session import Session

from application.utils.config import init_config

# 终端脚本工具初始化
manager = Manager()

# SQLAlchemy初始化
db = SQLAlchemy()

# redis数据库初始化
# - 1.默认缓存数据库对象，配置前缀为REDIS
redis_cache = FlaskRedis(config_prefix='REDIS')
# - 2.验证相关数据库对象，配置前缀为CHECK
redis_check = FlaskRedis(config_prefix='CHECK')
# - 3.验证相关数据库对象，配置前缀为SESSION
redis_session = FlaskRedis(config_prefix='SESSION')

# session储存配置初始化
session_store = Session()

# 全局初始化
def init_app(config_path):
    """全局初始化 - 需要传入加载开发或生产环境配置路径"""
    # 创建app应用对象
    app = Flask(__name__)

    # 开发或生产环境加载配置
    init_config(app, config_path)

    # SQLAlchemy加载配置
    db.init_app(app)

    # redis加载配置
    redis_cache.init_app(app)
    redis_check.init_app(app)
    redis_session.init_app(app)

    """一定先加载默认配置，再传入APP加载session对象"""
    # session保存数据到redis时启用的链接对象
    app.config["SESSION_REDIS"] = redis_session
    # session存储对象加载配置
    session_store.init_app(app)


    # 终端脚本工具加载配置
    manager.app = app

    return manager

日志初始化

flask中本身内置了基于loging模块封装的日志功能的,我们在使用的时候, 一般日志如果不是核心重点,则通过由python内置的logging模块进行配置集成使用即可, 如果项目中日志发挥作用比较重要, 则一般安装部署ELK日志分析系统.

日志的等级

从高到低，依次：
	FATAL/CRITICAL = 致命的，危险的
	ERROR = 错误
	WARNING = 警告
	INFO = 信息
	DEBUG = 调试

flask日志功能的基本使用

app.logger.fatal("致命")    # [2021-05-28 17:44:08,524] CRITICAL in manage: 致命
app.logger.error("错误")    # [2021-05-28 17:42:41,597] ERROR in manage: 错误
app.logger.warning("警告")  # [2021-05-28 17:43:34,401] WARNING in manage: 警告

# debug模式关闭了以后，info和debug等级的日志记录不会输出了
app.logger.info("运行信息")  # [2021-05-28 17:44:39,914] INFO in manage: 运行信息
app.logger.debug("调试信息") # [2021-05-28 17:45:01,131] DEBUG in manage: 调试信息

在项目运行时，框架本身会不断记录代码程序运行的日志错误，我们在这里新建一个日志记录器，专门只是记录我们业务逻辑的相关日志。

构建日志模块

开发环境配置文件写入日志的基本信息, application/settings/dev.py

"""开发环境配置"""

# 调试模式
DEBUG = True

"""SQLAlchemy数据库配置"""
# 数据库链接
SQLALCHEMY_DATABASE_URI = 'mysql://mofanguser:mofang@127.0.0.1:3306/mofang?charset=utf8mb4'
# 查询时会显示原始SQL语句
SQLALCHEMY_ECHO = True

"""redis数据库配置"""
# 默认缓存数据库 - 0号库
REDIS_URL = 'redis://:@127.0.0.1:6379/0'
# 验证相关数据 - 1号库
CHECK_URL = 'redis://:@127.0.0.1:6379/1'
# session储存数据库 - 2号库
SESSION_URL = 'redis://:@127.0.0.1:6379/2'

"""session数据储存到Redis的配置"""
# 配置session链接方式
SESSION_TYPE = 'redis'
# 如果设置session的生命周期是否是会话期, 为True，则关闭浏览器session就失效
SESSION_PERMANENT = False
# 设置session_id在浏览器中的cookie有效期
PERMANENT_SESSION_LIFETIME = 24 * 60 * 60  # session 的有效期，单位是秒
# 是否对发送到浏览器上session的cookie值进行加密
SESSION_USE_SIGNER = True
# 保存到redis的session数的名称前缀
SESSION_KEY_PREFIX = "session:"

"""日志基本信息配置"""
LOG_LEVEL = 'INFO'              # 日志输出到文件中的等级
LOG_DIR = '/logs/mofang.log'    # 日志存储路径
LOG_BACKPU_COUNT = 20           # 日志文件的最大备份数量
LOG_NAME = 'mofang'             # 日志器的名字，flask的名为：flask.app

把日志初始化相关的代码封装成一个日志类，application/utils/logger.py，

"""日志模块配置"""
import logging
from logging.handlers import TimedRotatingFileHandler

class Log():
    """日志模块"""
    def __init__(self, app=None):
        if app is not None:
            self.init_app(app)

    def init_app(self, app):
        self.app = app
        return self.setup()

    def setup(self):
        """集成日志功能到flask项目中"""
        # 设置日志的记录等级
        logging.basicConfig(level=self.app.config.get('LOG_LEVEL'))

        # 创建日志记录器，指明日志保存的路径、每个日志文件的最大大小、保存的日志文件个数上限
        file_log_handler = TimedRotatingFileHandler(
            filename=self.app.BASE_DIR + self.app.config.get('LOG_DIR'),
            when='midnight',# 每天新增日志的时间，午夜
            backupCount=self.app.config.get('LOG_BACKPU_COUNT') # 日志文件的最大备份数量
        )

        # 创建日志记录的格式 日志记录器 日志等级 发生时间 输入日志信息的文件名 行数 日志信息
        formatter = logging.Formatter('%(name)s: %(levelname)s %(asctime)s %(filename)s:%(lineno)d %(message)s')
        # 为刚创建的日志记录器设置日志记录格式
        file_log_handler.setFormatter(formatter)
        # 为全局的日志工具对象（flaskapp使用的）添加日志记录器
        logging.getLogger(self.app.config.get("LOG_NAME")).addHandler(file_log_handler)
        # 返回日志器对象提供给业务开发
        logger = logging.getLogger(self.app.config.get("LOG_NAME"))
        # 给flask默认的日志记录器增加写入日志到logs
        self.app.logger.addHandler(file_log_handler)

        return logger

在项目引入文件加载初始化日志配置, application/__init__.py

import os

from flask import Flask
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
from flask_session import Session

from application.utils.config import init_config
from application.utils.logger import Log

# 终端脚本工具初始化
manager = Manager()

# SQLAlchemy初始化
db = SQLAlchemy()

# redis数据库初始化
# - 1.默认缓存数据库对象，配置前缀为REDIS
redis_cache = FlaskRedis(config_prefix='REDIS')
# - 2.验证相关数据库对象，配置前缀为CHECK
redis_check = FlaskRedis(config_prefix='CHECK')
# - 3.验证相关数据库对象，配置前缀为SESSION
redis_session = FlaskRedis(config_prefix='SESSION')

# session储存配置初始化
session_store = Session()

# 自定义日志初始化
logger = Log()


# 全局初始化
def init_app(config_path):
    """全局初始化 - 需要传入加载开发或生产环境配置路径"""
    # 创建app应用对象
    app = Flask(__name__)

    # 当前项目根目录 - 日志加载配置时需要
    app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

    # 开发或生产环境加载配置
    init_config(app, config_path)

    # SQLAlchemy加载配置
    db.init_app(app)

    # redis加载配置
    redis_cache.init_app(app)
    redis_check.init_app(app)
    redis_session.init_app(app)

    """一定先加载默认配置，再传入APP加载session对象"""
    # session保存数据到redis时启用的链接对象
    app.config["SESSION_REDIS"] = redis_session
    # session存储对象加载配置
    session_store.init_app(app)

    # 为日志对象加载配置
    log = logger.init_app(app)
    app.log = log

    # 终端脚本工具加载配置
    manager.app = app

    return manager

蓝图初始化

在application下创建apps目录，apps以后专门用于保存项目的每一个蓝图,并在apps创建home蓝图目录

自定义终端命令生成蓝图目录结构

通过自定义终端命令, 创建一个自动生成蓝图目录的命令.application/utils/commands.py

import os, inspect

from flask_script import Command, Option
from importlib import import_module

# 自定义注册命令
def load_commands(manager, command_path=None):
    """根据指定导包路径注册自定义命令到manage中"""
    if command_path is None:
        command_path = 'application.utils.commands'

    # 根据路径导包
    module = import_module(command_path)

    # 提前文件中所有命令类成员
    class_list = inspect.getmembers(module, inspect.isclass)
	# print( class_list )
    """
    [
        ('BlueprintCommand', <class 'application.utils.commands.BlueprintCommand'>), 
        ('Command', <class 'flask_script.commands.Command'>), 
        ('Option', <class 'flask_script.commands.Option'>)
    ]
    """
    for item in class_list:
        # 判断命令类是否是Command的子类，以为Command也是Command的子类，所有去除Command命令类注册
        if issubclass(item[1],Command) and item[0] != 'Command':
            # 注册命令类到manage中
            manager.add_command(item[1].name, item[1])

# 生成蓝图目录结构
class BlueprintCommand(Command):
    # 生成蓝图命令名称
    name = 'blue'

    # 传递参数
    option_list = [
        Option('-n', '--name', dest='name'),
    ]

    # 运行程序
    def run(self, name):
        # 生成蓝图目录结构
        os.mkdir(name)
        open(f'{name}/__init__.py', 'w')
        open(f'{name}/views.py', 'w')
        open(f'{name}/models.py', 'w')
        open(f'{name}/urls.py', 'w')
        open(f'{name}/test.py', 'w')
        open(f'{name}/api.py', 'w')
        open(f'{name}/socket.py', 'w')
        open(f'{name}/tasks.py', 'w')

        print(f'蓝图{name}创建完成...')

项目引入文调用load_command函数注册命令, application/__init__.py

import os

from flask import Flask
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
from flask_session import Session

from application.utils.config import init_config
from application.utils.logger import Log
from application.utils.commands import load_commands

# 终端脚本工具初始化
manager = Manager()

# SQLAlchemy初始化
db = SQLAlchemy()

# redis数据库初始化
# - 1.默认缓存数据库对象，配置前缀为REDIS
redis_cache = FlaskRedis(config_prefix='REDIS')
# - 2.验证相关数据库对象，配置前缀为CHECK
redis_check = FlaskRedis(config_prefix='CHECK')
# - 3.验证相关数据库对象，配置前缀为SESSION
redis_session = FlaskRedis(config_prefix='SESSION')

# session储存配置初始化
session_store = Session()

# 自定义日志初始化
logger = Log()


# 全局初始化
def init_app(config_path):
    """全局初始化 - 需要传入加载开发或生产环境配置路径"""
    # 创建app应用对象
    app = Flask(__name__)

    # 当前项目根目录
    app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

    # 开发或生产环境加载配置
    init_config(app, config_path)

    # SQLAlchemy加载配置
    db.init_app(app)

    # redis加载配置
    redis_cache.init_app(app)
    redis_check.init_app(app)
    redis_session.init_app(app)

    """一定先加载默认配置，再传入APP加载session对象"""
    # session保存数据到redis时启用的链接对象
    app.config["SESSION_REDIS"] = redis_session
    # session存储对象加载配置
    session_store.init_app(app)

    # 为日志对象加载配置
    log = logger.init_app(app)
    app.log = log

    # 终端脚本工具加载配置
    manager.app = app

    # 自动注册自定义命令
    load_commands(manager)

    return manager

cd application/apps
python ../../manage.py blue -nhome

注册蓝图

在开发环境中,建立一个待注册的蓝图应用路径列表, application/settings/dev.py

"""待注册的蓝图应用路径列表"""
INSTALL_BLUEPRINT = [
    'application.apps.home',
]

在application.utils.blueprint.py模块中声明一个resgister_blueprint函数,函数中针对注册到项目配置文件中的INSTALL_BLUEPRINT蓝图列表选项的蓝图内容实现自动注册到app应用对象里面。

from flask import Blueprint

# 自动注册蓝图
def register_blueprint(app):
    # 从配置文件中读取需要注册到项目中的蓝图路径信息
    blueprint_path_list = app.config.get('INSTALL_BLUEPRINT')

    # 遍历蓝图路径列表，对每一个蓝图进行初始化
    for blueprint_path in blueprint_path_list:
        # 获取蓝图路径中最后一段的包名作为蓝图的名称
        blueprint_name = blueprint_path.split('.')[-1]

        # 创建蓝图对象
        blueprint = Blueprint(blueprint_name, blueprint_path)

        # 把蓝图对象注册到app实例对象
        # todo url_prefix 是地址前缀，将来我们将来实现一个总路由来声明它
        app.register_blueprint(blueprint, url_prefix="")

项目引入文件中,调用resgister_blueprint函数,实现自动注册蓝图

application/__init__.py

import os

from flask import Flask
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
from flask_session import Session

from application.utils.config import init_config
from application.utils.logger import Log
from application.utils.commands import load_commands
from application.utils.bluerprint import register_blueprint


# 终端脚本工具初始化
manager = Manager()

# SQLAlchemy初始化
db = SQLAlchemy()

# redis数据库初始化
# - 1.默认缓存数据库对象，配置前缀为REDIS
redis_cache = FlaskRedis(config_prefix='REDIS')
# - 2.验证相关数据库对象，配置前缀为CHECK
redis_check = FlaskRedis(config_prefix='CHECK')
# - 3.验证相关数据库对象，配置前缀为SESSION
redis_session = FlaskRedis(config_prefix='SESSION')

# session储存配置初始化
session_store = Session()

# 自定义日志初始化
logger = Log()


# 全局初始化
def init_app(config_path):
    """全局初始化 - 需要传入加载开发或生产环境配置路径"""
    # 创建app应用对象
    app = Flask(__name__)

    # 当前项目根目录
    app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

    # 开发或生产环境加载配置
    init_config(app, config_path)

    # SQLAlchemy加载配置
    db.init_app(app)

    # redis加载配置
    redis_cache.init_app(app)
    redis_check.init_app(app)
    redis_session.init_app(app)

    """一定先加载默认配置，再传入APP加载session对象"""
    # session保存数据到redis时启用的链接对象
    app.config["SESSION_REDIS"] = redis_session
    # session存储对象加载配置
    session_store.init_app(app)

    # 为日志对象加载配置
    log = logger.init_app(app)
    app.log = log

    # 自动注册蓝图
    register_blueprint(app)

    # 终端脚本工具加载配置
    manager.app = app

    # 自动注册自定义命令
    load_commands(manager)

    return manager

注册蓝图的路由和视图

application/utils/blueprint.py中生成path函数,把url地址和视图方法映射关系处理成字典

from flask import Blueprint

# 自动注册蓝图
def register_blueprint(app):
    # 从配置文件中读取需要注册到项目中的蓝图路径信息
    blueprint_path_list = app.config.get('INSTALL_BLUEPRINT')

    # 遍历蓝图路径列表，对每一个蓝图进行初始化
    for blueprint_path in blueprint_path_list:
        # 获取蓝图路径中最后一段的包名作为蓝图的名称
        blueprint_name = blueprint_path.split('.')[-1]

        # 创建蓝图对象
        blueprint = Blueprint(blueprint_name, blueprint_path)

        # 把蓝图对象注册到app实例对象
        # todo url_prefix 是地址前缀，将来我们将来实现一个总路由来声明它
        app.register_blueprint(blueprint, url_prefix="")
        
# 把url地址和视图方法映射关系处理成字典   
def path(rule, view_func, **kwargs):
    """绑定url地址和视图的映射关系"""
    data = {
        'rule':rule,
        'view_func':view_func,
        **kwargs
    }
    return data

在application.__init__入口文件中，导入path路由映射函数，将来方便再其他地方调用该函数

from application.utils.bluerprint import register_blueprint, path

在home蓝图下的urls.py中,使用path函数绑定视图和路由的映射关系并添加urlpatterns中,home.urls.py

from application import path
# 引入当前蓝图应用视图
from . import views

urlpatterns = [
    path('/index', views.index, methods=['post']),
    path('/demo', views.demo)
]

为了方便测试，先到当前home蓝图下视图文件views.py中，添加2个测试的视图

def index():
    return 'home/views hello!!'

def demo():
    return 'home.views.demo ok'

蓝图注册函数register_blueprint中, 生成蓝图对象以后自动加载并注册蓝图的路由和视图

application/utils/blueprint.py

from flask import Blueprint
# 引入导包函数
from importlib import import_module

# 自动注册蓝图
def register_blueprint(app):
    # 从配置文件中读取需要注册到项目中的蓝图路径信息
    blueprint_path_list = app.config.get('INSTALL_BLUEPRINT')

    # 遍历蓝图路径列表，对每一个蓝图进行初始化
    for blueprint_path in blueprint_path_list:
        # 获取蓝图路径中最后一段的包名作为蓝图的名称
        blueprint_name = blueprint_path.split('.')[-1]
        # 创建蓝图对象
        blueprint = Blueprint(blueprint_name, blueprint_path)

        # 导入子路由关系，blueprint_url_path就是当前蓝图下的urls模块的导包路径
        blueprint_url_path = blueprint_path + '.urls'
        # 导包
        urls_module = import_module(blueprint_url_path)
        # 获取urls模块下路由列表urlpatterns
        urlpatterns = urls_module.urlpatterns
        # 把urlpatterns的每一个路由信息添加注册到蓝图对象里面
        for url in urlpatterns:
            blueprint.add_url_rule(**url)


        # 把蓝图对象注册到app实例对象
        # todo url_prefix 是地址前缀，将来我们将来实现一个总路由来声明它
        app.register_blueprint(blueprint, url_prefix="")

# 把url地址和视图方法映射关系处理成字典
def path(rule, view_func, **kwargs):
    """绑定url地址和视图的映射关系"""
    data = {
        'rule':rule,
        'view_func':view_func,
        **kwargs
    }
    return data

此时,运行项目，就可以通过url地址访问蓝图下的视图方法了,postman中

# get方法:
http://0.0.0.0:5000/demo
# post方法
http://0.0.0.0:5000/index

上面蓝图注册到app示例对象时, 没有设置url_prefix路由前缀, 接下来我们可以单独设置一个总路由application/urls.py,进行路由前缀的设置.

(1) 项目默认配置文件中,新增总路由的配置路径,application/settings/__init__.py

"""总路由"""
URL_PATH = "application.urls"

(2) 创建include函数，负责把路由前缀和蓝图进行绑定映射，application.utils.blueprint，

# 路由前缀和蓝图进行绑定映射
def include(url_prefix, blueprint_url_subfix):
    """

    :param url_prefix: 路由前缀
    :param blueprint_url_subfix: 蓝图路由，
            格式：蓝图包名.路由模块名
            例如：蓝图目录是home, 路由模块名是urls，则参数：home.urls
    :return:
    """
    data = {
        "url_prefix": url_prefix,
        "blueprint_url_subfix": blueprint_url_subfix
    }
    return data

在application.__init__入口文件中，导入include函数，将来方便再其他地方调用该函数

from application.utils.bluerprint import register_blueprint, path, include

(3) 总路由文件注册蓝图和路由前缀的关系到列表中, application/urls.py,

from application import include

# 蓝图子路由列表
urlpatterns = [
    include('/home','home.urls')
]

(4) 接下来，就可以在注册蓝图时，把路由前缀随着蓝图对象一起注册到app实例对象中

application/utils/blueprint.py

from flask import Blueprint
# 引入导包函数
from importlib import import_module

# 自动注册蓝图
def register_blueprint(app):
    # 从配置文件中读取总路由路径信息
    app_urls_path = app.config.get('URL_PATH')
    # 导包，导入总路由模块
    app_urls_module = import_module(app_urls_path)
    # 获取总路由列表
    app_urlpatterns = app_urls_module.urlpatterns

    # 从配置文件中读取需要注册到项目中的蓝图路径信息
    blueprint_path_list = app.config.get('INSTALL_BLUEPRINT')
    # 遍历蓝图路径列表，对每一个蓝图进行初始化
    for blueprint_path in blueprint_path_list:
        # 获取蓝图路径中最后一段的包名作为蓝图的名称
        blueprint_name = blueprint_path.split('.')[-1]
        # 创建蓝图对象
        blueprint = Blueprint(blueprint_name, blueprint_path)

        # 蓝图路由的前缀
        url_prefix = ""
        # 蓝图下的子路由列表
        urlpatterns = []

        # 获取蓝图的父级目录, 即application/apps
        blueprint_father_path =  ".".join( blueprint_path.split(".")[:-1] )
        # 循环总路由列表
        for item in app_urlpatterns:
            # 判断当前蓝图是否在总路由列表中
            if blueprint_name in item["blueprint_url_subfix"]:
                # 导入蓝图下的子路由模块
                urls_module = import_module(blueprint_father_path + "." + item["blueprint_url_subfix"])
                # 获取urls模块下路由列表urlpatterns
                urlpatterns = urls_module.urlpatterns
                # 提取蓝图路由的前缀
                url_prefix = item["url_prefix"]
                # 从总路由中查到当前蓝图对象的前缀就不要继续往下遍历了
                break

        for url in urlpatterns:
            blueprint.add_url_rule(**url)

        # 把蓝图对象注册到app实例对象,并添加路由前缀
        app.register_blueprint(blueprint, url_prefix=url_prefix)

# 把url地址和视图方法映射关系处理成字典
def path(rule, view_func, **kwargs):
    """绑定url地址和视图的映射关系"""
    data = {
        'rule':rule,
        'view_func':view_func,
        **kwargs
    }
    return data

# 路由前缀和蓝图进行绑定映射
def include(url_prefix, blueprint_url_subfix):
    """

    :param url_prefix: 路由前缀
    :param blueprint_url_subfix: 蓝图路由，
            格式：蓝图包名.路由模块名
            例如：蓝图目录是home, 路由模块名是urls，则参数：home.urls
    :return:
    """
    data = {
        "url_prefix": url_prefix,
        "blueprint_url_subfix": blueprint_url_subfix
    }
    return data

注册蓝图的模型

在蓝图home下的models.py中声明模型,例如：

from application import db
class User(db.Model):
    __tablename__ = "mf_user"
    id = db.Column(db.Integer, primary_key=True, comment="主键ID")
    name = db.Column(db.String(255), unique=True, comment="账户名")
    password = db.Column(db.String(255), comment="登录密码")
    ip_address = db.Column(db.String(255), index=True, comment="登录IP")

    def __repr__(self):
        return self.name

在自动注册蓝图对象时,导入模型，让flask识别到。

application/utils/blueprint.py

from flask import Blueprint
# 引入导包函数
from importlib import import_module

# 自动注册蓝图
def register_blueprint(app):
    # 从配置文件中读取总路由路径信息
    app_urls_path = app.config.get('URL_PATH')
    # 导包，导入总路由模块
    app_urls_module = import_module(app_urls_path)
    # 获取总路由列表
    app_urlpatterns = app_urls_module.urlpatterns

    # 从配置文件中读取需要注册到项目中的蓝图路径信息
    blueprint_path_list = app.config.get('INSTALL_BLUEPRINT')
    # 遍历蓝图路径列表，对每一个蓝图进行初始化
    for blueprint_path in blueprint_path_list:
        # 获取蓝图路径中最后一段的包名作为蓝图的名称
        blueprint_name = blueprint_path.split('.')[-1]
        # 创建蓝图对象
        blueprint = Blueprint(blueprint_name, blueprint_path)

        # 蓝图路由的前缀
        url_prefix = ""
        # 蓝图下的子路由列表
        urlpatterns = []

        # 获取蓝图的父级目录, 即application/apps
        blueprint_father_path =  ".".join( blueprint_path.split(".")[:-1] )
        # 循环总路由列表,获取当前蓝图的路由列表和路由前缀
        for item in app_urlpatterns:
            # 判断当前蓝图是否在总路由列表中
            if blueprint_name in item["blueprint_url_subfix"]:
                # 导入蓝图下的子路由模块
                urls_module = import_module(blueprint_father_path + "." + item["blueprint_url_subfix"])
                # 获取urls模块下路由列表urlpatterns
                urlpatterns = urls_module.urlpatterns
                # 提取蓝图路由的前缀
                url_prefix = item["url_prefix"]
                # 从总路由中查到当前蓝图对象的前缀就不要继续往下遍历了
                break

        # 注册蓝图路由
        for url in urlpatterns:
            blueprint.add_url_rule(**url)

        # 导入蓝图模型
        import_module(blueprint_path + '.models')

        # 把蓝图对象注册到app实例对象,并添加路由前缀
        app.register_blueprint(blueprint, url_prefix=url_prefix)

# 把url地址和视图方法映射关系处理成字典
def path(rule, view_func, **kwargs):
    """绑定url地址和视图的映射关系"""
    data = {
        'rule':rule,
        'view_func':view_func,
        **kwargs
    }
    return data

# 路由前缀和蓝图进行绑定映射
def include(url_prefix, blueprint_url_subfix):
    """

    :param url_prefix: 路由前缀
    :param blueprint_url_subfix: 蓝图路由，
            格式：蓝图包名.路由模块名
            例如：蓝图目录是home, 路由模块名是urls，则参数：home.urls
    :return:
    """
    data = {
        "url_prefix": url_prefix,
        "blueprint_url_subfix": blueprint_url_subfix
    }
    return data

在项目入口文件中通过 db的 create_all() 创建数据表。application/__init__.py，

import os

from flask import Flask
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
from flask_redis import FlaskRedis
from flask_session import Session

from application.utils.config import init_config
from application.utils.logger import Log
from application.utils.commands import load_commands
from application.utils.bluerprint import register_blueprint, path, include


# 终端脚本工具初始化
manager = Manager()

# SQLAlchemy初始化
db = SQLAlchemy()

# redis数据库初始化
# - 1.默认缓存数据库对象，配置前缀为REDIS
redis_cache = FlaskRedis(config_prefix='REDIS')
# - 2.验证相关数据库对象，配置前缀为CHECK
redis_check = FlaskRedis(config_prefix='CHECK')
# - 3.验证相关数据库对象，配置前缀为SESSION
redis_session = FlaskRedis(config_prefix='SESSION')

# session储存配置初始化
session_store = Session()

# 自定义日志初始化
logger = Log()


# 全局初始化
def init_app(config_path):
    """全局初始化 - 需要传入加载开发或生产环境配置路径"""
    # 创建app应用对象
    app = Flask(__name__)

    # 当前项目根目录
    app.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

    # 开发或生产环境加载配置
    init_config(app, config_path)

    # SQLAlchemy加载配置
    db.init_app(app)

    # redis加载配置
    redis_cache.init_app(app)
    redis_check.init_app(app)
    redis_session.init_app(app)

    """一定先加载默认配置，再传入APP加载session对象"""
    # session保存数据到redis时启用的链接对象
    app.config["SESSION_REDIS"] = redis_session
    # session存储对象加载配置
    session_store.init_app(app)

    # 为日志对象加载配置
    log = logger.init_app(app)
    app.log = log

    # 自动注册蓝图
    register_blueprint(app)

    # 注册模型，创建表
    with app.app_context():
        db.create_all()

    # 终端脚本工具加载配置
    manager.app = app

    # 自动注册自定义命令
    load_commands(manager)

    return manager

此时创建项目目录结构 - 2

mofang						# 项目根目录
├── application/            # 项目主要逻辑代码保存目录
|   ├── settings/           # 项目配置存储目录
│   │   ├ __init__.py       # 项目默认初始化配置文件
│   │   ├ dev.py            # 开发阶段的配置文件
│   │   └ prod.py           # 生产阶段的配置文件
│   ├── __init__.py         # 项目初始化全局引导文件
|   ├── utils/              # 项目工具类库目录
│   │   ├ blueprint.py      # 蓝图注册相关的函数
│   │   ├ commands.py       # 自定义命令和加载命令的相关函数
│   │   ├ config.py         # 项目配置加载的辅助函数
│   │   └ logger.py         # 日志模块
│   ├── apps/               # 保存项目中所有蓝图的存储目录
│   │   ├── home            # 蓝图目录【这里是举例而已】
│   │   │   ├── __init__.py # 蓝图的初始化文件
│   │   │   ├── urls.py     # 蓝图的子路由文件
│   │   │   ├── models.py   # 蓝图的模型文件
│   │   │   └── views.py    # 蓝图的视图文件
│   │   ├── __init__.py
│   └── urls.py              # 总路由
├── manage.py               # 项目的终端管理脚本文件