Memcached¶

Memcached 是一種完全基於記憶體的快取伺服器，最初開發用於處理 LiveJournal.com 的高負載，隨後由 Danga Interactive 開源。Facebook 和 Wikipedia 等網站使用它來減少資料庫存取並顯著提高網站效能。

Memcached 作為守護進程執行，並分配了指定的 RAM 容量。它所做的只是為在快取中新增、檢索和刪除資料提供快速介面。所有資料都直接儲存在記憶體中，因此沒有資料庫或檔案系統使用的開銷。

在安裝 Memcached 本身之後，您需要安裝 Memcached 繫結。有幾個可用的 Python Memcached 繫結；Django 支援的兩個是 pylibmc 和 pymemcache。

若要將 Memcached 與 Django 搭配使用

• 將 BACKEND 設定為 django.core.cache.backends.memcached.PyMemcacheCache 或 django.core.cache.backends.memcached.PyLibMCCache（取決於您選擇的 memcached 繫結）

• 將 LOCATION 設定為 ip:port 值，其中 ip 是 Memcached 守護進程的 IP 位址，而 port 是 Memcached 正在執行的連接埠，或設定為 unix:path 值，其中 path 是 Memcached Unix socket 檔案的路徑。

在此範例中，Memcached 使用 pymemcache 繫結在 localhost (127.0.0.1) 連接埠 11211 上執行

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": "127.0.0.1:11211",
    }
}

在此範例中，Memcached 可透過使用 pymemcache 繫結的本機 Unix socket 檔案 /tmp/memcached.sock 取得

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": "unix:/tmp/memcached.sock",
    }
}

Memcached 的一個出色功能是它能夠在多個伺服器上共用快取。這表示您可以在多台機器上執行 Memcached 守護進程，並且該程式會將機器群組視為 單一 快取，而無需在每台機器上複製快取值。若要利用此功能，請在 LOCATION 中包含所有伺服器位址，無論是以分號或逗號分隔的字串，或是以清單形式。

在此範例中，快取會在 IP 位址為 172.19.26.240 和 172.19.26.242，且均在連接埠 11211 上執行的 Memcached 執行個體之間共用

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": [
            "172.19.26.240:11211",
            "172.19.26.242:11211",
        ],
    }
}

在下列範例中，快取會在 IP 位址為 172.19.26.240（連接埠 11211）、172.19.26.242（連接埠 11212）和 172.19.26.244（連接埠 11213）上執行的 Memcached 執行個體之間共用

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": [
            "172.19.26.240:11211",
            "172.19.26.242:11212",
            "172.19.26.244:11213",
        ],
    }
}

依預設，PyMemcacheCache 後端設定下列選項（您可以在 OPTIONS 中覆寫它們）

"OPTIONS": {
    "allow_unicode_keys": True,
    "default_noreply": False,
    "serde": pymemcache.serde.pickle_serde,
}

關於 Memcached 的最後一點是，基於記憶體的快取有一個缺點：由於快取的資料儲存在記憶體中，如果您的伺服器崩潰，資料將會遺失。顯然，記憶體並非用於永久資料儲存，因此請不要僅依賴基於記憶體的快取作為您唯一的資料儲存方式。毫無疑問，任何 Django 快取後端都不應被用於永久儲存 - 它們都旨在成為快取解決方案，而不是儲存 - 但我們在這裡指出這一點是因為基於記憶體的快取是特別暫時的。

Redis¶

Redis 是一個可用於快取的記憶體內資料庫。首先，您需要在本機或遠端機器上執行 Redis 伺服器。

在設定 Redis 伺服器後，您需要安裝 Redis 的 Python 繫結。redis-py 是 Django 原生支援的繫結。也建議安裝 hiredis-py 套件。

若要將 Redis 與 Django 搭配使用作為快取後端

• 將 BACKEND 設定為 django.core.cache.backends.redis.RedisCache。

• 將 LOCATION 設定為指向您的 Redis 執行個體的 URL，使用適當的配置。如需可用配置的詳細資訊，請參閱 redis-py 文件。

例如，如果 Redis 在 localhost (127.0.0.1) 連接埠 6379 上執行

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
    }
}

通常，Redis 伺服器受到驗證保護。為了提供使用者名稱和密碼，請將它們與 URL 一起新增至 LOCATION

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://username:password@127.0.0.1:6379",
    }
}

如果您在複製模式中設定了多個 Redis 伺服器，您可以將伺服器指定為以分號或逗號分隔的字串，或是以清單形式。當使用多個伺服器時，寫入操作會在第一個伺服器（主節點）上執行。讀取操作會在隨機選擇的其他伺服器（複本節點）上執行

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": [
            "redis://127.0.0.1:6379",  # leader
            "redis://127.0.0.1:6378",  # read-replica 1
            "redis://127.0.0.1:6377",  # read-replica 2
        ],
    }
}

資料庫快取¶

Django 可以將其快取資料儲存在您的資料庫中。如果您擁有快速、索引良好的資料庫伺服器，效果最佳。

若要使用資料庫表作為您的快取後端

• 將 BACKEND 設定為 django.core.cache.backends.db.DatabaseCache

• 將 LOCATION 設定為 tablename，即資料庫表的名稱。此名稱可以是您想要的任何名稱，只要它是尚未在您的資料庫中使用的有效表名稱即可。

在此範例中，快取表的名稱為 my_cache_table

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.db.DatabaseCache",
        "LOCATION": "my_cache_table",
    }
}

與其他快取後端不同，資料庫快取不支援在資料庫層級自動刪除過期的條目。相反地，過期的快取條目會在每次呼叫 add()、set() 或 touch() 時刪除。

python manage.py createcachetable

class CacheRouter:
    """A router to control all database cache operations"""

    def db_for_read(self, model, **hints):
        "All cache read operations go to the replica"
        if model._meta.app_label == "django_cache":
            return "cache_replica"
        return None

    def db_for_write(self, model, **hints):
        "All cache write operations go to primary"
        if model._meta.app_label == "django_cache":
            return "cache_primary"
        return None

    def allow_migrate(self, db, app_label, model_name=None, **hints):
        "Only install the cache model on primary"
        if app_label == "django_cache":
            return db == "cache_primary"
        return None

檔案系統快取¶

基於檔案的後端會將每個快取值序列化並儲存為單獨的檔案。若要使用此後端，請將 BACKEND 設定為 "django.core.cache.backends.filebased.FileBasedCache"，並將 LOCATION 設定為合適的目錄。例如，若要將快取資料儲存在 /var/tmp/django_cache 中，請使用此設定

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "/var/tmp/django_cache",
    }
}

如果您使用的是 Windows，請將磁碟機代號放在路徑的開頭，如下所示

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "c:/foo/bar",
    }
}

目錄路徑應為絕對路徑，也就是說，它應該從檔案系統的根目錄開始。您是否在設定結尾加上斜線並不重要。

請確保此設定指向的目錄存在且可讀寫，或是可以由您的網頁伺服器執行的系統使用者建立。繼續上面的範例，如果您的伺服器以使用者 apache 的身分執行，請確保目錄 /var/tmp/django_cache 存在且可由使用者 apache 讀寫，或是可以由使用者 apache 建立。

本機記憶體快取¶

如果未在您的設定檔中指定另一個快取，這是預設的快取。如果您想要記憶體內快取的速度優勢，但沒有執行 Memcached 的能力，請考慮使用本機記憶體快取後端。此快取是按進程（請參閱下文）且具有執行緒安全性的。若要使用它，請將 BACKEND 設定為 "django.core.cache.backends.locmem.LocMemCache"。例如

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
        "LOCATION": "unique-snowflake",
    }
}

快取 LOCATION 用於識別個別的記憶體儲存區。如果您只有一個 locmem 快取，您可以省略 LOCATION；但是，如果您有多個本機記憶體快取，您將需要為其中至少一個快取指派名稱，以使其保持分開。

快取使用最近最少使用 (LRU) 刪除策略。

請注意，每個進程都會有自己的私有快取實例，這表示無法進行跨進程快取。這也表示本機記憶體快取並不是特別節省記憶體，因此它可能不是生產環境的良好選擇。它在開發上很不錯。

虛擬快取（用於開發）¶

最後，Django 隨附一個「虛擬」快取，它實際上不快取，它只是實作快取介面而不做任何事情。

如果您有一個在各個地方使用大量快取的生產網站，但有一個開發/測試環境，您不想快取，也不想必須更改程式碼以特殊處理後者，這會很有用。若要啟動虛擬快取，請將 BACKEND 設定如下

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.dummy.DummyCache",
    }
}

使用自訂快取後端¶

雖然 Django 包含對許多開箱即用的快取後端的支援，但有時您可能想要使用自訂的快取後端。若要將外部快取後端與 Django 搭配使用，請使用 Python 匯入路徑作為 BACKEND 的 CACHES 設定，如下所示

CACHES = {
    "default": {
        "BACKEND": "path.to.backend",
    }
}

如果您要建立自己的後端，您可以將標準快取後端作為參考實作。您會在 Django 原始碼的 django/core/cache/backends/ 目錄中找到程式碼。

注意：如果沒有真正令人信服的理由，例如主機不支援它們，您應該堅持使用 Django 隨附的快取後端。它們已經過充分測試且有完善的文件。

快取引數¶

可以為每個快取後端提供額外的引數，以控制快取行為。這些引數會以 CACHES 設定中的額外索引鍵提供。有效的引數如下

• TIMEOUT：用於快取的預設逾時時間（以秒為單位）。此引數預設為 300 秒（5 分鐘）。您可以將 TIMEOUT 設定為 None，以便預設情況下快取索引鍵永不過期。值 0 會導致索引鍵立即過期（實際上是「不快取」）。

• OPTIONS：應傳遞至快取後端的任何選項。有效選項的清單會因每個後端而異，且由第三方程式庫支援的快取後端會將其選項直接傳遞至底層快取程式庫。

  實作自己的刪除策略的快取後端（即 locmem、filesystem 和 database 後端）會遵循下列選項

  • MAX_ENTRIES：在刪除舊值之前，快取中允許的最大條目數。此引數預設為 300。

  • CULL_FREQUENCY：當達到 MAX_ENTRIES 時要刪除的條目比例。實際比例為 1 / CULL_FREQUENCY，因此將 CULL_FREQUENCY 設定為 2，表示當達到 MAX_ENTRIES 時刪除一半的條目。此引數應為整數，預設值為 3。

    當 CULL_FREQUENCY 的值為 0 時，表示當達到 MAX_ENTRIES 時將會清空整個快取。在某些後端（尤其是 database），這樣做會使刪除速度快得多，但代價是快取未命中率會更高。

  Memcached 和 Redis 後端會將 OPTIONS 的內容作為關鍵字引數傳遞給用戶端建構函式，以便對用戶端行為進行更進階的控制。如需範例用法，請參閱下文。

• KEY_PREFIX：一個字串，將會自動包含（預設為前置）在 Django 伺服器使用的所有快取鍵中。

  如需更多資訊，請參閱快取文件。

• VERSION：Django 伺服器產生的快取鍵的預設版本號碼。

  如需更多資訊，請參閱快取文件。

• KEY_FUNCTION：一個字串，包含一個點分隔的路徑，指向一個函式，該函式定義如何將前綴、版本和鍵組合成最終的快取鍵。

  如需更多資訊，請參閱快取文件。

在此範例中，檔案系統後端配置了 60 秒的逾時時間和 1000 個項目的最大容量

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "/var/tmp/django_cache",
        "TIMEOUT": 60,
        "OPTIONS": {"MAX_ENTRIES": 1000},
    }
}

以下是基於 pylibmc 的後端範例配置，該配置啟用二進位協定、SASL 驗證和 ketama 行為模式

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyLibMCCache",
        "LOCATION": "127.0.0.1:11211",
        "OPTIONS": {
            "binary": True,
            "username": "user",
            "password": "pass",
            "behaviors": {
                "ketama": True,
            },
        },
    }
}

以下是基於 pymemcache 的後端範例配置，該配置啟用用戶端池 (這可以透過保持用戶端連線來提高效能)、將 memcache/網路錯誤視為快取未命中，並在連線的 socket 上設定 TCP_NODELAY 標誌

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": "127.0.0.1:11211",
        "OPTIONS": {
            "no_delay": True,
            "ignore_exc": True,
            "max_pool_size": 4,
            "use_pooling": True,
        },
    }
}

以下是基於 redis 的後端範例配置，該配置選擇資料庫 10 (預設情況下 Redis 會提供 16 個邏輯資料庫)，並設定自訂的 連線池類別（預設情況下使用 redis.ConnectionPool）

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "db": "10",
            "pool_class": "redis.BlockingConnectionPool",
        },
    }
}

在 URLconf 中指定每個視圖的快取¶

前一節的範例硬式編碼了視圖已被快取的事實，因為 cache_page 會就地修改 my_view 函數。這種方法將你的視圖與快取系統耦合在一起，這在幾個方面來說並不理想。例如，你可能想在另一個沒有快取的網站上重複使用視圖函數，或者你可能想將視圖分發給可能想在沒有快取的情況下使用它們的人。這些問題的解決方案是在 URLconf 中指定每個視圖的快取，而不是在視圖函數本身旁邊指定。

你可以透過在 URLconf 中引用視圖函數時，使用 cache_page 包裝它來做到這一點。這是稍早的舊 URLconf：

urlpatterns = [
    path("foo/<int:code>/", my_view),
]

這是相同的內容，但 my_view 被包在 cache_page 中：

from django.views.decorators.cache import cache_page

urlpatterns = [
    path("foo/<int:code>/", cache_page(60 * 15)(my_view)),
]

存取快取¶

django.core.cache.caches¶

你可以透過類似字典的物件：django.core.cache.caches，存取在 CACHES 設定中設定的快取。在同一個執行緒中重複請求相同的別名，將會傳回相同的物件。

>>> from django.core.cache import caches
>>> cache1 = caches["myalias"]
>>> cache2 = caches["myalias"]
>>> cache1 is cache2
True

如果指定的鍵不存在，則會引發 InvalidCacheBackendError。

為了提供執行緒安全，每個執行緒都會傳回快取後端不同的執行個體。

django.core.cache.cache¶

作為捷徑，預設快取可以 django.core.cache.cache 取得。

>>> from django.core.cache import cache

這個物件等同於 caches['default']。

基本用法¶

基本介面是：

cache.set(key, value, timeout=DEFAULT_TIMEOUT, version=None)¶

>>> cache.set("my_key", "hello, world!", 30)

cache.get(key, default=None, version=None)¶

>>> cache.get("my_key")
'hello, world!'

key 應該是 str，而 value 可以是任何可 pickle 的 Python 物件。

timeout 引數是選用的，預設為 CACHES 設定中適當後端的 timeout 引數（如上所述）。這是該值應儲存在快取中的秒數。為 timeout 傳入 None 將會永遠快取該值。為 timeout 傳入 0 將不會快取該值。

如果物件不存在於快取中，cache.get() 會傳回 None。

>>> # Wait 30 seconds for 'my_key' to expire...
>>> cache.get("my_key")
None

如果你需要確定物件是否存在於快取中，並且你已經儲存了常值 None，請使用哨兵物件作為預設值：

>>> sentinel = object()
>>> cache.get("my_key", sentinel) is sentinel
False
>>> # Wait 30 seconds for 'my_key' to expire...
>>> cache.get("my_key", sentinel) is sentinel
True

cache.get() 可以接收 default 引數。如果物件不存在於快取中，這會指定要傳回哪個值：

>>> cache.get("my_key", "has expired")
'has expired'

cache.add(key, value, timeout=DEFAULT_TIMEOUT, version=None)¶

若要僅當某個鍵不存在時才新增它，請使用 add() 方法。它會接收與 set() 相同的參數，但如果指定的鍵已存在，它不會嘗試更新快取：

>>> cache.set("add_key", "Initial value")
>>> cache.add("add_key", "New value")
>>> cache.get("add_key")
'Initial value'

如果您需要知道 add() 是否將值儲存在快取中，您可以檢查其回傳值。如果該值已儲存，它會回傳 True，否則回傳 False。

cache.get_or_set(key, default, timeout=DEFAULT_TIMEOUT, version=None)¶

如果您想取得鍵的值，或是在快取中沒有該鍵時設定一個值，可以使用 get_or_set() 方法。它接受與 get() 相同的參數，但是預設值會設定為該鍵的新快取值，而不是回傳。

>>> cache.get("my_new_key")  # returns None
>>> cache.get_or_set("my_new_key", "my new value", 100)
'my new value'

您也可以傳遞任何可呼叫的物件作為預設值。

>>> import datetime
>>> cache.get_or_set("some-timestamp-key", datetime.datetime.now)
datetime.datetime(2014, 12, 11, 0, 15, 49, 457920)

cache.get_many(keys, version=None)¶

還有一個 get_many() 介面，它只會存取快取一次。get_many() 會回傳一個字典，其中包含您要求的所有實際存在於快取中（且尚未過期）的鍵。

>>> cache.set("a", 1)
>>> cache.set("b", 2)
>>> cache.set("c", 3)
>>> cache.get_many(["a", "b", "c"])
{'a': 1, 'b': 2, 'c': 3}

cache.set_many(dict, timeout)¶

若要更有效率地設定多個值，請使用 set_many() 傳遞鍵值對的字典。

>>> cache.set_many({"a": 1, "b": 2, "c": 3})
>>> cache.get_many(["a", "b", "c"])
{'a': 1, 'b': 2, 'c': 3}

與 cache.set() 類似，set_many() 接受可選的 timeout 參數。

在支援的後端（memcached）上，set_many() 會回傳一個無法插入的鍵列表。

cache.delete(key, version=None)¶

您可以使用 delete() 明確刪除鍵，以清除特定物件的快取。

>>> cache.delete("a")
True

如果成功刪除鍵，delete() 會回傳 True，否則回傳 False。

cache.delete_many(keys, version=None)¶

如果您想一次清除多個鍵，delete_many() 可以接受要清除的鍵列表。

>>> cache.delete_many(["a", "b", "c"])

cache.clear()¶

最後，如果您想刪除快取中的所有鍵，請使用 cache.clear()。請謹慎使用此方法；clear() 會從快取中移除所有內容，而不僅僅是您的應用程式設定的鍵。

>>> cache.clear()

cache.touch(key, timeout=DEFAULT_TIMEOUT, version=None)¶

cache.touch() 會為鍵設定新的到期時間。例如，若要將鍵更新為從現在起 10 秒後到期：

>>> cache.touch("a", 10)
True

與其他方法一樣，timeout 參數是可選的，預設為 CACHES 設定中適當後端的 TIMEOUT 選項。

如果成功觸摸鍵，touch() 會回傳 True，否則回傳 False。

cache.incr(key, delta=1, version=None)¶

cache.decr(key, delta=1, version=None)¶

您也可以分別使用 incr() 或 decr() 方法，遞增或遞減已存在的鍵。預設情況下，現有的快取值會遞增或遞減 1。您可以透過在遞增/遞減呼叫中提供參數來指定其他遞增/遞減值。如果您嘗試遞增或遞減不存在的快取鍵，則會引發 ValueError。

>>> cache.set("num", 1)
>>> cache.incr("num")
2
>>> cache.incr("num", 10)
12
>>> cache.decr("num")
11
>>> cache.decr("num", 5)
6

cache.close()¶

如果快取後端實作了 close()，您可以使用 close() 關閉與快取的連線。

>>> cache.close()

快取鍵前綴¶

如果您在伺服器之間，或在您的生產和開發環境之間共享快取實例，則有可能一個伺服器快取的資料被另一個伺服器使用。如果伺服器之間快取資料的格式不同，則可能導致一些很難診斷的問題。

為了防止這種情況，Django 提供了為伺服器使用的所有快取鍵加上前綴的功能。當儲存或擷取特定快取鍵時，Django 會自動使用 KEY_PREFIX 快取設定的值為快取鍵加上前綴。

透過確保每個 Django 實例都有不同的 KEY_PREFIX，您可以確保快取值中不會發生衝突。

快取版本控制¶

當您變更使用快取值的執行程式碼時，您可能需要清除任何現有的快取值。最簡單的方法是刷新整個快取，但這可能會導致遺失仍然有效且有用的快取值。

Django 提供了一種更好的方法來鎖定個別快取值。Django 的快取框架有一個系統範圍的版本識別碼，使用 VERSION 快取設定指定。此設定的值會自動與快取前綴和使用者提供的快取鍵組合，以取得最終快取鍵。

預設情況下，任何鍵請求都會自動包含站點預設快取鍵版本。但是，原始快取函數都包含 version 參數，因此您可以指定要設定或取得的特定快取鍵版本。例如：

>>> # Set version 2 of a cache key
>>> cache.set("my_key", "hello world!", version=2)
>>> # Get the default version (assuming version=1)
>>> cache.get("my_key")
None
>>> # Get version 2 of the same key
>>> cache.get("my_key", version=2)
'hello world!'

可以使用 incr_version() 和 decr_version() 方法來遞增和遞減特定鍵的版本。這使得可以將特定鍵升級到新版本，而不會影響其他鍵。繼續前面的例子：

>>> # Increment the version of 'my_key'
>>> cache.incr_version("my_key")
>>> # The default version still isn't available
>>> cache.get("my_key")
None
# Version 2 isn't available, either
>>> cache.get("my_key", version=2)
None
>>> # But version 3 *is* available
>>> cache.get("my_key", version=3)
'hello world!'

快取鍵轉換¶

如前兩節所述，使用者提供的快取鍵不會被逐字使用 – 它會與快取前綴和鍵版本組合，以提供最終快取鍵。預設情況下，這三個部分會使用冒號連接以產生最終字串。

def make_key(key, key_prefix, version):
    return "%s:%s:%s" % (key_prefix, version, key)

如果您想以不同的方式組合這些部分，或對最終鍵應用其他處理（例如，取得鍵部分的雜湊摘要），則可以提供自訂鍵函數。

KEY_FUNCTION 快取設定指定一個符合上述 make_key() 原型的函數的點式路徑。如果提供，此自訂鍵函數將會取代預設的鍵組合函數。

快取鍵警告¶

Memcached 是最常用的生產快取後端，不允許快取鍵超過 250 個字元或包含空白字元或控制字元，使用此類鍵會導致例外。為了鼓勵可移植的快取程式碼並盡量減少令人不快的意外，如果使用的鍵會在 memcached 上造成錯誤，其他內建快取後端會發出警告 (django.core.cache.backends.base.CacheKeyWarning)。

如果您使用的是可以接受更廣泛鍵值的生產環境後端（自訂後端，或非快取記憶體內建後端之一），並且希望在不出現警告的情況下使用此更廣泛的範圍，您可以使用以下程式碼在您的其中一個 INSTALLED_APPS 的 management 模組中關閉 CacheKeyWarning

import warnings

from django.core.cache import CacheKeyWarning

warnings.simplefilter("ignore", CacheKeyWarning)

如果您想要為其中一個內建後端提供自訂的鍵值驗證邏輯，您可以繼承它，僅覆寫 validate_key 方法，並遵循使用自訂快取後端的說明。例如，若要對 locmem 後端執行此操作，請將此程式碼放在模組中

from django.core.cache.backends.locmem import LocMemCache


class CustomLocMemCache(LocMemCache):
    def validate_key(self, key):
        """Custom validation, raising exceptions or warnings as needed."""
        ...

…並在您的 CACHES 設定的 BACKEND 部分中使用此類別的虛線 Python 路徑。