Flask Framework Cookbook-第十二章 其他贴士和技巧

第十二章 其他贴士和技巧

这本书已经覆盖了使用Flask创建web应用需要知道的所有东西。但还是有很多需要你自己去探索。最后一章,我们将讲述额外一些小节,如果有必要的话,他们可以被添加进应用。

这一章,将包含下面内容:

  • 使用Whoosh进行全文搜索
  • 使用Elasticsearch进行全文搜索
  • 使用signals
  • 使用缓存
  • 为Flask应用支持E-mail
  • 理解异步操作
  • 使用Celery

介绍

这一章,我们首先将学习如何使用Whoosh和Elasticsearch进行全文搜索。全文搜索对于提供大量内容和选项的Web应用程序(如电子商务网站)非常重要。接下来我们将捕捉信号,这些信号是在应用里某些操作执行时被发送的。然后为我们的Flask应用实现缓存。
我们同样将会看到应用如何支持发送e-mail。然后将看到如何实现应用异步。通常,WSGI应用是同步和阻塞的,不能同时处理多个同步请求。我们将看到如何通过一个简单的例子解决这个问题。我们还会集成Celery到我们的应用,看一个任务队列对应用带来的好处。

使用Whoosh进行全文搜索

Whoosh是使用Python完成的一个快速全文索引和搜索库。它是一个完全Pythonic的API,使得开发者为他们的应用增加搜索功能非常容易和高效。这一节,我们将使用一个叫做Flask-WhooshAlchemy的包,它集成了Whoosh文本搜索功能和SQLAlchemy,以便用于Flask应用中。

准备

使用下面命令安装Flask-WhooshAlchemy:

$ pip install flask_whooshalchemy

它将安装需要的包和依赖。

译者注

flask_whooshalchemy不支持Python3,另外对中文支持也不好,不推荐使用,可以使用jieba。

怎么做

使用SQLAlchemy集成Whoosh和Flask是非常简单的。首先,我们需要提供一个Whoosh目录的路径,这个目录下将创建模型索引。这应该在应用配置里完成,即my_app/__init__.py:

app.config['WHOOSH_BASE'] = '/tmp/whoosh'

你可以选择任意你喜欢的路径,可以是绝对路径也可以是相对路径。

接下来,我们需要改变models.py文件,使得一些string/text字段可搜索:

import flask.ext.whooshalchemy as whooshalchemy
from my_app import app

class Product(db.Model):
    __searchable__ = ['name', 'company']
    # … Rest of code as before … #

whooshalchemy.whoosh_index(app, Product)

class Category(db.Model):
    __searchable__ = ['name']
    # … Rest of code as before … #

whooshalchemy.whoosh_index(app, Category)

注意每个模型添加的__searchable__语句。它告诉Whoosh去创建这些字段的索引。记住这些字段应该是text或者是string类型的。whoosh_index语句告诉应用为这些模型创建索引,如果他们还不存在的话。

做好这些之后,添加一个handler使用Whoosh进行搜索。可以在views.py处理这些:

@catalog.route('/product-search-whoosh')
@catalog.route('/product-search-whoosh/<int:page>')
def product_search_whoosh(page=1):
    q = request.args.get('q')
    products = Product.query.whoosh_search(q)
    return render_template(
        'products.html', products=products.paginate(page, 10)
    )

这里,通过q获取URL参数,然后传递它的值到whoosh_search()方法里。这个方法将会对Product模型的name和company字段进行全文搜索。我们前面已经进行了设置,使得模型里的name和company变得可搜索了。

原理

在第四章基于SQL搜索一节中我们实现了一个基于基本字段搜索的方法。但是在使用Whoosh情况下,搜索时我们不需要指定任何字段。我们可以输入任何字段,如何匹配上可搜索字段的话,将会返回结果,并按照相关性进行排序。

首先,在应用创建一些商品。现在,打开http://127.0.0.1:5000/product-search-whoosh?q=iPhone,结果页将显示商品名包含iPhone的列表。

提示

Whoosh提供了一些高级选项,我们可以控制哪些字段可以搜索或者结果是如何排序的。你可以根据应用的需要自行探索。

其他

  • 参考 https://pythonhosted.org/Whoosh/
  • 参考 https://pypi.python.org/pypi/Flask-WhooshAlchemy

使用Elasticsearch进行全文搜索

Elasticsearch是一个基于Lucene的搜索服务,是一个开源信息检索库。ElasticSearch提供了一个分布式全文搜索引擎,它具有RESTful Web接口和schema-free JSON文档。这一小节,我们将使用Elasticsearch为我们的Flask应用完成全文搜索。

准备

我们将使用一个叫做pyelasticsearch的Python库,它使得处理Elasticsearch很容易:

$ pip install pyelasticsearch

我们同样需要安装Elasticsearch服务本身。可以从http://www.elasticsearch.org/download/下载。解压文件,然后运行下面命令:

$ bin/elasticsearch

默认情况下,将在http://localhost:9200/上运行Elasticsearch服务。

怎么做

为了演示集成,我们将从向应用配置添加Elasticsearch开始,即my_app/__init__.py:

from pyelasticsearch import ElasticSearch
from pyelasticsearch.exceptions import IndexAlreadyExistsError

es = ElasticSearch('http://localhost:9200/')
try:
    es.create_index('catalog')
except IndexAlreadyExistsError, e:
    pass

这里,我们从ElasticSearch类创建了一个es对象,它接收了服务器URL。然后创建了一个叫做catalog的索引。他们是在try-except块中处理的,因为如果索引已经存在 ,将会抛出IndexAlradyExistsError,通过捕捉异常,可以忽略这个错误。

接下来,我们需要往Elasticsearch索引里添加文档(document)。可以在视图和模型里完成这些,但是最好是将它添加在模型层。所以,我们将在models.py里完成这些:

from my_app import es

class Product(db.Model):

    def add_index_to_es(self):
        es.index('catalog', 'product', {
            'name': self.name,
            'category': self.category.name
        })
        es.refresh('catalog')

class Category(db.Model):

    def add_index_to_es(self):
        es.index('catalog', 'category', {
            'name': self.name,
        })
        es.refresh('catalog')

这里,在每个模型里,我们添加了一个叫做add_index_to_es()的方法,这个方法将添加与当前Product或者Category对象对应的文档到catalog索引里,并伴随相关的文件类型,即product或category。最后,我们刷新索引以保证新建的索引可以被搜索到。

add_index_to_es()方法可以在我们创建,更新,删除商品时被调用。为了演示,我们仅仅在views.py创建商品时添加了这个方法:

from my_app import es

def create_product():
    #... normal product creation as always ...#
    db.session.commit()
    product.add_index_to_es()
    #... normal process as always ...#

@catalog.route('/product-search-es')
@catalog.route('/product-search-es/<int:page>')
def product_search_es(page=1):
    q = request.args.get('q')
    products = es.search(q)
    return products

同时,添加一个product_search_es()方法,允许在刚刚创建的Elasticsearch上进行搜索。对create_category()方法做同样的处理。

怎么做

假设已经在每个类别里面创建一些商品。现在,如果打开http://127.0.0.1:5000/product-search-es?q=galaxy,我们将看到类似于下面截图的回复:

使用signals

Signals可以理解为应用里发生的事件。这些事件可以被一些特定接收方订阅,当事件发生的时候会触发一个函数。事件的发生由发送方广播,发送方可以指定接收方触发函数里可以使用的参数。

提示

您应该避免修改信号中的任何应用程序数据,因为信号不是按指定的顺序执行的,而且很容易导致数据损坏。

准备

我们将使用一个叫做binker的Python库,它提供了一些信号特性。Flask内建了对blinker的支持,可以很大程度上使用信号。其中一些核心信号是由Flask提供的。

这一小节,我们将使用上一小节的应用,通过信号添加额外的product和category文档(documents)到索引里。

怎么做

首先,我们创建新建商品和类别时的信号。可以在models.py中处理这个。也可以在任何我们希望的文件里处理,因为信号是在全局范围创建的:

from blinker import Namespace

catalog_signals = Namespace()
product_created = catalog_signals.signal('product-created')
category_created = catalog_signals.signal('category-created')

我们使用Namespace去创建信号,因为这将在自定义命名空间创建他们,而不是在全局空间,这将有助于管理信号。我们创造了两个信号,可以从他们的名字明白他们的意思。

之后,我们需要去为这些信号创建订阅者,给他们绑定函数。为了这个目的,add_index_to_es()需要被移除,在全局范围需要创建新的函数:

def add_product_index_to_es(sender, product):
    es.index('catalog', 'product', {
        'name': product.name,
        'category': product.category.name   
    })
    es.refresh('catalog')

product_created.connect(add_product_index_to_es, app)

def add_category_index_to_es(sender, category):
    es.index('catalog', 'category', {
        'name': category.name,
    })
    es.refresh('catalog')

category_created.connect(add_category_index_to_es, app)

前面的代码中,我们使用.connect()为信号创建了订阅者。这个方法接收一个函数,这个函数会在事件发生时调用。它同样接收一个发送方做为可选参数。app对象作为发送者被提供,因为,我们不希望我们的函数在任何应用任何地方触发的时候都会被调用。这在扩展的情况下尤其适用,可以被多个应用程序使用。接收方调用的函数接收发送者作为第一个参数,如果发送方没提供的话,通常情况下是None。我们提供product/category作为第二个参数,为了将这条记录添加进Elasticsearch索引。

现在,我们仅仅需要触发可以被接收方捕捉的信号。可以在views.py处理这些。为了达到这个目的,需要移除add_index_to_es()方法,使用.send()方法替换他们:

from my_app.catalog.models import product_created, category_created

def create_product():
    #... normal product creation as always ...#
    db.session.commit()
    product_created.send(app, product=product)
    # product.add_index_to_es()
    #... normal process as always ...#

对create_category()做同样的处理。

原理

当一个商品被创建的时候,product_created信号被触发了,app做为发送方,商品做为关键参数。这个会在models.py中被捕捉,当add_product_index_to_es()函数被调用的时候,会向目录索引添加文档。

其他

  • 参考资料 https://pypi.python.org/pypi/blinker
  • 参考资料 http://flask.pocoo.org/docs/0.10/signals/#core-signals
  • Flask-SQLAlchemy提供的信号可以在https://pythonhosted.org/Flask-SQLAlchemy/signals.html找到

使用缓存

当应用程序的响应时间增加成为一个问题时,缓存成为了任何Web应用程序的重要组成部分。Flask本身默认不提供任何缓存支持,但是Werkzeug支持。Werkzeug对缓存提供了基本的支持,并可以使用多种后端(backend),比如Memcached和Redis。

准备

我们将安装一个叫做Flask-Cache的扩展,这会在很大程度上简化缓存的使用:

$ pip install Flask-Cache

怎么做

首先,需初始化Cache。将在应用配置里进行处理,my_app/__init__.py

from flask.ext.cache import Cache

cache = Cache(app, config={'CACHE_TYPE': 'simple'})

这里,使用simple做为Cache的类型,缓存存储在内存里。不建议在生产环境这样做。对于生产环境,需使用Redis,Memcached,文件系统等等这些。Flask-Cache对这些全部支持。

接下来,需在方法里增加缓存;这是非常容易实现的。我们仅仅需要对视图方法增加@cache.cached(timeout=

from my_app import cache
@catalog.route('/categories')
@cache.cached(timeout=120)
def categories():
    # Fetch and display the list of categories  

这种缓存方式以键值对的形式进行存储,键为请求路径,值为这个方法的输出值。

原理

在添加了前面的代码后,检查缓存是否生效。首先访问http://127.0.0.1:5000/categories获取类别列表。在将会在缓存里为这个URL存储一个键值对。现在,快速的创建一个新的类别,然后再次访问商品类别列表页面。你将看到新建的类别没有被列出来。等几分钟,然后刷新页面。新的类别才会被展示出来。这是因为第一次访问的时候类别列表被缓存了,有效时间是2分钟,即120秒。

这可能看起来像是应用的一个错误,但是在大型应用程序中,减少对数据库的访问次数是一种恩惠,并且整个应用程序体验也会得到改善。缓存通常用于那些结果不经常更新的处理程序。

更多

我们中的许多人可能认为,在单个类别或产品页面中,这种缓存将失败,因为每个记录都有一个单独的页面。解决这个问题的方法是memoization。当一个方法用同样参数进行多次调用时,结果应该是从缓存中加载而不是访问数据库。实现memoization非常简单:

@catalog.route('/product/<id>')
@cache.memoize(120)
def product(id):
    # Fetch and display the product

现在,如果我们在浏览器输入http://127.0.0.1:5000/product/1,第一次请求将从数据库读取数据。但是,第二次,如果做相同的访问,将从缓存加载数据。如果我们打开另一个商品页面http://127.0.0.1:5000/product/2,将从数据库获取商品细节。

其他

  • 了解更多Flask-Cache,参见https://pythonhosted.org/Flask-Cache/
  • 了解更多memoization,参见http://en.wikipedia.org/wiki/Memoization

为Flask应用支持E-mail

发送邮件功能是任何web应用最基础功能中的一个。基于Python的应用,可以使用smptblib非常容易的完成这一功能。在Flask中,使用Flask-Mail扩展更加简化了这一过程。

准备

Flask-Mail通过pip安装:

$ pip install Flask-Mail

让我们以一个简单的例子为例,每当添加新类别时,将向应用管理者发送一封e-mail。

怎么做

首先,需要在应用配置里实例化Mail对象,即my_app/__init__.py:

from flask_mail import Mail

app.config['MAIL_SERVER'] = 'smtp.gmail.com'
app.config['MAIL_PORT'] = 587
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USERNAME'] = 'gmail_username'
app.config['MAIL_PASSWORD'] = 'gmail_password'
app.config['MAIL_DEFAULT_SENDER'] = ('Sender name', 'sender email')
mail = Mail(app)

同时,我们需一些配置去创建e-mail服务和发送者账号。前面的代码是一个配置Gmail账户的简单示例。任何SMTP服务可以像这样建立。还有一些其他选项可以选择,可以参见Flask-Mail文档https://pythonhosted.org/Flask-Mail

原理

在类别创建的时候发送e-mail,我们需要对view.py做下面修改:

from my_app import mail
from flask_mail import Message

@catalog.route('/category-create', methods=['GET', 'POST'])
def create_category():
    # … Create category … #
    db.session.commit()
    message = Message(
        "New category added",
        recipients=['some-receiver@domain.com']
    )
    message.body = 'New category "%s" has been created' % category.name
    mail.send(message)
    # … Rest of the process … #

这里,一个新的e-mail将从我们创建的发送方发送给接收列表方。

更多

现在,假设需要发送一封非常大的邮件,包含非常多的HTML文本。将这些全都写在Python文件里会使得代码丑陋和难以管理。一个简单的方法是创建模板,然后在发送邮件的时候渲染。我创建了两个模板,一个是HTML文本,一个纯文本。

category-create-email-text.html模板看起来像这样:

A new category has been added to the catalog.
The name of the category is {{ category.name }}.
Click on the URL below to access the same:
{{ url_for('catalog.category', id=category.id, _external = True) }}
This is an automated email. Do not reply to it.

category-create-email-html.html模板看起来像这样:

<p>A new category has been added to the catalog.</p>
<p>The name of the category is <a href="{{ url_for('catalog.category', id=category.id, _external = True) }}">
        <h2>{{ category.name }}</h2>
    </a>.
</p>
<p>This is an automated email. Do not reply to it.</p>

之后,我们需修改之前在views.py里创建e-mail的代码;

message.body = render_template(
    "category-create-email-text.html", category=category
)
message.html = render_template(
    "category-create-email-html.html", category=category
)

其他

  • 阅读下一小节,明白怎么将耗时的email发送过程用一个异步线程处理

理解异步操作

应用中有一些操作可能是耗时的,会使用应用变慢,即使这并不是真正意义上的慢。但这降低了用户体验。为了解决这个问题,最简单的方式是使用线程进行异步操作。这一小节,我们将使用Python的thread和threading库来完成这一功能。threading库是thread的一个简单接口;它提供了更多功能和隐藏了用户不常使用的一些东西。

准备

我们将使用上一小节的应用代码。我们中的许多人可能会注意到当邮件在发送的时候,应用在等待这一过程完成,事实上这是不必要的。E-mail发送可以在后台处理,这样我们的应用对用户来说响应就变得及时。

怎么做

使用thread库处理异步是非常简单。仅仅需要在views.py里增加这些代码:

import thread

def send_mail(message):
    with app.app_context():
        mail.send(message)
# Replace the line below in create_category()
#mail.send(message)
# by
thread.start_new_thread(send_mail, (message,))

你可以看到,在一个新的线程里发生邮件,这个线程接收一个叫message的参数。我们需要去创建一个新的send_mail()方法,因为我们的e-mail模板包含url_for,所以send_mail方法仅能运行在应用上下文中,默认情况下在一个新建的线程里不可用。

同时,发送e-mail同样可以使用threading库:

from threading import Thread

# Replace the previously added line in create_category() by
new_thread = Thread(target=send_mail, args=[message])
new_thread.start()

实际上,效果和前面一样,但是threading库提供了在需要的时候启动线程的灵活性,而不是同时创建和启动线程。

原理

很容易观察上面代码的效果。比较这个应用的执行效果和前一小节的应用效果。你会发现这个应用响应性更强。其他一种方式是监测日志输出,在e-mail发送之前,新建的类别页面将会加载。

使用Celery

Celery是为Python准备的任务队列。早期的时候有一个扩展是集成了Flask和Celery,但是在Celery3.0的时候,这个扩展被废弃了。现在,Celery可以直接在Flask里使用,而仅仅需做一些配置。前面小节,我们实现了异步发送邮件,这一小节将使用Celery完成同样的功能。

准备

安装Celery:

$ pip install celery

在Flask下使用Celery,我们仅仅需要修改一点Flask app配置。这里,使用Redis做为代理(broker)。
我们将使用前一小节的应用,然后使用Celery完成它。

怎么做

首先要做的是,在应用配置文件里做一些配置,即my_app/__init__.py:

from celery import Celery

app.config.update(
    CELERY_BROKER_URL='redis://localhost:6379',
    CELERY_RESULT_BACKEND='redis://localhost:6379'
)
def make_celery(app):
    celery = Celery(
        app.import_name, broker=app.config['CELERY_BROKER_URL']
    )
    celery.conf.update(app.config)
    TaskBase = celery.Task
    class ContextTask(TaskBase):
        abstract = True
        def __call__(self, *args, **kwargs):
            with app.app_context():
                return TaskBase.__call__(self, *args, **kwargs)
    celery.Task = ContextTask
    return celery

前面的代码直接来自于Flask网站,大部分情况下可以在应用里这样使用:

celery = make_celery(app)

运行Celery进程,需执行下面命令:

$ celery worker -b redis://localhost:6379 --app=my_app.celery -l INFO
提示

确保Redis运行在broker URL上,如配置中所指定的那样。

这里,-b指定了broker,-app指定了在配置文件里创建的celery对象。
现在,仅仅需要在views.py里使用celery对象去异步发送邮件:

from my_app import celery

@celery.task()
def send_mail(message):
    with app.app_context():
        mail.send(message)

# Add this line wherever the email needs to be sent
send_mail.apply_async((message,))

如果我们希望一个方法作为Celery任务运行只需增加@celery.task装饰器即可。Celery进程会自动检测到这些方法。

原理

现在,我们创建了一个商品,并且一封邮件发送了,我们可以在Celery进程日志里看到一个任务正在运行,看起来像这样:

[2014-08-28 01:16:47,365: INFO/MainProcess] Received task: my_app.catalog.views.send_mail[d2ca07ae-6b47-4b76-9935-17b826cdc340]
[2014-08-28 01:16:55,695: INFO/MainProcess] Task my_app.catalog.views.send_mail[d2ca07ae-6b47-4b76-9935-17b826cdc340] succeeded in 8.329121886s: None

其他

  • 更多Celery信息,参见 http://docs.celeryproject.org/en/latest/index.html
阅读更多
文章标签: Python Flask Cookbook
个人分类: Flask Framework Cookbook
上一篇Flask Framework Cookbook-第十一章 部署
想对作者说点什么? 我来说一句

Learning Flask Framework 无水印pdf 0分

2016年01月10日 2.61MB 下载

Flask Framework Cookbook.pdf

2017年08月10日 2.84MB 下载

没有更多推荐了,返回首页

关闭
关闭