# ch06 · 可维护性：工厂、蓝图、配置、CLI

> 来源：教材配套 PPT《第六章 如何使程序易于维护.pptx》，共 75 页。本节只摘录**知识点与关键文字**，图取自 PPT 原页。

## 第 1 页 · 讲师：谢福财

- 讲师：谢福财
- Flask课程——
- **第六章**
- 如何使程序易于维护

![第1页图](media/ch06/slide01_img1.png)

## 第 2 页 · 掌握合理地安排项目结构的方法

- 掌握合理地安排项目结构的方法
- 掌握使用配置文件完成应用实例
- 配置的方法
- 掌握蓝图的基本使用方法
- 掌握Flask-Login的基本使用方法
- 学习目标

![第2页图](media/ch06/slide02_img1.png)

## 第 3 页 · 教学重点

- 教学重点
- 教学难点
- 第1章的引言提到，Flask微框架的“微”并不是指把整个Web应用放入一个Python文件，而是指Flask旨在保持代码简洁且易于扩展。但在第3、4、5章的实例中，为方便读者调试、理解代码，大部分代码都是以单文件的方式编写的。本章将会以实用项目的结构进行介绍，并“保持代码简洁且易于扩展”。
- 教学重难点

## 第 4 页 · 模块化开发

- 模块化开发
- 配置文件
- 项目结构
- Flask-Login
- 小结
- 管理员注册

## 第 5 页 · 配置文件

- 配置文件
- 01

## 第 6 页 · 配置文件

- 配置文件
- 在前几章的程序中，应用初始化时都会有诸如以下的代码。
- app.config['SECRET_KEY'] = 'Chapter5'
- app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path. join(basedir, 'data.sqlite')
- app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
- 这些代码都是用于定义应用实例的一些参数、属性的，可以通过建立配置类，将这些零碎的配置项整合在一起，并可以通过类继承的方式建立多套配置方案，来实现不同环境下所需的设定。

## 第 7 页 · 配置文件

- 配置文件
- 以下是配置文件（config.py）的代码实现。
- import os
- basedir = os.path.abspath(os.path.dirname(__file__))
- # 配置类基类，用于定义一些固定的参数
- class Config:
- SECRET_KEY = 'Chapter6'
- SQLALCHEMY_TRACK_MODIFICATIONS = False
- # 可在初始化时用于执行自定义操作
- @staticmethod
- def init_app(app):
- pass
- @staticmethod: 这是 Python 中的装饰器，用于将下面的 init_app 方法定义为一个静态方法，它不依赖于类的实例而可以直接调用。
- def init_app(app): 这是一个静态方法，接受一个参数 app，代表 Flask 应用程序。它通常用于在应用程序初始化时执行一些自定义操作。该方法被设置为 pass，即不执行任何操作。

## 第 8 页 · 配置文件

- 配置文件
- # 开发环境下所使用的配置类
- class DevelopmentConfig(Config):
- DEBUG = True
- SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'data-dev.sqlite')
- # 测试环境下所使用的配置类
- class TestingConfig(Config):
- TESTING = True
- SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'data-test.sqlite')
- # 生产环境下所使用的配置类
- class ProductionConfig(Config):
- SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'data.sqlite')
- # configs用于映射不同环境下所使用的不同配置类
- configs = dict(
- development=DevelopmentConfig,
- testing=TestingConfig,
- production=ProductionConfig,
- )
- 这里写了三个不同环境的配置类，根据应用程序在不同环境中的运行情况，配置不同的参数和选项，以确保应用程序在各种环境下表现良好。

## 第 9 页 · 配置文件

- 配置文件
- set FLASK_ENV=development
- 配置文件编写完成之后，便是要使应用加载相应的配置。通常情况下，可以根据环境变量FLASK_ENV获取到当前使用的环境（development、testing、production），也可以使用Flask提供的助手函数get_env()获取。
- 环境变量FLASK_ENV可在命令提示符窗口中通过set指令进行设置，设置方法如下所示。
- 接着就是应用加载配置的代码，代码如下。
- from flask import Flask
- from flask.helpers import get_env
- from config import configs
- app = Flask(__name__)
- # 加载应用配置
- env = get_env()
- config = configs.get(env)
- app.config.from_object(config)
- config.init_app(app)

## 第 10 页 · 配置文件

- 配置文件
- 在默认情况下，如果直接处于命令提示符窗口中，app.env的值为“production”，即生产环境；如果通过PyCharm启动，则app.env的值默认为“development”，即开发环境。
- 如果需要对应用进行测试，可以在PyCharm中建立一套新的运行配置，指定FLASK_ENV的值（即app.env）为“testing”，步骤如下图所示。

![第10页图](media/ch06/slide10_img1.png)

## 第 11 页 · 配置文件

- 配置文件

![第11页图](media/ch06/slide11_img1.png)

![第11页图](media/ch06/slide11_img2.png)

## 第 12 页 · 配置文件

- 配置文件
- 配置建立完成后，选中新配置运行，可以发现环境变量变成了“testing”，如下图所示。

![第12页图](media/ch06/slide12_img1.png)

## 第 13 页 · 项目结构

- 项目结构
- 02

## 第 14 页 · 项目结构

- 项目结构
- 相信各位同学在之前章节的例子中，也隐隐约约发现了所有内容都整合在一起的结构是不利于维护的。Flask没有固定的结构，程序要如何设计都取决于开发者。这节主要以基于模块划分的结构进行演示。内容较多，如下图所示。

![第14页图](media/ch06/slide14_img1.png)

![第14页图](media/ch06/slide14_img2.png)

## 第 15 页 · 项目结构

- 项目结构
- 在接下来的内容中，将基于以上结构来进行开发。由于文件数量较多，过于零碎化，不便于将所有文件内容直接在文中展示，详情请参考书本所提供的样例代码。

## 第 16 页 · 项目结构

- 项目结构
- **2.1应用管理入口**
- 书本上5.2.2小节简单介绍了使用Manager对应用进行托管的方法，即作为应用管理入口。使用Manager托管可以很方便地将应用功能（如Migrate、Shell等）联系在一起。本小节将会把Manager部分的代码单独拆分到一个文件，以便于维护。
- 以下是应用管理入口文件（manage.py）的部分代码实现。
- from flask.helpers import get_env
- from flask_migrate import MigrateCommand
- from flask_script import Manager, Shell
- from app import create_app, db, dh
- # 根据相应的环境创建应用实例，并初始化Manager
- env = get_env()
- app = create_app(env)
- manager = Manager(app)

## 第 17 页 · 项目结构

- 项目结构
- 接着是注册指令的代码，代码如下所示。
- def make_shell_context():
- context = dict(
- db=db,
- dh=dh,
- )
- # 将所有模型注册到交互Shell
- context.update((cls.__name__, cls) for cls in dh.get_all_model_ classes())
- return context
- # 注册指令到Manager
- manager.add_command("shell", Shell(make_context=make_shell_context))
- manager.add_command('db', MigrateCommand)
- if __name__ == '__main__':
- manager.run()
- 由上述代码可见，应用管理入口文件仅包含了创建Manager所需的基本代码，相当简洁。应用实例就由下一小节来实现。

## 第 18 页 · 项目结构

- 项目结构
- **2.2 应用“工厂”函数**
- 一个完整的Flask应用不只有应用实例本身，应用根据业务需求，往往依赖于多个模块辅助。即初始化应用时，还需要初始化其相关的依赖模块。单独分析每一个模块的初始化代码相当简单，但将所有模块的初始化代码整合在一起，就比较复杂了。而且，在不同的环境下创建应用，需要加载不同的配置类。
- 根据以上需求，常见的解决方案便是建立应用“工厂”函数，将所有关于初始化应用、相关模块的内容整合在一起，以便于维护。

## 第 19 页 · 项目结构

- 项目结构
- 首先将之前所创建的app.py文件删除，然后建立一个名为“app”的Python包（Python Package），使用Python包可以更方便地扩展应用功能，如下图所示。
- 注意：建立Python包后，需要将“templates”与“static”目录移动至“app”目录内。

![第19页图](media/ch06/slide19_img1.png)

## 第 20 页 · 项目结构

- 项目结构
- 以下是应用“工厂”函数（app/__init__.py）的代码实现。
- from flask import Flask
- from flask_bootstrap import Bootstrap
- from flask_migrate import Migrate
- from flask_sqlalchemy import SQLAlchemy
- from config import configs
- from .database import DatabaseHelper
- # 对象在函数外创建，以便在其他文件中引用
- bootstrap = Bootstrap()
- db = SQLAlchemy()
- migrate: Migrate
- # 创建数据库助手类实例
- dh = DatabaseHelper(db)
- 首先是引入了所需要的扩展，都是之前的内容，大家如果不记得了可以回顾一下之前学习的知识。

## 第 21 页 · 项目结构

- 项目结构
- 接着就是将创建应用的流程，封装为一个函数，方便我们去管理。代码如下。
- def create_app(env):
- app = Flask(__name__)
- # 加载应用配置
- config = configs.get(env)
- app.config.from_object(config)
- config.init_app(app)
- # 初始化数据库操作实例
- db.init_app(app)
- # 初始化Flask-Migrate
- global migrate
- migrate = Migrate(app, db)
- migrate.init_app(app, render_as_batch=True)
- # 初始化Flask-Bootstrap
- bootstrap.init_app(app)
- bootstrap_cdns = app.extensions['bootstrap']['cdns']
- bootstrap_cdns['bootstrap'] = bootstrap_cdns['local']
- bootstrap_cdns['jquery'] = bootstrap_cdns['local']

## 第 22 页 · 项目结构

- 项目结构
- 剩下的代码如下所示。
- # 将各模块的蓝图（Blueprint）注册到应用实例
- from .user import user
- # url_prefix参数可以为用户模块添加上级位置
- app.register_blueprint(user, url_prefix='/user')
- from .admin import admin, admin_user
- app.register_blueprint(admin, url_prefix='/admin')
- app.register_blueprint(admin_user, url_prefix='/admin/user')
- # 将所有模型类注册到模板全局变量，以便于后续调用
- # 注册模型须放置在所有模型加载之后，否则将获取不到相应模型
- for cls in dh.get_all_model_classes():
- app.add_template_global(cls)
- return app
- 这里是将不同模块的蓝图注册到应用程序中，使其可以处理不同 URL 路由，同时也注册了模型类到模板的全局变量，以便在模板中访问这些模型。
- 蓝图的内容会在后续详细讲到，这里就先略过。

## 第 23 页 · 项目结构

- 项目结构
- 在完成了应用的，就到了数据库的内容，数据库相关代码，如“BaseModel”类等内容，都整合到了“app/database.py”文件中。
- 以下是数据库相关功能（app/database.py）的代码实现
- from flask_sqlalchemy import BaseQuery, Model, SQLAlchemy
- # 定义所有模型的基类
- class BaseModel(Model):
- # 声明 query 属性的类型，以获得代码提示补全
- query: BaseQuery
- # 定义模型初始化方法
- def __init__(self, **kwargs):
- # 将参数传入父类初始化方法
- super(BaseModel, self).__init__(**kwargs)
- 这里是用到了5.3.3小节里面的模型基类代码，这里不再详细讲解具体代码。

## 第 24 页 · 项目结构

- 项目结构
- 在完成了应用的，就到了数据库的内容，数据库相关代码，如“BaseModel”类等内容，都整合到了“app/database.py”文件中。
- 以下是数据库相关功能（app/database.py）的代码实现
- from flask_sqlalchemy import BaseQuery, Model, SQLAlchemy
- # 定义所有模型的基类
- class BaseModel(Model):
- # 声明 query 属性的类型，以获得代码提示补全
- query: BaseQuery
- # 定义模型初始化方法
- def __init__(self, **kwargs):
- # 将参数传入父类初始化方法
- super(BaseModel, self).__init__(**kwargs)
- 这里是用到了5.3.3小节里面的模型基类代码，这里不过多讲解。

## 第 25 页 · 项目结构

- 项目结构
- 紧接上文的数据库代码，代码如下。
- # 定义对象输出格式，方便输出预览
- def __repr__(self):
- fields = []
- # 获取对象原始数据
- for k, v in self.__dict__.items():
- # 只输出相关属性
- if k[0] != '_':
- # 防止模型关联后无限递归
- if isinstance(v, BaseModel):
- fields.append('%s=<%s ...>' % (k, v.__class__.__ name__))
- elif isinstance(v, str):
- fields.append("%s='%s'" % (k, v))
- else:
- fields.append('%s=%a' % (k, v))
- # 拼接显示结果
- result = '<%s %s>' % (self.__class__.__name__, ' '.join(fields))
- return result
- 这段是之前讲过的定义对象输出的格式代码。大家也可以试着去修改这段代码。

## 第 26 页 · 项目结构

- 项目结构
- 紧接上文的数据库代码，代码如下。
- # 定义数据库助手类，以便进行一些常用操作
- class DatabaseHelper:
- def __init__(self, db: SQLAlchemy):
- self._db = db
- # 获取所有基于BaseModel类的模型，以便注册到交互Shell
- def get_all_model_classes(self):
- classes = []
- for cls in self._db.Model._decl_class_registry.values():
- if hasattr(cls, '__tablename__') and issubclass(cls, BaseModel):
- classes.append(cls)
- return classes
- # 定义获取db.session的属性，以获得完整的代码补全
- @property
- def session(self) -> Session:
- return self._db.session
- 这段是之前讲过的把内容注册到Shell的代码。在应用“工厂”函数（create_app()）中，大部分的初始化内容都在以往的章节中有所介绍。除了“蓝图”，该内容将会在下一节中进行讲解。

## 第 27 页 · 模块化开发

- 模块化开发
- 03

## 第 28 页 · 模块化开发

- 模块化开发
- 在前面章节的讲解中，均采用了单一文件的方式进行开发。在简单的demo或演示中，采用这种方式固然简单，可以快速达成目标。但这种方式不适合用于完成大型项目，也不利于后续的维护。本节将主要介绍使用蓝图（Blueprint）来实现模块化开发，从而解决以上问题的方法。

## 第 29 页 · 模块化开发

- 模块化开发
- **3.1使用蓝图**
- 在前面的例子中，注册视图函数都是直接使用应用路由来进行的。当使用应用“工厂”函数时，便出现了一个问题：如何注册视图？将所有视图函数都建立在应用“工厂”函数中显然是不合理的。而使用“蓝图”，则可以将数个视图函数组合在一起，将其作为一个模块注册到应用中。
- 假设现在需要实现一个用户模块，可以参考6.2节中的项目结构展示，在“app”包中再建立一个“user”包，同时在包内建立“models.py”“views.py”“form.py”“errors.py”4个文件，以便于后续代码的编写。

## 第 30 页 · 模块化开发

- 模块化开发
- 以下是模块（蓝图）初始化代码（__init__.py）的实现。
- from flask import Blueprint
- user = Blueprint('user', __name__)
- # 加载相关的模型、视图、错误视图（如果有）
- from . import models, views, errors
- 初始化代码相当简洁，仅创建了一个“Blueprint”类对象，引入了该包下各部分的功能。此处引入“models”“views”“errors”，可能有的同学会有疑问：创建完Blueprint类后，仅是引入这些内容，后面并没有使用这些内容，这部分的代码有何意义？此时，可以回想一下，模型所继承的“db.Model”对象及注册函数时使用的“app.route”装饰器。
- 在“models.py”中定义的模型将会因为被引入，而被“db”对象捕捉到，实现表结构的初始化；而“views.py”中定义的视图函数，将会因为使用“route”装饰器而被初始化代码中的“user”蓝图对象捕捉到，从而实现路由的注册；“errors.py”中的错误视图函数同理。最后便完成了模型、视图、错误视图的加载（或注册）。

## 第 31 页 · 模块化开发

- 模块化开发
- 以下是数据模型（models.py）的代码实现。
- from app import db
- from app.database import BaseModel
- class UserModel(db.Model, BaseModel):
- __tablename__ = 'user'
- id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
- username = db.Column(db.VARCHAR, unique=True)
- password = db.Column(db.VARCHAR)
- is_admin = db.Column(db.BOOLEAN, default=False, nullable=False)
- info = db.relationship('UserInfoModel', backref='user', uselist=False, cascade='all')
- class UserInfoModel(db.Model, BaseModel):
- __tablename__ = 'user_info'
- user: UserModel
- user_id = db.Column(db.INTEGER, db.ForeignKey(UserModel.id), primary_key=True)
- phone = db.Column(db.VARCHAR)
- email = db.Column(db.VARCHAR)
- introduce = db.Column(db.TEXT)
- 用户模块模型较为简单，仅是账号模型与信息模型进行了一对一关联，以描述一个完整的用户。

## 第 32 页 · 模块化开发

- 模块化开发
- 以下是表单类（forms.py）的代码实现。
- from flask_wtf import FlaskForm
- from wtforms import StringField, PasswordField, SubmitField, TextAreaField, BooleanField
- from wtforms.validators import DataRequired, Email, Optional, Regexp
- class LoginForm(FlaskForm):
- username = StringField(label='用户名', validators=[DataRequired()])
- password = PasswordField(label='密码', validators=[DataRequired()])
- remember = BooleanField(label='记住该用户')
- submit = SubmitField(label='登录')
- class RegisterForm(FlaskForm):
- username = StringField(label='用户名', validators=[DataRequired()])
- password = PasswordField(label='密码', validators=[DataRequired()])
- # 此处使用11位数字的正则表达式检测手机号
- phone = StringField(label='手机号', validators=[Optional(), Regexp(r'\d{11}')])
- email = StringField(label='邮箱', validators=[Optional(), Email()])
- introduce = TextAreaField(label='自我介绍')
- submit = SubmitField(label='注册')
- 上述代码仅包含了登录、注册功能，结构也是相当简单。

## 第 33 页 · 模块化开发

- 模块化开发
- 以下是视图函数（views.py）的代码实现。由于内容过多，所以分成注册用户、登录用户、查看用户信息3个基本功能的视图函数来讲。
- 首先还是要引入相关的内容依赖，大家要记得不要引用错误，导致代码报错。引入的代码如下所示。
- from flask import render_template, request, redirect, flash, abort
- from app import dh
- from . import user
- from .forms import *
- from .models import *

## 第 34 页 · 模块化开发

- 模块化开发
- 以下是用户注册的代码。
- # 用户注册
- @user.route('/register', methods=['GET', 'POST'])
- def register():
- form = RegisterForm()
- if request.method == 'POST' and form.validate_on_submit():
- item = UserModel(
- username=form.username.data,
- password=form.password.data,
- is_admin=False,
- info=UserInfoModel(
- phone=form.phone.data,
- email=form.email.data,
- introduce=form.introduce.data,
- ),
- )
- try:
- dh.session.add(item)
- dh.session.commit()
- flash('注册成功', 'success')
- return redirect('login')
- except Exception as e:
- flash('注册失败 - %s' % e, 'danger')
- return abort(500)
- else:
- return render_template('user/register.html', form=form)

## 第 35 页 · 模块化开发

- 模块化开发
- 以下是用户登录的代码。
- # 用户登录
- @user.route('/login', methods=['GET', 'POST'])
- def login():
- form = LoginForm()
- if request.method == 'POST' and form.validate_on_submit():
- try:
- item = UserModel.query.filter_by(username=form.username.data, password=form.password.data).first()
- if item is not None:
- flash('登录成功', 'success')
- return redirect(request.path)
- else:
- raise Exception('用户名或密码错误')
- except Exception as e:
- flash('登录失败 - %s' % e, 'danger')
- return abort(500)
- else:
- return render_template('user/login.html', form=form)
- 用户访问 /user/login 页面时，可以输入用户名和密码，然后将其提交给服务器进行处理。这个登录过程包括表单验证和数据库查询操作。如果登录成功，用户会得到成功的提示并被重定向到当前页面，否则会收到登录失败的消息。

## 第 36 页 · 模块化开发

- 模块化开发
- 以下是查看用户信息的代码。
- @user.route('/<int:id>')
- def view(id: int):
- try:
- item = UserModel.query.get(id)  # type: UserModel
- if item is not None:
- return render_template('user/view.html', item=item)
- else:
- raise Exception('用户不存在')
- except Exception as e:
- flash('查看用户 - %s' % e, 'danger')
- return abort(404)
- 用户可以访问 /user/<id> 页面，其中 <id> 是用户的标识符，以查看特定用户的详细信息。如果用户存在，将显示用户详情页面，否则将显示 404 错误页面。
- 上述代码包含了用户模块的功能实现，包含了登录、注册、查看用户信息3个基本功能的视图函数（相关模板页面可以自行设计或参考本书所提供的样例代码实现）。

## 第 37 页 · 模块化开发

- 模块化开发
- 在完成了模型、视图、错误视图、表单代码的编写以后，在应用“工厂”函数中，将“user”蓝图实例注册到应用实例即可。
- 以下是应用“工厂”函数（app/__init__.py）需要修改的部分。
- # ……引入依赖代码……
- # ……其他初始化代码……
- def create_app(env):
- # ……应用初始化代码……
- # 在此处将用户模块的蓝图（Blueprint）注册到应用实例
- from .user import user
- # url_prefix参数可以为用户模块添加上级位置
- app.register_blueprint(user, url_prefix='/user')
- # ……其他初始化代码……
- 此时，即可通过访问“/user/register”页面来进行用户注册，用户注册完成后可通过访问“/user/login”页面来进行用户登录，还可根据id访问“/user/<id>”页面查看用户相关信息。注意：在运行程序之前需要初始化数据库，具体操作可参考书本5.4.3小节。

## 第 38 页 · 模块化开发

- 模块化开发
- 用户模块完成后的演示效果如下图所示。
- 用户注册页面

![第38页图](media/ch06/slide38_img1.png)

## 第 39 页 · 模块化开发

- 模块化开发
- 用户模块完成后的演示效果如下图所示。
- 用户登录页面

![第39页图](media/ch06/slide39_img1.png)

## 第 40 页 · 模块化开发

- 模块化开发
- 用户模块完成后的演示效果如下图所示。
- 查看用户信息页面

![第40页图](media/ch06/slide40_img1.png)

## 第 41 页 · 模块化开发

- 模块化开发
- **3.2 子模块**
- 在大型网站中，一个模块可以由多个子模块组成。例如，在博客系统中，后台管理模块可以用于管理用户、文章，那么便可以将后台管理模块拆分成用户管理模块、文章管理模块两个子模块。
- 在3.1小节的例子中，应用实例可以通过注册蓝图实现模块化开发；而在当前版本的Flask中，可以从项目结构的方面入手来实现子模块的效。

## 第 42 页 · 模块化开发

- 模块化开发
- 具体实现可参考接下来的“用户管理模块”代码。以下是管理模块初始化（admin/__init__.py）的代码实现。
- from flask import Blueprint
- admin = Blueprint('admin', __name__)
- from .user import user as admin_user
- from . import views
- 以下是用户管理模块初始化（admin/user/__init__.py）的代码实现。
- from flask import Blueprint
- user = Blueprint('admin.user', __name__)
- from . import views, models, errors

## 第 43 页 · 模块化开发

- 模块化开发
- 以下是应用“工厂”函数（app/__init__.py）的代码实现。
- def create_app(env):
- #……应用初始化代码……
- # 将各模块的蓝图（Blueprint）注册到应用实例
- from .user import user
- # url_prefix参数可以为用户模块添加上级位置
- app.register_blueprint(user, url_prefix='/user')
- from .admin import admin, admin_user
- app.register_blueprint(admin, url_prefix='/admin')
- app.register_blueprint(admin_user, url_prefix='/admin/user')
- from .portal import portal
- app.register_blueprint(portal)
- # ……其他初始化代码……

## 第 44 页 · 模块化开发

- 模块化开发
- 后台首页与用户管理模块的简单演示效果如下图所示
- 后台首页

![第44页图](media/ch06/slide44_img1.png)

## 第 45 页 · 模块化开发

- 模块化开发
- 当前例子的后台主体内容仅包含了首页。通常情况下，后台首页作为各个模块管理功能的入口。如下图所示。
- 用户管理功能

![第45页图](media/ch06/slide45_img1.png)

## 第 46 页 · Flask-Login

- Flask-Login
- 04

## 第 47 页 · 概念介绍

- 概念介绍
- Flask-Login是什么？
- Flask-Login 是一个 Flask 扩展，用于处理用户身份验证和用户会话管理。它简化了用户认证和会话管理的实现，特别适用于构建需要用户登录功能的 Web 应用程序。

## 第 48 页 · “

- “
- 3.1小节实现了一个简单的用户模块，其中登录视图函数代码的功能是从表单（用户输入）中获取账号密码，然后在数据库中查找与信息匹配的用户，如果存在便提示登录成功。
- 但仍存在一个问题：如果登录后访问其他页面，会发现用户并没有登录。实际上其中还缺了一部分核心功能，那便是用户认证（会话）的实现。
- Flask-Login顾名思义就是与登录功能相关的模块。该模块主要用于实现“用户认证”，以及“要求认证访问”，它提供了一套用户基本模型，可以很好地解决以上问题。
- 为什么要用Flask-Login？
- ”
- 概念介绍

## 第 49 页 · 安装依赖

- 安装依赖
- 与安装Flask的操作一致，打开命令提示符窗口，输入以下命令。
- pip install flask-login==0.4.1
- 执行上述命令之后，能看到“Successfully installed…”提示信息，没有提示红色的报错信息，即安装成功，此时，Flask-Login的依赖包便安装完成了，如下图所示。

![第49页图](media/ch06/slide49_img1.png)

## 第 50 页 · 用户认证

- 用户认证
- 实现用户认证从原理上看其实很简单，仅需要使用会话（Session）对客户浏览器进行记录即可。而Flask-Login实现了一个易于维护的基本用户模型，规范了用户认证的操作，易于扩展。
- 要使用Flask-Login，首先需要在应用初始化文件（app/__init__.py）中添加相关代码，要添加的代码如下。
- # ……引入依赖代码……from flask_login import LoginManager # ……其他初始化代码……login_manager = LoginManager() def create_app(env):     # ……应用初始化代码……         # 初始化Flask-Login     login_manager.login_view = 'user.login'     login_manager.login_message_category = 'danger'     login_manager.login_message = '请登录后再进行操作'     login_manager.init_app(app)	     # ……将模块的蓝图（Blueprint）注册到应用实例……         # 其他初始化代码

## 第 51 页 · 用户认证

- 用户认证
- # 初始化Flask-Login
- login_manager.login_view = 'user.login'
- login_manager.login_message_category = 'danger'
- login_manager.login_message = '请登录后再进行操作'
- login_manager.init_app(app)
- login_manager.login_view = 'user.login': 这一行设置了登录页面的视图函数，它告诉 Flask-Login 在需要用户登录时将用户重定向到 user.login 视图。也就是说，如果用户未登录尝试访问需要登录的页面，Flask-Login 将自动重定向到 user.login 视图，以便用户登录。
- login_manager.login_message_category = 'danger': 这一行设置了登录消息的 Bootstrap 样式类别。在默认情况下，Flask-Login 使用 info 类别来显示登录消息，但在这里，将它设置为 danger，以便登录消息显示为红色，以突出显示警告。
- login_manager.login_message = '请登录后再进行操作': 这一行设置了显示给用户的登录提示消息。如果用户尝试访问需要登录的页面但未登录，将显示这条消息。
- login_manager.init_app(app): 最后，这一行初始化 Flask-Login 扩展，将其与 Flask 应用程序实例 app 关联起来，以便在整个应用程序中使用 Flask-Login 功能。
- 拿新添的代码给大家讲解一下，新添的代码如下。

## 第 52 页 · Flask-Login

- Flask-Login
- 然后使用户模型（user/models.py）继承Flask-Login所提供的基本用户实现，代码如下。
- from flask_login import UserMixin
- # 使用户模型继承Flask-Login的基本用户实现（UserMixin）
- class UserModel(UserMixin, db.Model, BaseModel):
- # ……用户模型代码……

## 第 53 页 · Flask-Login

- Flask-Login
- 再添加模块公共方法（user/common.py），实现当前用户的获取及Flask-Login所需的用户加载器，代码如下。
- from flask_login import current_user
- from app import login_manager
- # 用于Flask-Login获取用户
- from .models import UserModel
- @login_manager.user_loader
- def _load_user(id: int):
- return UserModel.query.get(id)
- # 获取当前用户，指定类型以便获取代码补全
- def get_current_user() -> UserModel:
- return current_user

## 第 54 页 · Flask-Login

- Flask-Login
- 最后在视图函数中（user/views.py）实现登录功能即可，代码如下。
- from flask_login import login_user
- # 用户登录
- @user.route('/login', methods=['GET', 'POST'])
- def login():
- form = LoginForm()
- if request.method == 'POST' and form.validate_on_submit():
- try:
- item = UserModel.query.filter_by(username=form.username.data, password=form.password.data).first()
- if item is not None:
- # 使用Flask-Login完成用户登录认证
- login_user(item)
- flash('登录成功', 'success')
- return redirect(request.path)
- else:
- raise Exception('用户名或密码错误')
- except Exception as e:
- flash('登录失败 - %s' % e, 'danger')
- return abort(500)
- else:
- return render_template('user/login.html', form=form)
- 到此，用户认证便完成了，可以在其他模块（视图函数）中，调用用户模块公共方法（common.py）中的get_current_user()函数获取当前登录的用户。

## 第 55 页 · Flask-Login

- Flask-Login
- **4.1 要求认证访问**
- 在某些页面中，例如注销页面、查看当前登录的用户信息页面等，需要用户登录后才可访问。这时可能读者会有一个疑问：难道每一个需要使用当前用户的视图函数都需要添加一段“if current_user is not None”的代码吗？
- 答案是不需要，使用Flask-Login，只要添加“login_required”装饰器即可。

## 第 56 页 · Flask-Login

- Flask-Login
- 以下是视图函数（user/views.py）的代码
- from flask_login import logout_user, login_required
- from .common import get_current_user
- @user.route('/logout')
- @login_required
- def logout():
- if logout_user():
- flash('注销成功', 'success')
- return redirect('/user/login')
- # 查看用户信息（当前用户）
- @user.route('/')
- @login_required
- def view_current():
- item = get_current_user()
- return render_template('user/view.html', item=item)
- @login_required: 这个装饰器确保只有已登录的用户才能访问这个路由。如果未登录的用户尝试访问 /user/logout，Flask-Login 会自动将他们重定向到登录页面。

## 第 57 页 · Flask-Login

- Flask-Login
- 以上例子（查看当前用户信息）仅用于演示要求验证访问。如果需要在模板页面中使用当前登录的用户，仅需要使用Flask-Login所注册的全局对象“current_user”即可。参考“common/nav.html”编写模板页面的代码，因篇幅过长，此处仅截取部分代码进行展示。代码在下一页展示。

## 第 58 页 · Flask-Login

- Flask-Login
- <ul class="nav navbar-nav navbar-right">
- <li class="dropdown">
- {% if current_user.is_anonymous %}
- {# 如果用户没有登录，即显示游客用的菜单 #}
- <a href="#" class="dropdown-toggle" data-toggle= "dropdown" role="button" aria-haspopup="true"
- aria-expanded="true">
- 游客
- <span class="caret"></span></a>
- <ul class="dropdown-menu">
- <li><a href="{{ url_for('user.login') }}">登录</a></li>
- <li><a href="{{ url_for('user.register') }}">注册</a></li>
- </ul>
- {% else %}
- {# 登录以后显示用户名 #}
- <a href="#" class="dropdown-toggle" data-toggle= "dropdown" role="button" aria-haspopup="true"
- aria-expanded="true">
- {{ current_user.info.nickname or current_ user.username }}
- <span class="caret"></span></a>
- <ul class="dropdown-menu">
- <li><a href="{{ url_for('user.edit') }}">用户信息</a></li>
- <li class="divider"></li>
- <li><a href="{{ url_for('user.logout') }}">注销</a></li>
- </ul>
- {% endif %}
- </li>
- </ul>

## 第 59 页 · Flask-Login

- Flask-Login
- 查看当前登录用户信息的效果如下图所示。
- 查看当前登录用户信息

![第59页图](media/ch06/slide59_img1.png)

## 第 60 页 · Flask-Login

- Flask-Login
- 注销登录用户后查看当前登录用户信息的效果如下图所示。
- 注销登录用户后查看当前登录用户信息

![第60页图](media/ch06/slide60_img1.png)

## 第 61 页 · Flask-Login

- Flask-Login
- **4.2 管理员认证访问**
- 4.1小节并没有提到后台管理模块的修改。显然，后台管理模块是需要用户登录认证后才可以进行访问的，但同时，也不是所有用户都可以访问，只有管理员才可以对后台进行操作。
- 在之前所义的用户模型中有一个“is_admin”的布尔值属性，可以基于“login_required”装饰器，使用这个属性对当前登录的用户进行检测，以实现管理员认证访问。

## 第 62 页 · Flask-Login

- Flask-Login
- 以下是“admin_required”装饰器（admin/common.py）的代码实现。
- from functools import wraps
- from flask import abort, flash
- from flask_login import login_required
- from app.user.common import get_current_user
- def admin_required(func):
- @wraps(func)
- def decorated_view(*args, **kwargs):
- if not get_current_user().is_admin:
- flash('拒绝访问', 'danger')
- return abort(403)
- return func(*args, **kwargs)
- return login_required(decorated_view)
- 以上代码对“login_required”装饰器进行了包装，然后if not get_current_user().is_admin:在 decorated_view 视图函数中，首先调用 get_current_user() 函数获取当前登录的用户信息，然后检查该用户是否具有管理员权限。如果用户不是管理员，表示没有权限访问受保护的视图。

## 第 63 页 · Flask-Login

- Flask-Login
- 那么接下来，所有与管理员功能相关的视图函数自然都需要添加上该装饰器。例如，后台首页（admin/views.py）的代码实现如下。
- from flask import render_template
- from . import admin
- from .common import admin_required
- @admin.route('/')
- @admin_required
- def index():
- return render_template('admin/index.html')
- 将所有管理员视图都添加上“admin_required”装饰器后，管理员认证访问就完全实现了。但之前所创建的“admin”用户仍然是普通用户，是无法访问管理员视图的。

## 第 64 页 · Flask-Login

- Flask-Login
- 如果要将“admin”用户修改成管理员用户，可以在交互Shell中执行以下操作。
- C:\Users\hsojo\PycharmProjects\FlaskChapter6>python manage.py shell
- >>> admin = UserModel.query.filter_by(username='admin').first()
- >>> admin.is_admin = True
- >>> db.session.add(admin)
- >>> db.session.commit()

## 第 65 页 · Flask-Login

- Flask-Login
- 普通用户访问后台首页的演示效果如下图所示
- 普通用户访问后台首页

![第65页图](media/ch06/slide65_img1.png)

## 第 66 页 · Flask-Login

- Flask-Login
- 管理员用户访问后台首页的演示效果如下图所示
- 管理员用户访问后台首页

![第66页图](media/ch06/slide66_img1.png)

## 第 67 页 · 管理员注册

- 管理员注册
- 05

## 第 68 页 · 管理员注册

- 管理员注册
- 在上一节注册管理员用户时，需要先在“用户注册”页面中通过正常流程输入用户名、密码及其他信息项目；然后还需要在交互Shell中修改用户对象的“is_admin”属性。显然，这很花时间。
- 为了解决上述问题，可以回顾一下书本5.2.3小节中的“注册命令”操作。使用命令方式注册管理员用户，可以节约不少时间。

## 第 69 页 · 管理员注册

- 管理员注册
- 以下是应用管理指令（app/commands.py）的代码实现。
- from flask_script import Manager
- from app import dh
- from app.user.models import UserModel, UserInfoModel
- def register_manage_commands(manager: Manager):
- @manager.command
- def create_admin():
- username = input('Input Username:')
- password = input('Input Password:')
- item = UserModel(username=username, password=password, is_admin= True,
- info=UserInfoModel(introduce='Create By Manager.'))
- dh.session.add(item)
- dh.session.commit()

## 第 70 页 · 管理员注册

- 管理员注册
- 管理员注册指令编写完成后，需要将其注册到Manager中。
- 以下是应用管理入口（manage.py）的代码实现。
- # ……引入依赖代码……
- env = get_env()
- app = create_app(env)
- manager = Manager(app)
- # 管理指令注册代码
- def register_manage_commands(manager: Manager):
- @manager.command
- def create_admin():
- username = input('Input Username:')
- password = input('Input Password:')
- item = UserModel(username=username, password=password, is_admin= True,
- info=UserInfoModel(introduce='Create By Manager.'))
- dh.session.add(item)
- dh.session.commit()
- register_manage_commands(manager)
- if __name__ == '__main__':
- manager.run()

## 第 71 页 · 管理员注册

- 管理员注册
- 通过Manager注册管理员的操作过程如下图所示。
- 使用Manager注册管理员

![第71页图](media/ch06/slide71_img1.png)

## 第 72 页 · 小结

- 小结
- 06

## 第 73 页 · 小结

- 小结
- 本章介绍了使用Flask实现模块化开发，使项目易于维护的方法；
- 学会使用配置文件来配置 Flask 应用实例，这有助于将应用的设置与代码分离，使得应用更易于配置和部署。
- 掌握了蓝图的基本使用方法，可以将应用的不同部分划分为模块，使代码更加有组织和可维护。
- 了解了如何使用 Flask-Login 扩展来管理用户登录状态，以及如何使用装饰器 @login_required 来保护需要登录的视图。

## 第 74 页 · 课后作业

- 课后作业
- 今日作业
- 课后习题6.7
- 选做（在你的 Flask 项目中创建至少两个蓝图：
- 一个用于用户认证和管理（注册、登录、注销、用户信息管理等）
- 另一个用于其他功能，例如文章管理、评论等
- 将相关的视图和路由划分到这两个蓝图中，然后在应用实例中注册它们。）

![第74页图](media/ch06/slide74_img1.jpg)

## 第 75 页 · 谢谢聆听

- 谢谢聆听
