15 Flask mega-tutorial 第15章更好的应用程序结构【蓝图】

小鱼儿 2022-05-15 06:04 174阅读 0赞

如需转载请注明出处。  
win10 64位、Python 3.6.3、Notepad++、Chrome 67.0.3396.99（正式版本）（64 位）  
注：作者编写时间2018-03-14，linux、python 3.5.2

以下内容均是加入自己的理解与增删，以记录学习过程。不限于翻译，部分不完全照搬作者Miguel Grinberg的博客，版权属于作者，感谢他提供免费学习的资料。

<table> 
 <tbody> 
  <tr> 
   <th colspan="4"><b><font>传送门</font></b></th> 
  </tr> 
  <tr> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81332147" rel="nofollow">00 开篇</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81354752" rel="nofollow">01 Hello world</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81364734" rel="nofollow">02 模板</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81389112" rel="nofollow">03 Web表单</a></b></td> 
  </tr> 
  <tr> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81485554" rel="nofollow">04 数据库</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81536333" rel="nofollow">05 用户登录</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81565017" rel="nofollow">06 个人资料和头像</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81590339" rel="nofollow">07 错误处理</a></b></td> 
  </tr> 
  <tr> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81634851" rel="nofollow">08 关注</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81672110" rel="nofollow">09 分页</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81746739" rel="nofollow">10 支持QQ邮箱</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81779883" rel="nofollow">11 美化页面</a></b></td> 
  </tr> 
  <tr> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81951594" rel="nofollow">12 时间和日期</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81982032" rel="nofollow">13 I18n和L10n 翻译成中文 zh-CN</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/81989457" rel="nofollow">14 Ajax(百度翻译API</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/82055120" rel="nofollow">15 更好的App结构(蓝图)</a></b></td> 
  </tr> 
  <tr> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/82119331" rel="nofollow">16 全文搜索</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/82185100" rel="nofollow">17 部署到腾讯云Ubuntu</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/82185153" rel="nofollow">18 部署到Heroku</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/82185229" rel="nofollow">19 部署到Docker容器</a></b></td> 
  </tr> 
  <tr> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/82776565" rel="nofollow">20 JavaScript魔法</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/82778415" rel="nofollow">21 用户通知</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/82778449" rel="nofollow">22 后台工作(Redis)</a></b></td> 
   <td><b><a href="https://blog.csdn.net/weixin_38256474/article/details/82778519" rel="nofollow">23 应用程序编程接口(API)</a></b></td> 
  </tr> 
 </tbody> 
</table>

本章将使用适合大型应用程序的样式重新构建应用程序。

目前Microblog已是一个体面的应用程序了，所以此刻是讨论一个**Flask**应用程序如何成长而不会变得混乱或太难管理的时机了。**Flask**是一个框架，旨在为我们提供以想要的任何方式组织项目的选项，并且作为这个理念的一部分，它可以在应用程序变得更大、或我们的需要以及经验水平提升时，更改或调整应用程序的结构。

接下来，将讨论适用于大型应用程序的一些模式，并演示对Microblog项目的结构进行一些更改，目标是使代码更易于维护和更有条理。但是当然，在真正的**Flask**精神中，鼓励尝试决定组织自己的项目时，将这些更改作为建议。

# 目前的限制 #

应用程序在目前为止存在 两个基本问题。看一下应用程序的结构，会注意到有一些不同的 子系统可识别，但支持它们的代码是混合的，没有任何明确的界限。回顾一下这些 子系统是什么：

*  用户身份验证子系统，包括app/routes.py中的一些视图功能，app/forms.py中的一些表单，app/templates中的一些模板，以及app/email.py中的电子邮件支持。
 *  错误子系统，app/errors.py中定义的错误处理 和app/templates中的模板。
 *  核心应用程序功能，包括显示和编写博客帖子，用户个人资料和关注，以及博客帖子的实时翻译，这些功能通过大多数应用程序的模块 和模板进行传播。

考虑已确定的这个三个子系统以及它们的结构，可能会注意到一种模式。到目前为止，一直遵循的组织逻辑是基于具有专用于不同应用程序功能的模块。有一个视图函数模块、一个用于Web表单、一个用于错误处理、一个用于电子邮件，一个用于HTML模板，等等。虽然这是一个对于小项目有意义的结构，但是一旦项目开始增长，它往往会使这些模块中的一些变得非常庞大和混乱。

清楚地看到问题的一种方法是考虑如何通过尽可能多地重用这个项目来启动第二个项目。例如，用户身份验证部分 应该可以在其他应用程序中正常运行，但如果想要按原样使用这个代码，则必须进入多个模块，并将相关部分复制、粘贴到新项目的新文件中。这将是极其不方便的。如果这个项目将所有与身份验证相关的文件与应用程序的其余部分分开，这就非常好了。**Flask**蓝图功能有助于实现更实用的组织方式，使重用代码变得更容易。

第二个问题不明显。**Flask**应用程序实例 在**app/\_\_init\_\_.py**中以一个全局变量被创建，然后被很多应用程序模块所导入。虽然这本身不是一个问题，但将应用程序作为全局变量可能会使得某些场景复杂化，特别是与测试相关的场景中。想象一下，若想在不同配置下测试这个应用程序。由于应用程序被定义为全局变量，因此实际上无法实例化使用不同配置变量的两个应用程序。另一种不理想的情况是 所有测试都使用相同的应用程序，因此测试可能会对应用程序进行更改，从而影响以后运行的另一个测试。理想情况下，希望所有测试都在一个质朴的应用程序实例上运行。

实际上在**tests.py**模块中可看到，在应用程序中设置后要求修改配置，以指示测试使用内存数据库而不是基于磁盘的默认SQLite数据库。我们真的没有其他办法去更改已配置的数据库，因为在测试开始时，已经创建并配置了应用程序。对于这种特殊情况，在应用程序运用于应用程序后去更改配置似乎工作正常，但在其他情况下可能不会，并且在任何情况下，这都是一种不好的做法，可能导致模糊和难以发现的错误。

更好的解决方案是 不让应用程序使用全局变量，而是使用一个应用程序工厂函数在运行时去创建函数。这将是一个接受配置对象作为参数的函数，并返回一个设置了这些配置的**Flask**应用程序实例。如果我可以修改应用程序以使用应用程序工厂函数，那么编写需要特殊配置的测试讲变得容易，因为每个测试都可以创建自己的应用程序。

在本章中，我将重构应用程序，为上面提到的三个子系统和应用程序工厂函数引入蓝图。向大家显示更改的详细列表是不切实际的，因为属于应用程序的一部分的每个文件几乎没有变化，所以我将讨论重构所采取的的步骤。可在源码文件中查看这些更改。

# 蓝图 #

在**Flask**中，蓝图是表示应用程序子集的逻辑结构。蓝图可包括路由、视图函数、表单、模板、静态文件等等元素。如果我们在单独的**Python包**中编写蓝图，那么我们将拥有一个组件，这个组件封装了与应用程序的特定功能相关的元素。

一个蓝图的内容最初是处于休眠状态。要关联这些元素，需要在应用程序中注册蓝图。在注册期间，添加到蓝图的所有元素都会传递给应用程序。因此，可将蓝图视为应用程序功能的临时存储，以帮助组织代码。

## 错误处理蓝图 ##

创建的第一个 蓝图是 封装对错误处理的支持的蓝图。这个蓝图结构如下：

app/
        errors/                             <-- blueprint package
            __init__.py                     <-- blueprint creation
            handlers.py                     <-- error handlers
        templates/
            errors/                         <-- error templates
                404.html
                500.html
        __init__.py                         <-- blueprint registration

本质上，所做的是将**app/errors.py**模块 移动到**app/errors/handlers.py**中；将这两个错误模板移动到**app/templates/errors**中，以便它们与其他模板分开。还必须更改在两个错误处理中的`render_template()`调用，以使用的新的错误模板子目录。之后，在创建应用程序实例后，将蓝图创建添加到**app/errors/\_\_init\_\_.py**模块中，并将蓝图注册添加到**app/\_\_init\_\_.py**中。

应该注意到，可将**Flask蓝图**配置为具有模板或静态文件的单独目录。我已决定将模板移动到应用程序模板目录的子目录中，以便所有模板都在单个层次结构中，但如果希望在蓝图包中具有属于蓝图的模板，那是支持的。例如，如果向`Blueprint()`构造函数添加一个`template_folder='templates'`参数，那么可将蓝图的模板存储在**app/errors/templates**中。

创建蓝图与创建应用程序非常相似。这是在蓝图包的\_\_init\_\_.py模块中完成的：

**app/errors/init.py**：错误蓝图

from flask import Blueprint
    
    bp = Blueprint('errors', __name__)
    
    from app.errors import handlers

**Blueprint类** 采取蓝图的名字，基础模块的名字（如同在**Flask应用程序实例**中通常设置\_\_name\_\_），以及一些可选参数（在这种情况下，我不需要）。创建蓝图对象后，我导入**handlers.py**模块，以便其中的错误处理程序注册到蓝图。这个导入位于底部以避免循环依赖。

在**handlers.py**模块中，我没有使用`@app.errorhandler`装饰器将错误处理程序附加到应用程序中，而是使用蓝图的`@bp.app_errorhandler`装饰器。虽然两个装饰器都达到了相同的最终结果，但我们的想法是尝试 使蓝图独立于应用程序，以便它更具可移植性。还需要修改两个错误模板的路径，以便考虑移动它们的新错误子目录。

**app/errors/handlers.py**：

from flask import render_template
    from app import db
    from app.errors import bp
    
    @bp.app_errorhandler(404)
    def not_found_error(error):
    	return render_template('errors/404.html'), 404
    
    @bp.app_errorhandler(505)
    def internal_error(error):
    	db.session.rollback()
    	return render_template('errors/500.html'), 500

完成错误处理程序重构的最后一步是 在应用程序中注册蓝图：

**app/\_\_init\_\_.py**：在应用程序中注册错误蓝图

#...
    def create_app(config_class=Config):
    	#...
    	app = Flask(__name__)
    
    	# ...
    
    	from app.errors import bp as errors_bp
    	app.register_blueprint(errors_bp)
    
    	# ...
    
    from app import routes, models  # <-- remove errors from this import!

要注册蓝图，得使用**Flask**应用程序实例的`register_blueprint()`方法。注册蓝图时，任何视图函数、模板、静态文件、错误处理模块等都会连接到应用程序。我把蓝图的导入放在`app.register_blueprint()`的上方，以避免循环依赖。

## 身份验证蓝图 ##

将应用程序的身份验证功能重构为一个蓝图的过程 与上一小节错误处理程序的过程非常相似。如下是重构蓝图的结构图：

要创建这个蓝图，必须将所有与身份验证相关的功能移动到 我在蓝图创建的新模块中。包括一些视图函数、Web表单、以及通过电子邮件发送密码重置令牌的支持函数等。还将模板移动到子目录中，以将它们与应用程序的其余部分分开。

在一个蓝图中定义路由时，得使用`@bp.route`装饰，而不是`@app.route`。在`url_for()`去构建URL时，使用的语法也需要做出更改。对于直接附加到应用程序的常规视图函数，`url_for()`的第一个参数是视图函数的名字。在一个蓝图中当定义一个路由时，这个参数必须包含蓝图名字和视图函数名字，并以逗号隔开。例如，我必须用`url_for('auth.login')`替换所有出现的`url_for('login')`，并且对剩下的视图函数也是如此。

在应用程序中注册 `auth`蓝图，使用了稍有不同的格式：

**app/\_\_init\_\_.py**：

# ...
    from app.auth import bp as auth_bp
    app.register_blueprint(auth_bp, url_prefix='/auth')
    # ...

在这种情形下的`register_blueprint()`调用有一个额外的参数 `url_prefix`。这完全是可选的，但是**Flask**为我们提供了在URL前缀下附加蓝图的选项，因此任何在蓝图中定义的路由都会在它们的URL中取得前缀。在很多情况下，这可用作一种“命名空间”，它可将蓝图中的所有路由与应用程序或其他蓝图中的其他路由分开。对于身份验证，我认为让所有路由以 `/auth`开头很好，所有就添加了此前缀。所以现在登录URL将是 `http://localhost:5000/auth/login`。因为用`url_for()`生成URL，所以所有URL都会自动包含前缀。

**app/auth/\_\_init\_\_.py**：

from flask import Blueprint
    
    bp = Blueprint('auth', __name__)
    
    from app.auth import routes

**app/auth/email.py**

from flask import render_template, current_app
    from flask_babel import _
    from app.email import send_email
    
    
    def send_password_reset_email(user):
        token = user.get_reset_password_token()
        send_email(_('[Microblog] Reset Your Password'),
                   sender=current_app.config['ADMINS'][0],
                   recipients=[user.email],
                   text_body=render_template('email/reset_password.txt',
                                             user=user, token=token),
                   html_body=render_template('email/reset_password.html',
                                             user=user, token=token))

**app/auth/forms.py**：

from flask_wtf import FlaskForm
    from wtforms import StringField, PasswordField, BooleanField, SubmitField
    from wtforms.validators import ValidationError, DataRequired, Email, EqualTo
    from flask_babel import _, lazy_gettext as _l
    from app.models import User
    
    
    class LoginForm(FlaskForm):
        username = StringField(_l('Username'), validators=[DataRequired()])
        password = PasswordField(_l('Password'), validators=[DataRequired()])
        remember_me = BooleanField(_l('Remember Me'))
        submit = SubmitField(_l('Sign In'))
    
    
    class RegistrationForm(FlaskForm):
        username = StringField(_l('Username'), validators=[DataRequired()])
        email = StringField(_l('Email'), validators=[DataRequired(), Email()])
        password = PasswordField(_l('Password'), validators=[DataRequired()])
        password2 = PasswordField(
            _l('Repeat Password'), validators=[DataRequired(),
                                               EqualTo('password')])
        submit = SubmitField(_l('Register'))
    
        def validate_username(self, username):
            user = User.query.filter_by(username=username.data).first()
            if user is not None:
                raise ValidationError(_('Please use a different username.'))
    
        def validate_email(self, email):
            user = User.query.filter_by(email=email.data).first()
            if user is not None:
                raise ValidationError(_('Please use a different email address.'))
    
    
    class ResetPasswordRequestForm(FlaskForm):
        email = StringField(_l('Email'), validators=[DataRequired(), Email()])
        submit = SubmitField(_l('Request Password Reset'))
    
    
    class ResetPasswordForm(FlaskForm):
        password = PasswordField(_l('Password'), validators=[DataRequired()])
        password2 = PasswordField(
            _l('Repeat Password'), validators=[DataRequired(),
                                               EqualTo('password')])
        submit = SubmitField(_l('Request Password Reset'))

**app/auth/routes.py**：

from flask import render_template, redirect, url_for, flash, request
    from werkzeug.urls import url_parse
    from flask_login import login_user, logout_user, current_user
    from flask_babel import _
    from app import db
    from app.auth import bp
    from app.auth.forms import LoginForm, RegistrationForm, \
        ResetPasswordRequestForm, ResetPasswordForm
    from app.models import User
    from app.auth.email import send_password_reset_email
    
    
    @bp.route('/login', methods=['GET', 'POST'])
    def login():
        if current_user.is_authenticated:
            return redirect(url_for('main.index'))
        form = LoginForm()
        if form.validate_on_submit():
            user = User.query.filter_by(username=form.username.data).first()
            if user is None or not user.check_password(form.password.data):
                flash(_('Invalid username or password'))
                return redirect(url_for('auth.login'))
            login_user(user, remember=form.remember_me.data)
            next_page = request.args.get('next')
            if not next_page or url_parse(next_page).netloc != '':
                next_page = url_for('main.index')
            return redirect(next_page)
        return render_template('auth/login.html', title=_('Sign In'), form=form)
    
    
    @bp.route('/logout')
    def logout():
        logout_user()
        return redirect(url_for('main.index'))
    
    
    @bp.route('/register', methods=['GET', 'POST'])
    def register():
        if current_user.is_authenticated:
            return redirect(url_for('main.index'))
        form = RegistrationForm()
        if form.validate_on_submit():
            user = User(username=form.username.data, email=form.email.data)
            user.set_password(form.password.data)
            db.session.add(user)
            db.session.commit()
            flash(_('Congratulations, you are now a registered user!'))
            return redirect(url_for('auth.login'))
        return render_template('auth/register.html', title=_('Register'),
                               form=form)
    
    
    @bp.route('/reset_password_request', methods=['GET', 'POST'])
    def reset_password_request():
        if current_user.is_authenticated:
            return redirect(url_for('main.index'))
        form = ResetPasswordRequestForm()
        if form.validate_on_submit():
            user = User.query.filter_by(email=form.email.data).first()
            if user:
                send_password_reset_email(user)
            flash(
                _('Check your email for the instructions to reset your password'))
            return redirect(url_for('auth.login'))
        return render_template('auth/reset_password_request.html',
                               title=_('Reset Password'), form=form)
    
    
    @bp.route('/reset_password/<token>', methods=['GET', 'POST'])
    def reset_password(token):
        if current_user.is_authenticated:
            return redirect(url_for('main.index'))
        user = User.verify_reset_password_token(token)
        if not user:
            return redirect(url_for('main.index'))
        form = ResetPasswordForm()
        if form.validate_on_submit():
            user.set_password(form.password.data)
            db.session.commit()
            flash(_('Your password has been reset.'))
            return redirect(url_for('auth.login'))
        return render_template('auth/reset_password.html', form=form)

以下是模板：

**app/templates/auth/login.html**：

{% extends "base.html" %}
    {% import 'bootstrap/wtf.html' as wtf %}
    
    {% block app_content %}
        <h1>{
       { _('Sign In') }}</h1>
        <div class="row">
            <div class="col-md-4">
                {
       { wtf.quick_form(form) }}
            </div>
        </div>
        <br>
    
        <p>{
       { _('New User?') }} <a href="{
       { url_for('auth.register') }}">{
       { _('Click to Register!') }}</a></p>
        <p>
            {
       { _('Forgot Your Password?') }}
            <a href="{
       { url_for('auth.reset_password_request') }}">{
       { _('Click to Reset It') }}</a>
        </p>
    {% endblock %}

**app/templates/auth/register.html**：

{% extends "base.html" %}
    {% import 'bootstrap/wtf.html' as wtf %}
    
    {% block app_content %}
    	<h1>{
       { _('Register') }}</h1>
    	<div class="row">
    		<div class="col-md-4">
    			{
       { wtf.quick_form(form) }}
    		</div>
    	</div>
    {% endblock %}

**app/templates/auth/reset\_password.html**：

{% extends "base.html" %}
    {% import 'bootstrap/wtf.html' as wtf %}
    
    {% block app_content %}
    	<h1>{
       { _('Reset Your Password') }}</h1>
    	<div class="row">
    		<div class="col-md-4">
    			{
       { wtf.quick_form(form) }}
    		</div>
    	</div>
    {% endblock %}

**app/templates/auth/reset\_password\_request.html**：

{% extends "base.html" %}
    {% import 'bootstrap/wtf.html' as wtf %}
    
    {% block app_content %}
    	<h1>{
       { _('Reset Password') }}</h1>
    	<div class="row">
    		<div class="col-md-4">
    			{
       { wtf.quick_form(form) }}
    		</div>
    	</div>
    {% endblock %}

## 应用程序【主main】蓝图 ##

第三个蓝图 包含核心应用程序的逻辑。重构这个蓝图需要使用与前两个蓝图相同的过程。给这个蓝图取名为`main`，所以引用视图函数的所有`url_for()`调用都必须得到一个`main.`的前缀。鉴于这是应用程序的核心功能，我决定将模板保留在相同的位置。

**app/main/\_\_init\_\_.py**：

from flask import Blueprint
    
    bp = Blueprint('main', __name__)
    
    from app.main import routes

**app/main/forms.py**：

from flask import request
    from flask_wtf import FlaskForm
    from wtforms import StringField, SubmitField, TextAreaField
    from wtforms.validators import ValidationError, DataRequired, Length
    from flask_babel import _, lazy_gettext as _l
    from app.models import User
    
    class EditProfileForm(FlaskForm):
        username = StringField(_l('Username'), validators=[DataRequired()])
        about_me = TextAreaField(_l('About me'),
                                 validators=[Length(min=0, max=140)])
        submit = SubmitField(_l('Submit'))
    
        def __init__(self, original_username, *args, **kwargs):
            super(EditProfileForm, self).__init__(*args, **kwargs)
            self.original_username = original_username
    
        def validate_username(self, username):
            if username.data != self.original_username:
                user = User.query.filter_by(username=self.username.data).first()
                if user is not None:
                    raise ValidationError(_('Please use a different username.'))
    
    class PostForm(FlaskForm):
        post = TextAreaField(_l('Say something'), validators=[DataRequired()])
        submit = SubmitField(_l('Submit'))

**app/main/routes.py**：

from datetime import datetime
    from flask import render_template, flash, redirect, url_for, request, g, \
        jsonify, current_app
    from flask_login import current_user, login_required
    from flask_babel import _, get_locale
    from guess_language import guess_language
    from app import db
    from app.main.forms import EditProfileForm, PostForm
    from app.models import User, Post
    from app.translate import translate
    from app.main import bp
    
    @bp.before_app_request
    def before_request():
        if current_user.is_authenticated:
            current_user.last_seen = datetime.utcnow()
            db.session.commit()
        #g.locale = str(get_locale())
        g.locale = 'zh' if str(get_locale()).startswith('zh') else str(get_locale())
    
    @bp.route('/', methods=['GET', 'POST'])
    @bp.route('/index', methods=['GET', 'POST'])
    @login_required
    def index():
        form = PostForm()
        if form.validate_on_submit():
            language = guess_language(form.post.data)
            if language == 'UNKNOWN' or len(language) > 5:
                language = ''
            post = Post(body=form.post.data, author=current_user,
                        language=language)
            db.session.add(post)
            db.session.commit()
            flash(_('Your post is now live!'))
            return redirect(url_for('main.index'))
        page = request.args.get('page', 1, type=int)
        posts = current_user.followed_posts().paginate(
            page, current_app.config['POSTS_PER_PAGE'], False)
        next_url = url_for('main.index', page=posts.next_num) \
            if posts.has_next else None
        prev_url = url_for('main.index', page=posts.prev_num) \
            if posts.has_prev else None
        return render_template('index.html', title=_('Home'), form=form,
                               posts=posts.items, next_url=next_url,
                               prev_url=prev_url)
    
    @bp.route('/explore')
    @login_required
    def explore():
        page = request.args.get('page', 1, type=int)
        posts = Post.query.order_by(Post.timestamp.desc()).paginate(
            page, current_app.config['POSTS_PER_PAGE'], False)
        next_url = url_for('main.explore', page=posts.next_num) \
            if posts.has_next else None
        prev_url = url_for('main.explore', page=posts.prev_num) \
            if posts.has_prev else None
        return render_template('index.html', title=_('Explore'),
                               posts=posts.items, next_url=next_url,
                               prev_url=prev_url)
    
    @bp.route('/user/<username>')
    @login_required
    def user(username):
        user = User.query.filter_by(username=username).first_or_404()
        page = request.args.get('page', 1, type=int)
        posts = user.posts.order_by(Post.timestamp.desc()).paginate(page, app.config['POSTS_PER_PAGE'], False)
        next_url = url_for('main.user', username=user.username, page=posts.next_num) if posts.has_next else None
        prev_url = url_for('main.user', username=user.username, page=posts.prev_num) if posts.has_prev else None
        return render_template('user.html', user=user, posts=posts.items, next_url=next_url, prev_url=prev_url)
    
    @bp.route('/edit_profile',methods=['GET','POST'])
    @login_required
    def edit_profile():
        form = EditProfileForm(current_user.username)
        if form.validate_on_submit():
            current_user.username = form.username.data
            current_user.about_me = form.about_me.data
            db.session.commit()
    
            flash(_('Your changes have been saved.'))
            return redirect(url_for('main.edit_profile'))
        elif request.method == 'GET':
            form.username.data = current_user.username
            form.about_me.data = current_user.about_me
        return render_template('edit_profile.html', title=_('Edit Profile'), form=form)
    
    @bp.route('/follow/<username>')
    @login_required
    def follow(username):
        user = User.query.filter_by(username=username).first()
        if user is None:
            flash(_('User %(username)s not found.', username=username))
            return redirect(url_for('main.index'))
        if user == current_user:
            flash(_('You connot follow yourself!'))
            return redirect(url_for('main.user', username=username))
        current_user.follow(user)
        db.session.commit()
        flash(_('You are following %(username)s!', username=username))
        return redirect(url_for('main.user', username=username))
    
    @bp.route('/unfollow/<username>')
    @login_required
    def unfollow(username):
        user = User.query.filter_by(username=username).first()
        if user is None:
            flash(_('User %(username)s not found.', username=username))
            return redirect(url_for('main.index'))
        if user == current_user:
            flash(_('You cannot unfollow yourself!'))
            return redirect(url_for('main.user', username=username))
        current_user.unfollow(user)
        db.session.commit()
        flash(_('You are not following %(username)s.', username=username))
        return redirect(url_for('main.user', username=username))
    
    @bp.route('/translate', methods=['POST'])
    @login_required
    def translate_text():
        q = request.form['q']
        fromLang = request.form['fromLang']
        toLang =request.form['toLang']
        return jsonify({'text': translate(q, fromLang, toLang)})

# 应用工厂模式 #

正如在本章的介绍中提到的那样，将应用程序作为一个全局变量引入了一些复杂性，主要是对某些测试场景的限制形式。在引入蓝图之前，应用程序必须是一个全局变量，因为所有的视图函数 和错误处理程序都需要用来自`app`的装饰器进行装饰，例如`@app.route`。但是现在所有路由和错误处理程序都被移到了蓝图上，使应用程序保持全局的原因要少得多。

因此，我要做的是添加一个名为`create_app()`的函数，它构造了Flask应用程序实例，并消除全局变量。转换不是微不足道的，我不得不不解决一些复杂问题，但让我们首先看一下应用程序工厂函数：

**app/\_\_init\_\_.py**：应用程序工厂函数

import logging
    from logging.handlers import SMTPHandler,RotatingFileHandler
    import os
    
    from flask import Flask,request
    from flask_sqlalchemy import SQLAlchemy#从包中导入类
    from flask_migrate import Migrate
    from flask_login import LoginManager
    from flask_mail import Mail
    from flask_bootstrap import Bootstrap
    from flask_moment import Moment
    from flask_babel import Babel,lazy_gettext as _l
    from config import Config#从config模块导入Config类
    
    db = SQLAlchemy()
    migrate = Migrate()
    login = LoginManager()#初始化Flask-Login
    login.login_view = 'login'
    login.login_message = _l('Please log in to access this page.')
    mail = Mail()
    bootstrap = Bootstrap()
    moment = Moment()
    babel = Babel()
    
    def create_app(config_class=Config):
    	app = Flask(__name__)
    	app.config.from_object(config_class)
    
    	db.init_app(app)
    	migrate.init_app(app, db)
    	login.init_app(app)
    	mail.init_app(app)
    	bootstrap.init_app(app)
    	moment.init_app(app)
    	babel.init_app(app)
    
    	from app.errors import bp as errors_bp
    	app.register_blueprint(errors_bp)
    
    	from app.auth import bp as auth_bp
    	app.register_blueprint(auth_bp, url_prefix='/auth')
    
    	if not app.debug and not app.testing:
    		if app.config['MAIL_SERVER']:
    			auth = None
    			if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']:
    				auth = (app.config['MAIL_USERNAME'],app.config['MAIL_PASSWORD'])
    			
    			secure = None
    			if app.config['MAIL_USE_SSL']:
    				secure = ()
    			mail_handler = SMTPHandler(
    				mailhost = (app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
    				fromaddr = 'no-reply@' + app.config['MAIL_SERVER'],
    				toaddrs = app.config['ADMINS'],
    				subject = 'Micblog Failure',
    				credentials = auth, secure=secure)
    			mail_handler.setLevel(logging.ERROR)
    			app.logger.addHandler(mail_handler)
    
    		if not os.path.exists('logs'):
    			os.mkdir('logs')
    		file_handler = RotatingFileHandler('logs/microblog.log', maxBytes=10240, backupCount=10)
    		file_handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
    		file_handler.setLevel(logging.INFO)
    		app.logger.addHandler(file_handler)
    
    		app.logger.setLevel(logging.INFO)
    		app.logger.info('Microblog startup')
    	return app
    
    @babel.localeselector
    def get_locale():
    	return request.accept_languages.best_match(app.config['LANGUAGES'])
    	#return 'zh'
    
    from app import models#在此移除errors、routes的导入

如上可看到，大多数**Flask扩展**都是通过创建扩展的实例并将应用程序作为参数传递来初始化的。当应用程序不作为全局变量存在时，有一种替代模式，其中扩展在两个阶段中初始化。扩展实例首先在全局范围内创建，但不会传递任何参数。这将创建未附加到应用程序的扩展实例。在工厂函数中创建应用程序实例时，必须在扩展实例上调用`init_app()`方法以将其绑定到现在已知的应用程序。

在初始化期间执行的其他任务保持不变，但是移动到工厂函数 而不是在全局范围内。包括蓝图注册和日志配置。请注意，我向条件中添加了一个`not app.testing`子句，用于决定是否应该启用电子邮件和文件日志记录，以便在单元测试期间跳过所有这些日志记录。由于在配置中设置了`TESTING`变量为`True`，因此在运行单元测试时`app.testing`标志将为`True`。

那么谁调用了应用程序工程函数？使用这个函数的显而易见的地方是顶级目录下的`microblog.py`脚本，它是应用程序现在在全局范围内存在的唯一模块。另一个地方是`tests.py`，将在下一节中更详细地讨论单元测试。

正如上面提到的，大多数引用`app`随着蓝图的引入而消失，但是我们必须解决一些代码中的问题。例如，**app/models.py，app/translate.py和app/main/routes.py**模块都有引用`app.config`。幸运的是，Flask开发人员试图让视图函数轻松访问应用程序实例，而不必像以前那样导入它。Flask提供的`current_app`变量是一个特殊的“上下文”变量，Flask在调度请求之前使用应用程序初始化这个变量。在之前已经看过另一个上下文变量，即我正在存储当前区域设置的`g`变量。这两个，以及Flask-Login的`current_user`，还有一些我们没看到的，有点“神奇”的变量。因为它们像全局变量一样工作，但只能在处理请求时访问，并且只能在处理它的线程中访问。

替换Flask的`current_app`变量的`app`消除了将应用程序实例作为全局变量导入的需要。通过简单的搜索和替换，没有任何困难，我能改变所有引用`app.config`和`current_app.config`。

**app/email.py**模块呈现一个稍大的挑战，所以我不得不用一个小窍门：

**app/email.py**：将应用程序实例传递给另一个线程

from threading import Thread
    from flask import current_app
    from flask_mail import Message
    from app import mail
    
    def send_async_email(app, msg):
    	with app.app_context():
    		mail.send(msg)
    
    def send_email(subject, sender, recipients, text_body, html_body):
    	msg = Message(subject, sender=sender, recipients=recipients)
    	msg.body = text_body
        msg.html = html_body
        Thread(target=send_async_email,args=(current_app._get_current_object(), msg)).start()

在`send_email()`函数中，应用程序实例作为参数传递给后台线程，然后后台线程将在不阻止应用程序的情况下传递电子邮件。直接在`send_async_email()`作为后台线程运行的函数中使用`current_app`将不起作用，因为`current_app`是一个与处理客户机请求的线程相关联的上下文感知变量。在不同的线程中，`current_app`不会分配值。直接将`current_app`作为参数传递给线程也不会有效，因为`current_app`实际上是一个动态映射到应用程序实例的代理对象。因此传递代理对象与使用`current_app`相同直接在线程中。我们需要做的是访问存储在代理对象中的真实应用程序实例，并将其作为`app`参数传递。`current_app._get_current_object()`表达式从代理对象中提取的实际应用程序实例，所以这就是我传递给线程作为参数。

当然还得修改**app/templates/email/**的reset\_password.text和reset\_password.html文件中的`url_for('auth.reset_password',token=token,_external=True)`添加前缀`auth.`。

另一棘手的模块是 **app/cli.py**，它实现了一些用于管理语言翻译的快捷命令。在这种情况下，`current_app`变量不起作用，因为这些命令是在启动时注册的，而不是在处理请求期间注册的，这是唯一当`current_app`能够使用的时间。为了删除在这个模块中引用向`app`，我采用了一个技巧，即 将这些自定义命令移动以`app`实例作为参数的`register()`函数中：

**app/cli.py**：注册自定义应用程序命令

import os
    import click
    
    def register(app):
    	@app.cli.group()
    	def translate():
    		#翻译和本地化命令
    		pass
    
    	@translate.command()
    	@click.argument('lang')
    	def init(lang):
    		#初始化一个新语言
    		if os.system('pybabel extract -F babel.cfg -k _l -o messages.pot .'):
    			raise RuntimeError('extract command failed')
    		if os.system('pybabel init -i messages.pot -d app/translations -l ' +lang):
    			raise RuntimeError('init command failed')
    		os.remove('messages.pot')
    
    	@translate.command()
    	def update():
    		#更新所有语言
    		if os.system('pybabel extract -F babel.cfg -k _l -o messages.pot .'):
    			raise RuntimeError('extract command failed')
    		if os.system('pybabel update -i messages.pot -d app/translations'):
    			raise RuntimeError('update command failed')
    		os.remove('messages.pot')
    
    	@translate.command()
    	def compile():
    		#编译所有语言
    		if os.system('pybabel compile -d app/translations'):
    			raise RuntimeError('compile command failed')

然后从**microblog.py**中调用这个`register()`函数。这是在所有重构后的完整**microblog.py**：

**microblog/microblog.py**：重构应用程序模块

from app import create_app, db, cli
    from app.models import User,Post
    
    app = create_app()
    cli.register(app)
    
    @app.shell_context_processor
    def make_shell_context():
    	return {'db':db, 'User':User, 'Post':Post}

最后，**app/models.py**保持不变动。

# 单元测试改进 #

正如本章开头所暗示的那样，到目前为止，所做的很多工作都是为了改进 单元测试工作流程。在运行单元测试时，希望确保应用程序的配置方式不会干扰开发资源，例如 数据库。

当前版本的**tests.py**在将应用程序运用于应用程序实例之后 修改配置，这是一种危险的做法，因为并非所有类型的更改都可以在最后完成时运行。我想要的是 有机会在将测试配置添加到应用程序之前指定它。

`create_app()`函数现在接受一个配置类作为一个参数。默认情况下，使用在**config.py**中定义的`Config`类，但我现在可以创建一个使用不同配置的应用程序实例，只需将新类传递给工厂函数即可。这是一个适合用于我们的单元测试实例配置类：

#...
    from app.models import User,Post
    from config import Config
    
    class TestConfig(config):
    	TESTING = True
    	SQLALCHEMY_DATABASE_URI = 'sqlite://'
    #...

上述代码中 创建了应用程序的`Config`类的子类，并重写SQLAlchemy配置以使用内存中的SQLite数据库。还添加了一个`TESTING`属性集为`True`，目前不需要它，但如果应用程序需要确定它是否在单元测试下运行，则可能会很有用。

应该还记得，我们的单元测试依赖于单元测试框架自动调用的`setUp()`和`tearDown()`方法来创建和销毁适用于每个运行测试的环境。现在还可以使用这两个方法为每个测试创建和销毁一个全新的应用程序：

**microblog/tests.py**：为每个测试创建一个应用程序

#...
    class UserModelCase(unittest.TestCase):
    	def setUp(self):
    		self.app = create_app(TestConfig)
    		self.app_context = self.app.app_context()
    		self.app_context.push()
    		db.create_all()
    
    	def tearDown(self):
    		db.session.remove()
    		db.drop_all()
    		self.app_context.pop()
    	#...

新应用程序将存储在 `self.app`中，但创建应用程序不足以使一切正常。得考虑到`db.create_all()`创建数据库表的语句。db实例需要知道应用程序实例是什么，因为它需要从`app.config`中取得数据库URI，但是当有一个应用程序的工厂，是不是真的局限于单一的应用程序时，可能有一个以上的创建。那么`db` 如何知道使用我们刚刚创建的 `self.app`实例？

答案就在**应用程序上下文**中。还记得 `current_app`变量，当没有要导入的全局应用程序时，这个变量以某种方式充当应用程序的代理吗？这个变量在当前线程中查找活动应用程序上下文，如果找到，则从中获取应用程序。如果没有上下文，则无法知道哪个应用程序处于活动状态，因此 `current_app`会引发异常。我们可以在下方看到 它在Python控制台中的工作原理。这需要是通过运行 python启动的控制台，因为flask shell命令会自动激活一个应用程序上下文以方便使用。

(venv) D:\microblog>python
    Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> from flask import current_app
    >>> current_app.config['SQLALCHEMY_DATABASE_URI']
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "D:\microblog\venv\lib\site-packages\werkzeug\local.py", line 347, in __getattr__
        return getattr(self._get_current_object(), name)
      File "D:\microblog\venv\lib\site-packages\werkzeug\local.py", line 306, in _get_current_object
        return self.__local()
      File "D:\microblog\venv\lib\site-packages\flask\globals.py", line 51, in _find_app
        raise RuntimeError(_app_ctx_err_msg)
    RuntimeError: Working outside of application context.
    
    This typically means that you attempted to use functionality that needed
    to interface with the current application object in some way. To solve
    this, set up an application context with app.app_context().  See the
    documentation for more information.
    >>> from app import create_app
    >>> app = create_app()
    [2018-08-29 14:42:53,590] INFO in __init__: Microblog startup
    >>> app.app_context().push()
    >>> current_app.config['SQLALCHEMY_DATABASE_URI']
    'sqlite:///D:\\microblog\\app.db'

这就是秘密！调用视图函数之前，Flask推送一个应用程序上下文，这使`current_app` 和 `g`处于活动。请求完成后，将删除上下文、以及这些变量。对于在单元测试`setUp()`方法中的`db.create_all()`调用，我推送了刚刚创建的应用程序实例的应用程序上下文，并以这种方式，`db.create_all()`可以使用`current_app.config`来知道数据库的位置。然后，在`tearDown()`方法中弹出上下文将所有内容重置为干净状态。

应该还知道 应用程序上下文 是Flask使用的两个上下文之一。还有一个 请求上下文，它更具体，因为它适用于请求。在处理请求之前激活请求上下文时，Flask的`request`和`session`变量、以及Flask-Login的`current_user`都将变得可用。

# 环境变量 #

正如在构建这个应用程序时看到的那样，有许多配置选项依赖于在启动服务器之前在我们的环境中设置变量。包括 密钥、电子邮件服务器信息、数据库URL、百度翻译API密钥等。这样做很不方便，因为每次打开新的终端会话时，都需要再次设置这些变量。

依赖于大量环境变量的应用程序的常见模式是将它们存储在根应用程序目录中的`.env`文件中。应用程序会启动时就会导入此文件中的变量，这样就不需要手动设置所有这些变量。

有一个支持.env文件的Python包，名为 python-dotenv。在[第1章][1]已安装过。当时未成功运用。

由于`config.py`模块 是我们读取所有环境变量的地方，因此我将在创建 `Config`类之前导入`.env`文件，以便在构造类时设置变量：  
**microblog/config.py**：

import os
    from dotenv import load_dotenv
    
    basedir = os.path.abspath(os.path.dirname(__file__))
    load_dotenv(os.path.join(basedir, '.env'))
    
    class Config(object):
        # ...

因此，现在可创建一个包含应用程序所需的所有环境变量的 `.env`文件。不过请不要将`.env`文件添加到 源代码管理中，因为肯定不希望文件包含源代码存储库包含的密码和其他敏感信息。

这个`.env`文件可用于所有的配置时变量，但是它不能用于Flask的 `FLASK_APP`和`FLASK_DEBUG`公共环境变量（可使用`.flaskenv`文件，[参考文档][Link 1]），因为这些在应用程序的引导过程中是非常早期就需要，即在应用程序实例和其配置对象存在之前。

以下示例显示了microblog/microblog.env文件：

MAIL_SERVER=smtp.qq.com
    MAIL_PORT=465
    MAIL_USE_SSL=True
    MAIL_USERNAME=you-qq@qq.com
    MAIL_PASSWORD=授权码
    APPID=you-baidufanyi-appid
    BD_TRANSLATOR_KEY=you-baidufanyi-secret

# 依赖文件 #

到目前为止，已在Python虚拟环境中安装了相当多的软件包。如果需要在另一台机器上重新生成环境，那么将无法记得必须安装的软件包，因此普遍接受的做法是在项目根文件夹中编写一个`requirements.txt`文件，列出所有的依赖项、以及其版本。生成这个列表实际很简单：

(venv) D:\microblog>pip freeze > requirements.txt

`pip freeze`命令 将把安装在了正确格式的虚拟环境中的所有软件包存储在`requirements.txt`文件中。现在，如果需要在另一台计算机上创建相同的虚拟环境，而不用逐个安装软件包，那么可运行：

pip install -r requirements.txt

目前为止，项目结构：

microblog/
    	app/
    		auth/
    		errors/
    		main/
    		static/
    		templates/
    			auth/
    			email/
    			_post.html
    			base.html
    			edit_profile.html
    			index.html
    			user.html
    		__init__.py
    		cli.py
    		email.py
    		models.py
    		translate.py
    	logs/
    	migrations/
    	env/
    	app.db
    	babel.cfg
    	config.py
    	microblgo.env
    	microblog.py
    	requirements.txt
    	tests.py

参考：  
[作者博客][Link 2]  
[源代码][Link 3]

如需转载请注明出处。

[1]: https://blog.csdn.net/weixin_38256474/article/details/81354752
[Link 1]: http://flask.pocoo.org/docs/1.0/cli/
[Link 2]: https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-xv-a-better-application-structure
[Link 3]: https://github.com/miguelgrinberg/microblog/tree/v0.15