Django 的緩存功能基本上是在某處創建一個頁面後保存，然後在下次訪問該頁面時返回它。

一般情況下每一個Web請求都回經過這樣一個過程：接收請求 -> url路由 -> 視圖處理 -> 資料庫讀寫 -> 視圖處理 -> 模版渲染 -> 返回請求。

如果出現大量重複的請求會頻發的增加伺服器的負擔，因此需要緩存把結果保存下來，降低伺服器負擔，減少工作頻率。

Caches 使用

緩存是被保存在資料庫中，還可以使用文件和 memcached 的機製作為其他保存方式。

settings.py 設置緩存

BACKEND 部分顯示緩存保存目的地的類型，db.DatabaseCashe 是一個資料庫。
LOCATION 部分是要存儲緩存的表的名稱。可以隨意命名，但不應與現有表的名稱重疊。

CACHES = {
    'default': {
        'BACKEND': 'Django.core.cache.backends.db.DatabaseCache',
        'LOCATION': 'cache_table',
    }
}

settings.py 緩存整個項目

直接在項目中 middleware 中設置即可。

MIDDLEWARE = [
    ......
    'django.middleware.cache.UpdateCacheMiddleware',  
    'django.middleware.common.CommonMiddleware',  
    'django.middleware.cache.FetchFromCacheMiddleware',  
    ......
]

創建緩存表

通過在終端中執行以下命令來創建 cache_table 緩存表。並且不需要使用 python manage.py makemigrations 進行表單遷移。

python manage.py createcachetable

緩存表的定義

通過 sqlite 進行緩存表的查看。

python manage.py dbshell

sqlite>.schema cache_table

緩存創建表的 SQL 命令。

CREATE TABLE IF NOT EXISTS "cache_table" (
    "cache_key" varchar(255) NOT NULL PRIMARY KEY,
    "value" text NOT NULL,
    "expires" datetime NOT NULL
);
CREATE INDEX "cache_table_expires" ON "cache_table" ("expires");

Url 設置緩存

在 urls.py 中指定要緩存的內容。緩存時間為 60 * 15 即 15個60秒即15分鐘。

from django.urls import path
from django.views.decorators.cache import cache_page 
from . import views


urlpatterns = [
    path('', cache_page(60 * 15)(views.ArticleListView.as_view()), name='article_list'),
    # ......
]

Templates 設置緩存

{% load cache %}
{% cache 600 content %}
    <h1>設置緩存</h1>
    這裡是緩存的信息
{% endcache %}

刪除緩存

清除一次緩存可以使用 cache.clear() 。

from django.core.cache import cache
cache.clear()

from django.core.cache import cache;cache.clear()

緩存裝飾器

緩存可以通過使用裝飾器 never_cache 。

from django.contrib.auth.mixins import LoginRequiredMixin
from django.utils.decorators import method_decorator
from django.views.decorators.cache import never_cache
from django.views import generic
from .models import Post


class Index(LoginRequiredMixin, generic.ListView):
    ......
    @method_decorator(never_cache)
    def dispatch(self, request, *args, **kwargs):
        return super().dispatch(request, *args, **kwargs)

Caches 參數說明

BACKEND

選項後端緩存選項，根據不同的內容進行選擇性填寫，對應指定路徑。

'django.core.cache.backends.db.DatabaseCache' # 資料庫緩存
'django.core.cache.backends.dummy.DummyCache' # 開發調試緩存
'django.core.cache.backends.filebased.FileBasedCache' # 文件緩存
'django.core.cache.backends.locmem.LocMemcache' # 內存緩存
'django.core.cache.backends.memcached.MemcachedCache' # Memcache緩存（python-memcached模塊）
'django.core.cache.backends.memcached.PyLibMCCache' # Memcache緩存（pylibmc模塊）
"django_redis.cache.RedisCache" # Redis緩存

KEY_Function

設置一個字符串，其中包含一個函數的點路徑，該函數定義了如何將前綴，版本和密鑰組合成最終緩存密鑰。

def make_key(key, key_prefix, version):
    return ':'.join([key_prefix, str(version), key])

KEY_PREFIX

一個字符串將自動包含（默認為前置）到 Django 伺服器使用的所有緩存鍵中。

KEY_PREFIX:' '

LOCATION

使用的緩存位置，可能是文件系統緩存的目錄，內存緩存伺服器的主機和埠，或者是本地內存緩存的標識名。

LOCATION:' '

OPTIONS

額外的參數傳遞給緩存後端，可用參數因緩存後端而異。

OPTIONS:None

TIMEOUT

緩存條目被視為過時之前的秒數，如果此設置的值為None，則緩存條目將不會過期。

TIMEOUT:300

VERSION

Django 伺服器生成的緩存鍵的默認版本號。

VERSION:1

CACHE_MIDDLEWARE_ALIAS

用於緩存中間件的緩存連接。

CACHE_MIDDLEWARE_ALIAS:'default'

CACHE_MIDDLEWARE_KEY_PREFIX

一個字符串，該字符串將作為由緩存中間件生成的緩存鍵的前綴，該前綴與KEY_PREFIX設置結合在一起。

CACHE_MIDDLEWARE_KEY_PREFIX:' '

CACHE_MIDDLEWARE_SECONDS

緩存中間件頁面的默認秒數。

CACHE_MIDDLEWARE_SECONDS:' '

在這裡插入圖片描述

緩存示例

開發調試緩存

# 此為開始調試用，實際內部不做任何操作
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

資料庫緩存

# 此緩存將內容保存至資料庫
 CACHES = {
     'default': {
         'BACKEND': 'django.core.cache.backends.db.DatabaseCache', # 引擎
         'LOCATION': 'my_cache_table', # 需要緩存的資料庫表
     }
 }
 # 註：其他配置同開發調試版本
 # 執行創建表命令  python manage.py createcachetable

文件緩存

# 此緩存將內容保存至文件
 CACHES = {
     'default': {
         'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
         'LOCATION': '/tmp/django_cache' # 文件位置,
     }
 }
# 註：其他配置同開發調試版本

內存緩存

# 此緩存將內容保存至內存的變量中
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'unique-snowflake',
    }
}

# 註：其他配置同開發調試版本

Memcache緩存（python-memcached模塊）

# 此緩存使用python-memcached模塊連接memcache
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '設置的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:設置的埠號',  
            '設置的IP:設置的埠號',  
        ]
    }
}

Memcache緩存（pylibmc模塊）

# 此緩存使用pylibmc模塊連接memcache
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
        'LOCATION': '設置的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:設置的埠號',  
            '設置的IP:設置的埠號',  
        ]
    }
}

redis緩存

# 需要 pip3 install django-redis
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://設置的IP:設置的埠號",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 100}
            # "PASSWORD": "密碼",
        }
    }
}

from django_redis import get_redis_connection  # 視圖中連接並操作
conn = get_redis_connection("default")

項目應用

全部項目緩存

# 使用中間件，經過一系列的認證等操作
# 如果內容在緩存中存在，則使用FetchFromCacheMiddleware獲取內容並返回給用戶
# 當返回給用戶之前，判斷緩存中是否已經存在
# 如果不存在則UpdateCacheMiddleware會將緩存保存至緩存，從而實現全站緩存

MIDDLEWARE = [
    'django.middleware.cache.UpdateCacheMiddleware',
    # 其他中間件...
    'django.middleware.cache.FetchFromCacheMiddleware',
]
CACHE_MIDDLEWARE_ALIAS = ""
CACHE_MIDDLEWARE_SECONDS = ""
CACHE_MIDDLEWARE_KEY_PREFIX = ""

單獨視圖緩存

# 方式一
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)),
]


# 方式三
from django.views.decorators.cache import cache_page
@cache_page(10)   #緩存10秒
def cache(request):
    import time
    time=time.time()
    return render(request,'cache.html',{'time':time,})

前端模板，引入 TemplateTag。

{% load cache %}

# 前端模板，使用緩存
{% cache 5000 緩存key %}
    緩存內容
{% endcache %}

Django 4.x Caches 緩存使用示例和配置方法