• flask中使用redis做缓存

    1.介绍

    缓存介绍

    如果您的应用运行很慢，那就尝试引入一些缓存吧。好吧，至少这是提高表现最简单的方法。缓存的工作是什么呢？比如说您有一个需要一段时间才能完成的函数，但是这个函数的返回结果可能在5分钟之内都是足够有效的，因此您可以将这个结果放到缓存中一段时间，而不用反复计算。
    如果同一个请求会被多次调用，每次调用都会消耗很多资源，并且每次返回的内容都相同，就该使用缓存了

    Flask 本身并不提供缓存功能，但是作为Flask 基础的 Werkzeug 库，则提供了一些基础的缓存支持。

    Werkzeug 支持多种缓存后端，通常的选择是 Memcached 服务器。

    缓存类型

    我们来了解一下flask-caching支持的缓存类型：

    flask-caching内置的缓存类型CACHE_TYPE有：NullCache、SimpleCache、FileSystemCache、RedisCache、RedisSentinelCache、RedisClusterCache、UWSGICache、MemcachedCache、SASLMemcachedCache和SpreadSASLMemcachedCache（在Flask-Caching2.0中删除）。

    其中：

    NullCache：无缓存，其配置参数可以有：

    • CACHE_NO_NULL_WARNING：不会抛出警告信息；
    • CACHE_DEFAULT_TIMEOUT：如果未指定超时，则使用默认超时，时间单位是秒。

    SimpleCache：使用本地python字典进行存储，非线程安全，其配置参数可以有：

    • CACHE_DEFAULT_TIMEOUT：如果未指定超时，则使用默认超时，时间单位是秒；
    • CACHE_THRESHOLD：最大缓存数；
    • CACHE_IGNORE_ERRORS：其值为True时，在删除过程中发生的任何错误将被忽略；其值为False时，在删除过程中第一个错误时停止删除；

    FileSystemCache：使用文件系统来存储缓存的值，其配置参数可以有：

    • CACHE_DEFAULT_TIMEOUT：如果未指定超时，则使用默认超时，时间单位是秒；
    • CACHE_IGNORE_ERRORS：其值为True时，在删除过程中发生的任何错误将被忽略；其值为False时，在删除过程中第一个错误时停止删除；
    • CACHE_DIR：存储缓存的目录；
    • CACHE_THRESHOLD：最大缓存数；
    • CACHE_OPTIONS：在缓存类实例化期间传递的可选字典。

    RedisCache：使用Redis作为缓存后端，其配置参数可以有：

    • CACHE_DEFAULT_TIMEOUT：如果未指定超时，则使用默认超时，时间单位是秒；
    • CACHE_KEY_PREFIX：所有它都可以用于应用程序的应用程序使用相同的键；
    • CACHE_OPTIONS：在缓存类实例化期间传递的可选字典；
    • CACHE_REDIS_HOST：Redis 服务器主机；
    • CACHE_REDIS_PORT：Redis 服务器端口，默认为 6379；
    • CACHE_REDIS_PASSWORD：服务器的 Redis 密码；
    • CACHE_REDIS_DB ：Redis db（从零开始的数字索引），默认为 0；
    • CACHE_REDIS_URL：| 连接到 Redis 服务器的 URL，例子redis://user:password@localhost:6379/2 。

    RedisSentinelCache：使用Redis哨兵模型缓存，其配置参数可以有：

    • CACHE_KEY_PREFIX：所有它都可以用于应用程序的应用程序使用相同的键；
    • CACHE_REDIS_SENTINELS：Redis哨兵地址的列表或元组；
    • CACHE_REDIS_SENTINEL_MASTER：哨兵配置中的主服务器的名称
    • CACHE_REDIS_PASSWORD：服务器的 Redis 密码；
    • CACHE_REDIS_DB：Redis db（从零开始的数字索引），默认为 0。

    RedisClusterCache：使用Redis自动分区缓存，其配置参数可以有：

    • CACHE_KEY_PREFIX：所有它都可以用于应用程序的应用程序使用相同的键；
    • CACHE_REDIS_CLUSTER：一串以逗号分隔的 Redis 集群节点地址；
    • CACHE_REDIS_PASSWORD：服务器的 Redis 密码。

    MemcachedCache：使用memcached服务器作为缓存后端，支持pylibmc或memcache或Google应用程序引擎memcache库，其配置参数可以有：

    • CACHE_DEFAULT_TIMEOUT：如果未指定超时，则使用默认超时，时间单位是秒；
    • CACHE_KEY_PREFIX：所有它都可以用于应用程序的应用程序使用相同的键；
    • CACHE_MEMCACHED_SERVERS：服务器地址的列表或元组。

    注意：Flask-Caching不会将额外的配置选项传递给memcached后端，要向这些缓存添加其他配置。

    SASLMemcachedCache：启用SASL的memcached服务器作为缓存后端，其配置参数可以有：

    • CACHE_DEFAULT_TIMEOUT：如果未指定超时，则使用默认超时，时间单位是秒；
    • CACHE_KEY_PREFIX：所有它都可以用于应用程序的应用程序使用相同的键；
    • CACHE_OPTIONS：在缓存类实例化期间传递的可选字典；
    • CACHE_MEMCACHED_SERVERS：服务器地址的列表或元组；
    • CACHE_MEMCACHED_USERNAME：使用memcached进行SASL身份验证的用户名；
    • CACHE_MEMCACHED_PASSWORD：使用memcached进行SASL身份验证的密码。

    UWSGICache：使用uwsgi服务器作为缓存，其配置参数可以有：

    • CACHE_UWSGI_NAME：要连接的uwsgi缓存实例的名称，例如：mycache @ localhost :3031，默认为空字符串；

    注意：该UWSGICache没有维护也没有测试，不建议使用。

     

    2.安装模块

    1. pip3 install redis -i https://pypi.douban.com/simple
    2. pip3 install flask-caching -i https://pypi.douban.com/simple

    3.创建一个Flask-Cache的实例

    3.1介绍

    有很多种实例方式，这里介绍我最常用的一种

    3.2 第一种使用 

    view(推荐)

    1. from flask import Flask
    2. from flask_cache import Cache
    3.  
    4. config={
    5.               'CACHE_TYPE': 'redis',          # Use Redis
    6.               'CACHE_REDIS_HOST': 'abc.com',  # Host, default 'localhost'
    7.               'CACHE_REDIS_PORT': 6379,       # Port, default 6379
    8.               'CACHE_REDIS_PASSWORD': '111',  # Password
    9.               'CACHE_REDIS_DB': 2
    10. }         
    11.  
    12.  
    13. app = Flask(__name__)
    14. # 实例
    15. cache = Cache(config=config)
    16. # 绑定到app上
    17. cache.init_app(app)

    3.3 其他种使用

    1. from flask import Flask
    2. from flask_caching import Cache
    3. #配置RedisCache缓存类型参数值，我们使用本地的redis，没有密码
    4. config={     
    5.     'CACHE_TYPE':'redis',  #使用redis作为缓存
    6.     'CACHE_REDIS_HOST':'127.0.0.1',  #redis地址
    7.     'CACHE_REDIS_PORT':6379  #redis端口号
    8. }
    9.  
    10. app = Flask(__name__)
    11. #初始化缓存
    12. cache=Cache(app=app,config=config)  #创建Cache对象
    13. #或使用init_app()初始化缓存
    14. #cache=Cache()         #创建Cache对象
    15. #cache.init_app(app=app,config=config)
    16.  
    17. @app.route('/')
    18. def hello_world():
    19.     return 'Hello World!'
    20.  
    21. if __name__ == '__main__':
    22.     app.run()

    3.3 介绍参数

    1. CACHE_TYPE:设置缓存的类型
    2.  
    3. # 下面五个参数是所有的类型共有的
    4. CACHE_NO_NULL_WARNING = "warning" # null类型时的警告消息
    5. CACHE_ARGS = []	# 在缓存类实例化过程中解包和传递的可选列表，用来配置相关后端的额外的参数
    6. CACHE_OPTIONS = {}	# 可选字典,在缓存类实例化期间传递，也是用来配置相关后端的额外的键值对参数
    7. CACHE_DEFAULT_TIMEOUT # 默认过期/超时时间，单位为秒
    8. CACHE_THRESHOLD	# 缓存的最大条目数
    9.  
    10. CACHE_TYPE = null # 默认的缓存类型，无缓存
    11. CACHE_TYPE = 'simple' # 使用本地python字典进行存储，线程非安全
    12.  
    13. CACHE_TYPE = 'filesystem' # 使用文件系统来存储缓存的值
    14. CACHE_DIR = "" # 文件目录
    15.  
    16. CACHE_TYPE = 'memcached' # 使用memcached服务器缓存
    17. CACHE_KEY_PREFIX # 设置cache_key的前缀
    18. CAHCE_MEMCACHED_SERVERS	# 服务器地址的列表或元组
    19. CACHE_MEMCACHED_USERNAME # 用户名
    20. CACHE_MEMCACHED_PASSWORD # 密码
    21.  
    22. CACHE_TYPE = 'uwsgi' # 使用uwsgi服务器作为缓存
    23. CACHE_UWSGI_NAME # 要连接的uwsgi缓存实例的名称
    24.  
    25. CACHE_TYPE = 'redis' # 使用redis作为缓存
    26. CACHE_KEY_PREFIX # 设置cache_key的前缀
    27. CACHE_REDIS_HOST  # redis地址
    28. CACHE_REDIS_PORT  # redis端口
    29. CACHE_REDIS_PASSWORD # redis密码
    30. CACHE_REDIS_DB # 使用哪个数据库
    31. # 也可以一键配置
    32. CACHE_REDIS_URL	连接到Redis服务器的URL。示例redis://user:password@localhost:6379/2

    3.5 配置多个缓存实例

    1. cache1 = Cache()
    2. cache2 = Cache()
    3. cache1.init_app(app, config={ 'CACHE_TYPE' : 'redis','CACHE_REDIS_HOST':'192.168.1.20',
    4.                              'CACHE_REDIS_PORT':'6390'})
    5. cache2.init_app(app, config={ 'CACHE_TYPE' : 'redis','CACHE_REDIS_HOST':'192.168.1.21',
    6.                              'CACHE_REDIS_PORT':'6390'})

    4.使用

    装饰器，装饰无参数函数，缓存该函数

    使用格式

    @cache.cached(timeout=None,key_prefix=None,unless=None,forced_update=None,query_string=False)

    参数介绍 

    • timeout为超时时间，默认为None，即永不过期
    • key_prefix：缓存指定的函数；缓存项键值的前缀，默认为”view/%s”
    • unless：是否启用缓存，如果为True，不启用缓存；默认为None，即缓存有效
    • forced_update：缓存是否实时更新，如果为True，无论是否过期都将更新缓存；
    • query_string：为True时，缓存键是先将参数排序然后哈希的结果。

    实例 

    1. @app.route('/test2')
    2. @cache.cached(timeout=30) # 专门为装饰视图函数准备的装饰器
    3. def test2():
    4.     print('111')
    5.     return 'ok'

    装饰器，装饰有参数函数，缓存该函数

    使用格式

    @cache.memoize(timeout=None,make_name=None,unless=None,forced_update=None,query_string=False)

    参数介绍 

    与cache.cached()方法类似，区别为cache.memoize有make_name，其作用是设置函数的标志，如果没有就使用装饰的函数。

    Flask-Cache还提供了另一个装饰器方法”cache.memoize()”，它与”cache.cached()”的区别就是它会将函数的参数也放在缓存项的键值中：

    我们再次访问”/list”地址，对于不同的参数，”method called”会一直在控制台上打印出，而对于相同的参数，第二次就不会打印了。

    所以对于带参数的函数，你要使用”cache.memoize()”装饰器，而对于不带参数的函数，它同”cache.cached()”基本上一样。

    ”cache.memoize()”装饰器也有三个参数，

    ”timeout”和”unless”参数同”cache.cached()”一样，

    就是第二个参数”make_name”比较特别，它是一个回调函数，传入的是被装饰的函数名，返回是一个字符

    实例 

    1. @cache.memoize(timeout=50)
    2. def create_list(num):
    3.     print 'method create_list called'
    4.     l = []
    5.     for i in range(num):
    6.         l.append(str(i))
    7.     return l
    8.  
    9. @app.route('/list/')
    10. def list(num):
    11.     return ', '.join(create_list(num))

     cache.cached用来装饰普通函数

    参数：

            key_prefix：设置函数的标志，如果没有就使用装饰的函数 # 其他参数同cached

    我们访问”/list”地址时，第一次控制台上会有”method called”输出，第二次就不会了，说明缓存起效了。

    装饰普通函数时必须指定明确的”key_prefix”参数，因为它不像视图函数，可以使用请求路径”request.path”作为缓存项的键值。

    如果函数带参数，对于不同的参数调用，都会使用同一缓存项，即返回结果一样。

    1. @cache.cached(timeout=50, key_prefix='get_list')
    2. def get_list():
    3.     print 'method get_list called'
    4.     return ['a','b','c','d','e']
    5.  
    6. @app.route('/list')
    7. def list():
    8.     return ', '. join(get_list())

    @cache.memoize用来装饰普通函数

    参数

    参数：

            make_name：设置函数的标志，如果没有就使用装饰的函数 # 其他参数同cached

    我们访问”/list”地址时，第一次控制台上会有”method called”输出，第二次就不会了，说明缓存起效了。

    装饰普通函数时必须指定明确的”make_name”参数，因为它不像视图函数，可以使用请求路径”request.path”作为缓存项的键值。

    如果函数带参数，对于不同的参数调用，都会使用同一缓存项，即返回结果一样。

    实例

    1. # 装饰有参的函数
    2. @cache.memoize(timeout=60, make_name='get_result')
    3. def get_result(n):
    4.     return str(n)
    5.  
    6. @cache.cached(timeout=30)
    7. def test_xxx():
    8.     return 'this is a test'

    缓存键值对

    实例一

    1. # __init__.py
    2. from flask import Flask, current_app, make_response, request
    3. from test import get_result, test_xxx
    4. from exsentions import cache
    5.  
    6. app = Flask(__name__)
    7. app.config['SECRET_KEY'] = '123'
    8. cache.init_app(app, config={ 'CACHE_TYPE' : 'redis','CACHE_REDIS_HOST':'192.168.1.20',
    9.                              'CACHE_REDIS_PORT':'6390'})
    10.  
    11. @app.route('/test1')
    12. def test():
    13.     cache.set('name','xiaoming', timeout=30)
    14.     cache.set('person',{'name':'aaa', 'age':20})
    15.     x = cache.get('name')
    16.     print(x)
    17.     cache.set_many([('name1','hhh'),('name2','jjj')])
    18.     print(cache.get_many("name1","name2"))
    19.     print(cache.delete("name"))
    20.     print(cache.delete_many("name1","name2"))
    21.     return res
    22.  
    23. if __name__ == '__main__':
    24.     app.run(host='127.0.0.1', port=80, debug=True)

    实例二 

    1. #设置
    2. cache.set(key,value,timeout=None) #设置一个缓存对象
    3. cache.set_many([(key,value),(key,value),...,(key,value)],timeout=None) #设置多个缓存对象
    4. #获取
    5. cache.get(key)        #获取一个缓存对象
    6. cache.get_many(key1,key2,....)  #获取多个缓存对象
    7. #删除
    8. cache.get.delete(key)      #删除一个缓存对象
    9. cache_delete_many(key1,key2,...) #删除多个缓存对象
    10. cache.clear()     #删除所有缓存对象

    删除缓存

    对于普通缓存，你可以使用”delete()”方法来删除缓存项，而对于”memoize”缓存，你需要使用”delete_memoized”方法。如果想清除所有缓存，可以使用”clear()”方法。

    1. cache.delete('get_list')                     # 删除'get_list'缓存项
    2. cache.delete_many('get_list', 'view_hello')  # 同时删除'get_list'和'view_hello'缓存项
    3. cache.delete_memoized('create_list', 5)      # 删除调用'create_list'函数并且参数为5的缓存项
    4. cache.clear()                                # 清理所有缓存

    Jinja2模板中使用缓存

    其实在Jinja2模板中，我们还可以使用”{% cache %}”语句来缓存模板代码块：

    这样”{% cache %}”和”{% endcache %}”语句中所包括的内容就会被缓存起来。”{% cache %}”语句的第一个参数是”timeout”过期时间，默认为永不过期；第二个参数指定了缓存项的键值，如果不设，键值就是”模板文件路径”+”缓存块的第一行”。

    1. {% cache 50, 'temp' %}
    2. <p>This is under cachep>
    3. {% endcache %}

    然后在代码中，我们可以这样获取缓存项实际的键值：

    打印出来看看，你会发现实际的键值其实是”_template_fragment_cache_temp”。如果你要删除该缓存项，记得要传入实际的键值，而不是模板上定义的’temp’。

    1. from flask_cache import make_template_fragment_key
    2. key = make_template_fragment_key('temp')

    本文参考

    (253条消息) Flask-Cache——缓存_qq_41134008的博客-CSDN博客https://blog.csdn.net/qq_41134008/article/details/105698861flask插件系列之flask_caching缓存 - 倥偬时光 - 博客园 (cnblogs.com)https://www.cnblogs.com/cwp-bg/p/9687005.html(253条消息) flask缓存机制_冰_戒的博客-CSDN博客_flask缓存机制https://blog.csdn.net/huang_yong_peng/article/details/82622077

    Flask框架——flask-caching缓存 - 知乎 (zhihu.com)icon-default.png?t=M85Bhttps://zhuanlan.zhihu.com/p/544198743 

  • 相关阅读:
    《网络是怎样连接的》Charpter 1 笔记
    利用gpu加速神经网络算法,为什么用gpu 模型训练
    docker安装elasticsearch、kibana
    Beautiful Soup属性和方法及文档
    C++ —— 引用
    燃气智能巡检系统-燃气入户安检系统
    Selenium浏览器自动化测试框架
    计算机专业，不擅长打代码，考研该怎么选择?
    [附源码]Python计算机毕业设计django学生学习评价与分析系统
    计算机系统（16）----- 调度算法（2）
  • 原文地址：https://blog.csdn.net/qq_52385631/article/details/127613130