十五 Django框架，缓存

由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。

Django中提供了6种缓存方式：
　　1、开发调试，没有实质用途，只是配置了缓存配置
　　2、内存，将缓存保存在本地内存
　　3、文件，将缓存保存在本地文件
　　4、数据库，将缓存保存在数据库
　　5、Memcache缓存（python-memcached模块）将缓存保存在Memcache，用的python-memcached模块
　　6、Memcache缓存（pylibmc模块）将缓存保存在Memcache，用的pylibmc模块

配置

1、开发调试配置，

#缓存配置
# 自定义缓存key
def default_key_func(key, key_prefix, version):
    return ‘%s:%s:%s‘ % (key_prefix, version, key)

# 配置：
CACHES = {
    ‘default‘: {
        ‘BACKEND‘: ‘django.core.cache.backends.dummy.DummyCache‘,   # 开发调试，引擎
        ‘TIMEOUT‘: 300,                                             # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）如果使用中没设置，这里启用
        ‘OPTIONS‘: {
            ‘MAX_ENTRIES‘: 300,                                     # 最大缓存个数（默认300）
            ‘CULL_FREQUENCY‘: 3,                                    # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3，删除百分之3）
        },
        ‘KEY_PREFIX‘: ‘‘,                                           # 缓存key的前缀（默认空）
        ‘VERSION‘: 1,                                               # 缓存key的版本（默认1），设置后缓存key会是，KEY_PREFIX前缀加VERSION版本
        # ‘KEY_FUNCTION‘: default_key_func                           # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
    }
}

2、内存配置

#缓存配置
# 自定义缓存key
def default_key_func(key, key_prefix, version):
    return ‘%s:%s:%s‘ % (key_prefix, version, key)

# 配置：
CACHES = {
    ‘default‘: {
        ‘BACKEND‘: ‘django.core.cache.backends.locmem.LocMemCache‘,     #配置内存引擎
        ‘LOCATION‘: ‘unique-snowflake‘,                                 #配置内存缓存名称

        ‘TIMEOUT‘: 300,                     # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）如果使用中没设置，这里启用
        ‘OPTIONS‘: {
            ‘MAX_ENTRIES‘: 300,             # 最大缓存个数（默认300）
            ‘CULL_FREQUENCY‘: 3,            # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3，删除百分之3）
        },
        ‘KEY_PREFIX‘: ‘‘,                   # 缓存key的前缀（默认空）
        ‘VERSION‘: 1,                       # 缓存key的版本（默认1），设置后缓存key会是，KEY_PREFIX前缀加VERSION版本
        # ‘KEY_FUNCTION‘: default_key_func         # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
    }
}

3、文件配置

#缓存配置
# 自定义缓存key
def default_key_func(key, key_prefix, version):
    return ‘%s:%s:%s‘ % (key_prefix, version, key)

# 配置：
CACHES = {
    ‘default‘: {
        ‘BACKEND‘: ‘django.core.cache.backends.filebased.FileBasedCache‘,     #配置文件引擎
        ‘LOCATION‘: os.path.join(BASE_DIR,‘huancuen‘),                        #配置文件缓存路径,当前工程下的huancuen文件夹

        ‘TIMEOUT‘: 300,                     # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）如果使用中没设置，这里启用
        ‘OPTIONS‘: {
            ‘MAX_ENTRIES‘: 300,             # 最大缓存个数（默认300）
            ‘CULL_FREQUENCY‘: 3,            # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3，删除百分之3）
        },
        ‘KEY_PREFIX‘: ‘‘,                   # 缓存key的前缀（默认空）
        ‘VERSION‘: 1,                       # 缓存key的版本（默认1），设置后缓存key会是，KEY_PREFIX前缀加VERSION版本
        # ‘KEY_FUNCTION‘: default_key_func         # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
    }
}

4、数据库配置，这种方式不推荐，缓存本来就是解决数据库访问量，结果还是要访问数据库

# 配置：
CACHES = {
    ‘default‘: {
        ‘BACKEND‘: ‘django.core.cache.backends.db.DatabaseCache‘,     #配置数据库引擎
        ‘LOCATION‘: ‘my_cache_table‘,                                 #配置数据库表，注意：执行创建表命令 python manage.py createcachetable

        ‘TIMEOUT‘: 300,                     # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）如果使用中没设置，这里启用
        ‘OPTIONS‘: {
            ‘MAX_ENTRIES‘: 300,             # 最大缓存个数（默认300）
            ‘CULL_FREQUENCY‘: 3,            # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3，删除百分之3）
        },
        ‘KEY_PREFIX‘: ‘‘,                   # 缓存key的前缀（默认空）
        ‘VERSION‘: 1,                       # 缓存key的版本（默认1），设置后缓存key会是，KEY_PREFIX前缀加VERSION版本
        # ‘KEY_FUNCTION‘: default_key_func         # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
    }
}

5、Memcache缓存（python-memcached模块）配置

# 此缓存使用python-memcached模块连接memcache，3种连接方式

    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.MemcachedCache‘,  #连接引擎
            ‘LOCATION‘: ‘127.0.0.1:11211‘,　　　　　　　　　　　　　　　　　　　　　 #服务器IP和端口
        }
    }

    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.MemcachedCache‘,　　#连接引擎
            ‘LOCATION‘: ‘unix:/tmp/memcached.sock‘,　　　　　　　　　　　　　　　　　
        }
    }   

    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.MemcachedCache‘, #连接引擎
            ‘LOCATION‘: [　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#多服务器IP和端口
                ‘172.19.26.240:11211‘,
                ‘172.19.26.242:11211‘,
            ]
        }
    }#其他参数同上

6、Memcache缓存（pylibmc模块）配置

# 此缓存使用pylibmc模块连接memcache，3种连接方式

    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.PyLibMCCache‘,　　#连接引擎
            ‘LOCATION‘: ‘127.0.0.1:11211‘,　　　　　　　　　　　　　　　　　　　　　#ip端口
        }
    }

    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.PyLibMCCache‘,
            ‘LOCATION‘: ‘/tmp/memcached.sock‘,
        }
    }   

    CACHES = {
        ‘default‘: {
            ‘BACKEND‘: ‘django.core.cache.backends.memcached.PyLibMCCache‘,　　#连接引擎
            ‘LOCATION‘: [　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#多服务器ip端口
                ‘172.19.26.240:11211‘,
                ‘172.19.26.242:11211‘,
            ]
        }
    }#其他参数同上

缓存应用

注意：以上任意那种方式的缓存，在应用上都是一样的，应用首先要在全局配置缓存参数

1、全站应用缓存，不常用

使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存

Django提供了两个写好的中间件，用于全站缓存

MIDDLEWARE = [
        ‘django.middleware.cache.UpdateCacheMiddleware‘,  #当请求来的时候判断缓存是否存在，如果不存在写入缓存
        # 其他中间件...
        ‘django.middleware.cache.FetchFromCacheMiddleware‘, #如果缓存存在,在缓存里拿数据
    ]

全站缓存中间件注册

#中间件
MIDDLEWARE = [
    ‘django.middleware.cache.UpdateCacheMiddleware‘,
    # ‘app1.chajian.zhong_jian_jian.zhongjianjian‘,
    ‘django.middleware.security.SecurityMiddleware‘,
    ‘django.contrib.sessions.middleware.SessionMiddleware‘,
    ‘django.middleware.common.CommonMiddleware‘,
    # ‘django.middleware.csrf.CsrfViewMiddleware‘,   #
    ‘django.contrib.auth.middleware.AuthenticationMiddleware‘,
    ‘django.contrib.messages.middleware.MessageMiddleware‘,
    ‘django.middleware.clickjacking.XFrameOptionsMiddleware‘,
    ‘django.middleware.cache.FetchFromCacheMiddleware‘,
]

只要在中间件列表里注册了这两个缓存中间件，就自动缓存全站了

2、单独视图缓存

就是在逻辑处理函数上用上缓存装饰器，这样被用上缓存装饰器的逻辑处理的页面将自动缓存，要去掉全局的缓存中间件

导入缓存装饰器模块 from django.views.decorators.cache import cache_page

@cache_page(60)缓存装饰器，用在要缓存的逻辑处理函数上，参数是缓存时间秒

from django.shortcuts import render,redirect
import time

from django.views.decorators.cache import cache_page #导入缓存装饰器

#逻辑处理模块
@cache_page(5)  #运用缓存装饰器，缓存保存时间5秒
def special(request):
    t = time.time()
    return render(request, ‘app1/index.html‘,locals())

3、局部模板使用缓存

就是在html模板里应用，指定一个页面的某一个区块缓存

{% load cache %}#在模板页面导入局部缓存模块

{% cache 缓存时间 自定义缓存名称 %}
　　需要缓存的区块
{% endcache %}

{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" type="text/css" href="/static/css/tou.css">
</head>
<body>

{% cache 5 suij %}
   {{ t }}
{% endcache %}

</body>
</html>

将缓存保存在Redis

首先安装Redis缓存软件

然后安装Django中使用Redis缓存的第三方模块 django-redis

配置

#缓存配置
# 自定义缓存key
def default_key_func(key, key_prefix, version):
    return ‘%s:%s:%s‘ % (key_prefix, version, key)

# 配置：
CACHES = {
    ‘default‘: {
        ‘BACKEND‘: "django_redis.cache.RedisCache",     #配置文件引擎
        ‘LOCATION‘: "redis://127.0.0.1:6379",                        #配置文件缓存路径

        ‘TIMEOUT‘: 300,                     # 缓存超时时间（默认300秒，None表示永不过期，0表示立即过期）如果使用中没设置，这里启用
        ‘OPTIONS‘: {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            ‘MAX_ENTRIES‘: 300,             # 最大缓存个数（默认300）
            ‘CULL_FREQUENCY‘: 3,            # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3，删除百分之3）
        },
        ‘KEY_PREFIX‘: ‘jxiou‘,                   # 缓存key的前缀（默认空）
        ‘VERSION‘: 1,                       # 缓存key的版本（默认1），设置后缓存key会是，KEY_PREFIX前缀加VERSION版本
        # ‘KEY_FUNCTION‘: default_key_func         # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
    }
}

配置默认连接池

配置默认连接池很简单, 你只需要在 CACHES 中使用 CONNECTION_POOL_KWARGS 设置连接池的最大连接数量即可:

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        ...
        "OPTIONS": {
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
        }
    }
}

更多教程   http://django-redis-chs.readthedocs.io/zh_CN/latest/#id12

使用同上

原文地址：https://www.cnblogs.com/meng-wei-zhi/p/8183138.html

时间： 2024-10-01 23:30:29

十五 Django框架，缓存的相关文章

python学习笔记十五 django基础

Python的WEB框架有Django.Tornado.Flask 等多种,Django相较与其他WEB框架其优势为:大而全,框架本身集成了ORM.模型绑定.模板引擎.缓存.Session等诸多功能. 1.创建django程序 通过命令行 django-admin startproject mysite 创建project 一个工程可以包含多个app,app共用一个project的配置文件 cd mysite python manage.py startapp app01 创建app01 pyt

python学习笔记十五 web框架

python Web程序 众所周知,对于所有的Web应用,本质上其实就是一个socket服务端,用户的浏览器其实就是一个socket客户端. Python的WEB框架分为两类: 自己写socket,自己处理请求 基于wsgi(Web Server Gateway Interface WEB服务网关接口,实现socket功能),自己处理请求 如图示: 自己写的web框架 #!/usr/bin/env python #coding:utf-8 import socket def handle_req

十六 Django框架，信号

Django中提供了"信号调度",用于在框架执行操作时解耦.通俗来讲,就是一些动作发生的时候,信号允许特定的发送者去提醒一些接受者. 也就是当程序有指定动作时,触发一个信号函数 1.Django内置信号 Model signals #数据库操作时 pre_init # django的modal执行其构造方法前,自动触发 post_init # django的modal执行其构造方法后,自动触发 pre_save # django的modal对象保存前,自动触发 post_save #

redis数据库如何用Django框架缓存数据

---恢复内容开始--- 一.python 使用redis 1.1 安装 pip install redis 测试有一些基本的数据类型 import redis # redis 是一个缓存数据库 # r = redis.Redis(host='127.0.0.1', port=6379) # 一般采用host与redis 可以不用配置, 用db来选择操作的数据库 # 如: r = redis.Redis(db=11) # r.set() 设置值 操作字符串 r.set('name','coco'

Python之路【第十五篇】：Web框架

Python之路[第十五篇]:Web框架 Web框架本质 众所周知,对于所有的Web应用,本质上其实就是一个socket服务端,用户的浏览器其实就是一个socket客户端. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #!/usr/bin/env python #coding:utf-8   import socket   def handle_request(client):     buf = client.recv(10

Python进阶(三十六)-Web框架Django项目搭建全过程

Python进阶(三十六)-Web框架Django项目搭建全过程 ??IDE说明: Win7系统 Python:3.5 Django:1.10 Pymysql:0.7.10 Mysql:5.5 ??Django 是由 Python 开发的一个免费的开源网站框架,可以用于快速搭建高性能,优雅的网站! Django 特点 强大的数据库功能 用python的类继承,几行代码就可以拥有一个丰富,动态的数据库操作接口(API),如果需要你也能执行SQL语句. 自带的强大的后台功能 几行简单的代码就让你的网

第三百一十六节，Django框架，中间件

第三百一十六节,Django框架,中间件 django 中的中间件(middleware),在django中,中间件其实就是一个类,在请求到来和结束后,django会根据自己的规则在合适的时机执行中间件中相应的方法. 在django项目的settings模块中,有一个 MIDDLEWARE变量,其中每一个元素就是一个中间件(也就是一个中间件模块的一个类),如下. settings模块中 #中间件 MIDDLEWARE = [ 'django.middleware.security.Securit

hbase 学习（十五）缓存机制以及可以利用SSD作为存储的BucketCache

下面介绍Hbase的缓存机制: a.HBase在读取时,会以Block为单位进行cache,用来提升读的性能 b.Block可以分类为DataBlock(默认大小64K,存储KV).BloomBlock(默认大小128K,存储BloomFilter数据).IndexBlock(默认大小128K,索引数据,用来加快Rowkey所在DataBlock的定位) c.对于一次随机读,Block的访问顺序为BloomBlock.IndexBlock.DataBlock,如果Region下面的StoreFi

第三百七十五节，Django+Xadmin打造上线标准的在线教育平台—创建课程机构app，在models.py文件生成3张表，城市表、课程机构表、讲师表

第三百七十五节,Django+Xadmin打造上线标准的在线教育平台-创建课程机构app,在models.py文件生成3张表,城市表.课程机构表.讲师表 创建名称为app_organization的课程机构APP,写数据库操作文件models.py models.py文件 #!/usr/bin/env python # -*- coding:utf-8 -*- from __future__ import unicode_literals from datetime import datetim