安装¶

使用下面的命令行安装 Flask-Cache:

$ easy_install Flask-Cache

或者可以用下面的命令行，如果安装了 pip:

$ pip install Flask-Cache

使用¶

缓存（Cache）是通过使用一个 Cache 实例进行管理:

from flask import Flask
from flask.ext.cache import Cache

app = Flask(__name__)
cache = Cache(app)

你能够用 init_app 方法在初始化 Cache 后设置它:

cache = Cache()

app = Flask(__name__)
cache.init_app(app)

如果有多个 Cache 实例以及每一个实例都有不同后端的话（换句话说，就是每一个实例使用不用的缓存类型CACHE_TYPE），使用配置字典是十分有用的:

#: Method A: During instantiation of class
cache = Cache(config={'CACHE_TYPE': 'simple'})
#: Method B: During init_app call
cache.init_app(app, config={'CACHE_TYPE': 'simple'})

New in version 0.7.

缓存视图函数¶

使用装饰器 cached() 能够缓存视图函数。它在默认情况下使用请求路径(request.path)作为cache_key:

@cache.cached(timeout=50)
def index():
    return render_template('index.html')

该装饰器有一个可选的参数：unless，它允许一个可调用的、返回值是True或者False的函数。如果 unless 返回 True，将会完全忽略缓存机制（内置的缓存机制会完全不起作用）。

缓存其它函数¶

同样地，使用 @cached 装饰器也能够缓存其它非视图函数的结果。唯一的要求是需要指定 key_prefix，否则会使用请求路径(request.path)作为cache_key:

@cache.cached(timeout=50, key_prefix='all_comments')
def get_all_comments():
    comments = do_serious_dbio()
    return [x.author for x in comments]

cached_comments = get_all_comments()

Memoization（一种缓存技术）¶

请参看 memoize()

在memoization中，函数参数同样包含cache_key。

Memoize同样也为类成员函数而设计，因为它根据 identity 将 ‘self’ 或者 ‘cls’ 参数考虑进作为缓存键的一部分。

memoization背后的理论是：在一次请求中如果一个函数需要被调用多次，它只会计算第一次使用这些参数调用该函数。例如，存在一个决定用户角色的 sqlalchemy对象，在一个请求中可能需要多次调用这个函数。为了避免每次都从数据库获取信息，你可以这样做:

class Person(db.Model):
    @cache.memoize(50)
    def has_membership(self, role_id):
            return Group.query.filter_by(user=self, role_id=role_id).count() >= 1

class Person(db.Model):
    def __repr__(self):
        return "%s(%s)" % (self.__class__.__name__, self.id)

cache.delete_memoized('user_has_membership')

user_has_membership('demo', 'admin')
user_has_membership('demo', 'user')

cache.delete_memoized('user_has_membership', 'demo', 'user')

缓存Jinja2片段¶

用法:

{% cache [timeout [,[key1, [key2, ...]]]] %}
...
{% endcache %}

默认情况下“模版文件路径”+“片段开始的函数”用来作为缓存键。同样键名是可以手动设置的。键名串联成一个字符串，这样能够用于避免同样的块在不同模版被重复计算。

为了删除缓存值，为“del”设置超时时间:

{% cache 'del' %}...

如果提供键名，你可以很容易地产生模版的片段密钥，从模板上下文外删除它:

from flask.ext.cache import make_template_fragment_key
key = make_template_fragment_key("key1", vary_on=["key2", "key3"])
cache.delete(key)

例子:

Considering we have render_form_field and render_submit macroses.
{% cache 60*5 %}
<div>
    <form>
    {% render_form_field form.username %}
    {% render_submit %}
    </form>
</div>
{% endcache %}

清除缓存¶

请参看 clear().

下面的例子是一个用来清空应用缓存的脚本：

from flask.ext.cache import Cache

from yourapp import app, your_cache_config

cache = Cache()


def main():
    cache.init_app(app, config=your_cache_config)

    with app.app_context():
        cache.clear()

if __name__ == '__main__':
    main()

配置Flask-Cache¶

Flask-Cache有下面一些配置项:

此外，如果标准的Flask配置项 TESTING 使用并且设置为True的话， Flask-Cache 将只会使用NullCache作为缓存类型。

内建的缓存类型¶

定制缓存后端（后台）¶

你能够轻易地定制缓存后端，只需要导入一个能够实例化以及返回缓存对象的函数。CACHE_TYPE 将是你自定义的函数名的字符串。 这个函数期望得到三个参数。

• app
• args
• kwargs

你自定义的缓存对象必须是 werkzeug.contrib.cache.BaseCache 的子类。确保 threshold 是包含在kwargs参数中，因为它是所有BaseCache类通用的。

Redis的缓存实现的一个例子:

#: the_app/custom.py
class RedisCache(BaseCache):
    def __init__(self, servers, default_timeout=500):
        pass

def redis(app, config, args, kwargs):
   args.append(app.config['REDIS_SERVERS'])
   return RedisCache(*args, **kwargs)

在这个例子中，CACHE_TYPE 可能就是 the_app.custom.redis。

PylibMC缓存实现的一个例子:

#: the_app/custom.py
def pylibmccache(app, config, args, kwargs):
    return pylibmc.Client(servers=config['CACHE_MEMCACHED_SERVERS'],
                          username=config['CACHE_MEMCACHED_USERNAME'],
                          password=config['CACHE_MEMCACHED_PASSWORD'],
                          binary=True)

在这个例子中，CACHE_TYPE 可能就是 the_app.custom.pylibmccache。

API¶

class flask.ext.cache.Cache(app=None, with_jinja2_ext=True, config=None)¶

This class is used to control the cache objects.

init_app(app, config=None)¶

This is used to initialize cache with your app object

get(*args, **kwargs)¶

Proxy function for internal cache object.

set(*args, **kwargs)¶

Proxy function for internal cache object.

add(*args, **kwargs)¶

Proxy function for internal cache object.

delete(*args, **kwargs)¶

Proxy function for internal cache object.

get_many(*args, **kwargs)¶

Proxy function for internal cache object.

set_many(*args, **kwargs)¶

Proxy function for internal cache object.

delete_many(*args, **kwargs)¶

Proxy function for internal cache object.

clear()¶

Proxy function for internal cache object.

cached(timeout=None, key_prefix='view/%s', unless=None)¶

Decorator. Use this to cache a function. By default the cache key is view/request.path. You are able to use this decorator with any function by changing the key_prefix. If the token %s is located within the key_prefix then it will replace that with request.path

Example:

# An example view function
@cache.cached(timeout=50)
def big_foo():
    return big_bar_calc()

# An example misc function to cache.
@cache.cached(key_prefix='MyCachedList')
def get_list():
    return [random.randrange(0, 1) for i in range(50000)]

my_list = get_list()

Note

You MUST have a request context to actually called any functions that are cached.

New in version 0.4: The returned decorated function now has three function attributes assigned to it. These attributes are readable/writable.

uncached

The original undecorated function

cache_timeout

The cache timeout value for this function. For a custom value to take affect, this must be set before the function is called.

make_cache_key

A function used in generating the cache_key used.

Parameters:

timeout – Default None. If set to an integer, will cache for that amount of time. Unit of time is in seconds. key_prefix – Default ‘view/%(request.path)s’. Beginning key to . use for the cache key. New in version 0.3.4: Can optionally be a callable which takes no arguments but returns a string that will be used as the cache_key. unless – Default None. Cache will always execute the caching facilities unless this callable is true. This will bypass the caching entirely.

memoize(timeout=None, make_name=None, unless=None)¶

Use this to cache the result of a function, taking its arguments into account in the cache key.

Information on Memoization.

Example:

@cache.memoize(timeout=50)
def big_foo(a, b):
    return a + b + random.randrange(0, 1000)

>>> big_foo(5, 2)
753
>>> big_foo(5, 3)
234
>>> big_foo(5, 2)
753

New in version 0.4: The returned decorated function now has three function attributes assigned to it.

uncached

The original undecorated function. readable only

cache_timeout

The cache timeout value for this function. For a custom value to take affect, this must be set before the function is called.

readable and writable

make_cache_key

A function used in generating the cache_key used.

readable and writable

Parameters:

timeout – Default None. If set to an integer, will cache for that amount of time. Unit of time is in seconds. make_name – Default None. If set this is a function that accepts a single argument, the function name, and returns a new string to be used as the function name. If not set then the function name is used. unless – Default None. Cache will always execute the caching facilities unelss this callable is true. This will bypass the caching entirely.

New in version 0.5: params make_name, unless

delete_memoized(f, *args, **kwargs)¶

Deletes the specified functions caches, based by given parameters. If parameters are given, only the functions that were memoized with them will be erased. Otherwise all versions of the caches will be forgotten.

Example:

@cache.memoize(50)
def random_func():
    return random.randrange(1, 50)

@cache.memoize()
def param_func(a, b):
    return a+b+random.randrange(1, 50)

>>> random_func()
43
>>> random_func()
43
>>> cache.delete_memoized('random_func')
>>> random_func()
16
>>> param_func(1, 2)
32
>>> param_func(1, 2)
32
>>> param_func(2, 2)
47
>>> cache.delete_memoized('param_func', 1, 2)
>>> param_func(1, 2)
13
>>> param_func(2, 2)
47

Parameters:	fname – Name of the memoized function, or a reference to the function. *args – A list of positional parameters used with memoized function. **kwargs – A dict of named parameters used with memoized function.

Note

Flask-Cache uses inspect to order kwargs into positional args when the function is memoized. If you pass a function reference into fname instead of the function name, Flask-Cache will be able to place the args/kwargs in the proper order, and delete the positional cache.

However, if delete_memozied is just called with the name of the function, be sure to pass in potential arguments in the same order as defined in your function as args only, otherwise Flask-Cache will not be able to compute the same cache key.

Note

Flask-Cache maintains an internal random version hash for the function. Using delete_memoized will only swap out the version hash, causing the memoize function to recompute results and put them into another key.

This leaves any computed caches for this memoized function within the caching backend.

It is recommended to use a very high timeout with memoize if using this function, so that when the version has is swapped, the old cached results would eventually be reclaimed by the caching backend.

delete_memoized_verhash(f, *args)¶

Delete the version hash associated with the function.

..warning:

Performing this operation could leave keys behind that have
been created with this version hash. It is up to the application
to make sure that all keys that may have been created with this
version hash at least have timeouts so they will not sit orphaned
in the cache backend.

Changelog¶