Django之缓存六种方式及实战示例（其他篇六）

其他 2019-02-08 00:00:51 阅读次数: 0
版权声明：本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。本文为博主原创文章，转载请附上博文链接！ https://blog.csdn.net/Burgess_zheng/article/details/86747072

上一篇：Django之session详解与实战示例（其他篇五）点击跳转
目录篇：Django之其他目录篇 点击跳转
下一篇：Django之自定制中间件及实战示例（其他篇七）点击跳转

目录

缓存简单介绍

就是提高用户访问的速度，如购物网站：静态的一般采用缓存机制（如宝贝描述，商品的详细），动态的不用缓存机制（如购买数量，点赞数量）

1.配置

    a、开发调试

 # 此为开始调试用，实际内部不做任何操作
    # 配置：
        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）
                },
                'KEY_PREFIX': '',                                             # 缓存key的前缀（默认空）
                'VERSION': 1,                                                 # 缓存key的版本（默认1）
                'KEY_FUNCTION' 函数名                                          # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
            }
        }

# 自定义key
    def default_key_func(key, key_prefix, version):
        """
        Default function to generate keys.

        Constructs the key used by all other methods. By default it prepends
        the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
        function with custom key making behavior.
        """
        return '%s:%s:%s' % (key_prefix, version, key)

    def get_key_func(key_func):
        """
        Function to decide which key function to use.

        Defaults to ``default_key_func``.
        """
        if key_func is not None:
            if callable(key_func):
                return key_func
            else:
                return import_string(key_func)
        return default_key_func

    b、内存

# 此缓存将内容保存至内存的变量中
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                'LOCATION': 'unique-snowflake',  
#内容放入内存，在本地帮你创建一个全局变量，该变量名必须是唯一的，这个全局变量其实维护的就是一个字典 （unique-snowflake该变量名随便你更改只要唯一即可）
            }
        }

    # 注：其他配置同开发调试版本

    c、文件

# 此缓存将内容保存至文件
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
                'LOCATION': '/var/tmp/django_cache',
#缓存存放的文件路径
            }
        }
    # 注：其他配置同开发调试版本

    d、数据库

 # 此缓存将内容保存至数据库
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
                'LOCATION': 'my_cache_table', 
#在数据库，就必须创建一张表放缓存，所以my_cache_table是缓存的表名（可更改）
            }
        }
# 注：执行创建表命令 python manage.py createcachetable，然后数据库就会生成放缓存的表

    e、Memcache缓存（python-memcached模块）

# 此缓存使用python-memcached模块连接memcache
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': '127.0.0.1:11211', 
#连接memcache服务器的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': [
                '172.19.26.240:11211',
                '172.19.26.242:11211',
#连接到memcache服务器集群（memcache简单的分布式）
#这种简单的分布式原理：key的字符串转换成一个数字然后除以集群服务器的数量（如上是连接两个服务器就是2个），余数要么是0要么是1，如果是0就放在0元素（第1台服务器）的服务器上，如果是1就放在元素2（第2台服务器）的服务器上
            ]
        }
}

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': [
                ('172.19.26.240:11211',1),
                ('172.19.26.242:11211',15)
#连接到memcache服务器集群（memcache简单的分布式并赋予权重）
#这种简单的权重分布式原理：内容其实就是一个for循环，权重1等于在该for循环出现1次，权重15就等于在该for循环里面出现15次。同理：key的字符串转换成一个数字然后除以所有集群服务器的权重相加（如上两条服务器相加是16权重），余数，除以16那么余数等于0的概率就很小了，存放的概率自然就小了，自然权重15的概率多，那么存放概率自然多
            ]
        }
}

    f、Memcache缓存（pylibmc模块）

# 此缓存使用pylibmc模块连接memcache
    
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': '127.0.0.1:11211',
#连接memcache服务器的IP和端口

        }
    }

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': '/tmp/memcached.sock',
#连接文件的形式
        }
    }   

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': [
                '172.19.26.240:11211',
                '172.19.26.242:11211',
#连接到memcache服务器集群（memcache简单的分布式）
#这种简单的分布式原理：key的字符串转换成一个数字然后除以集群服务器的数量（如上是连接两个服务器就是2个），余数要么是0要么是1，如果是0就放在0元素（第1台服务器）的服务器上，如果是1就放在元素2（第2台服务器）的服务器上
            ]
        }
}

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': [
                ('172.19.26.240:11211',1),
                ('172.19.26.242:11211',15)
#连接到memcache服务器集群（memcache简单的分布式并赋予权重）
#这种简单的权重分布式原理：内容其实就是一个for循环，权重1等于在该for循环出现1次，权重15就等于在该for循环里面出现15次。同理：key的字符串转换成一个数字然后除以所有集群服务器的权重相加（如上两条服务器相加是16权重），余数，除以16那么余数等于0的概率就很小了，存放的概率自然就小了，自然权重15的概率多，那么存放概率自然多
            ]
        }
    }

2.应用

    a. 全站使用

 

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

MIDDLEWARE = [
        'django.middleware.cache.UpdateCacheMiddleware',
        # 其他中间件...
        'django.middleware.cache.FetchFromCacheMiddleware',
    ]

CACHE_MIDDLEWARE_ALIAS = ""
CACHE_MIDDLEWARE_SECONDS = ""
CACHE_MIDDLEWARE_KEY_PREFIX = ""

    b. 单独视图缓存

    #方式一：
        from django.views.decorators.cache import cache_page

        @cache_page(60 * 15)
        def my_view(request):
            ...

   # 方式二：
        from django.views.decorators.cache import cache_page

        urlpatterns = [
            url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
        ]

    c、局部视图使用

    a. 引入TemplateTag

        {% load cache %}

    b. 使用缓存

        {% cache 5000 缓存key %}
            缓存内容
        {% endcache %}

实战示例

    1.创建Django项目

Django之创建项目【二】：https://blog.csdn.net/Burgess_zheng/article/details/86505526

    2.定义setting配置文件缓存路径（创建缓存文件存放目录）

路径:project_burgess/project_burgess/settings

    3.定义请求的URL路由分发

路径:project_burgess/project_burgess/urls.py

from django.contrib import admin
from django.urls import path,re_path #Django版本2.0以上
from project_burgess import views
from django.conf.urls import url  #Django2.0
from django.conf.urls import include

urlpatterns = [
    path('admin/', admin.site.urls),
    
    #cache
    path('cache/', views.cache),  # 最新版本的Django路由使用path
    # url(r'^cache/', views.cache), #2.0版本使用的是url

]

    4.定义url对应函数处理

路径:project_burgess/project_burgess/views.py

__author__ = "Burgess Zheng"
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from django.shortcuts import render,HttpResponse,redirect

def cache(request):
    import time
    ctime = time.time()
    return render(request,'cache.html',{'ctime':ctime})

    5.定义响应的html文件

路径:project_burgess/templates/cache.html

{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>{{ ctime }}</h1>
</body>
</html>

    6.启动Django

手动：python manage.py runserver 127.0.0.1:8000

pycharm:

    7.浏览器测试

get请求

刷新

时间变了（说明是实时获取）

django提供了3种缓存的应用
第一种：指定views函数进行缓存（常使用）
第二种：对模板的局部进行缓存（常使用）
第三种：对整个网站进行缓存（非常小的网站适用如：自己的博客）

 

试验第一种：指定views函数进行缓存（常使用）

路径:project_burgess/project_burgess/views.py

__author__ = "Burgess Zheng"
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from django.shortcuts import render,HttpResponse,redirect

from django.views.decorators.cache import cache_page #把函数进行缓存需要该模块
@cache_page(10) #表示10秒缓存失效 ，默认是300秒
def cache(request):
    import time
    ctime = time.time()
    return render(request,'cache.html',{'ctime':ctime})

get请求

刷新

不变说明调用了缓存（查看缓存文件）

10秒后

 

试验第二种：对模板的局部进行缓存（常使用）

函数的缓存装饰器注释掉：路径:project_burgess/project_burgess/views.py

__author__ = "Burgess Zheng"
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from django.shortcuts import render,HttpResponse,redirect

#from django.views.decorators.cache import cache_page #把函数进行缓存需要该模块
#@cache_page(10) #表示10秒缓存失效 ，默认是300秒
def cache(request):
    import time
    ctime = time.time()
    return render(request,'cache.html',{'ctime':ctime})

路径:project_burgess/templates/cache.html

{% load cache %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>{{ ctime }}</h1>
    <h1>{{ ctime }}</h1>
    {% cache 10 c1 %}
    <h1>{{ ctime }}</h1>
{#该标签的字符串进行缓存，10秒失效,key的前缀c1#}
    {% endcache %}
</body>
</html>

get请求

刷新

局部缓存的就没变化（调用缓存文件），其他两个变化了

10秒后

试验第三种： 第三种：对整个网站进行缓存（非常小的网站适用如：自己的博客）

在最临近views函数的中间件进行对所有请求进行缓存提取数据，如果没有就继续往下执行views函数
在最临近url的总监级进行对数据的判断，缓存是否有该数据，如果没有该数据就把数据镜像缓存，同时发送数据给用户

路径:project_burgess/project_burgess/settings

整个网站都进行了缓存

get请求

刷新

整个网站进行了缓存

上一篇：Django之session详解与实战示例（其他篇五）点击跳转
目录篇：Django之其他目录篇 点击跳转
下一篇：Django之自定制中间件及实战示例（其他篇七）点击跳转

猜你喜欢

转载自blog.csdn.net/Burgess_zheng/article/details/86747072
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022