Django4.0 緩存框架-設(shè)置緩存

緩存系統(tǒng)需要少量的設(shè)置。也就是說，你必須告訴它你的緩存數(shù)據(jù)應(yīng)該放在哪里 —— 是在數(shù)據(jù)庫中，還是在文件系統(tǒng)上，或者直接放在內(nèi)存中。這是一個重要的決定，會影響你的緩存的性能；是的，有些緩存類型比其他類型快。

緩存設(shè)置項位于你的配置文件的緩存配置中。這里有緩存配置所有可用值的說明。

?Memcached ?是一個完全基于內(nèi)存的緩存服務(wù)器，最初開發(fā)用于處理 LiveJournal.com 的高負載，隨后由 Danga Interactive 開源。 Facebook 和 Wikipedia 等網(wǎng)站使用它來減少數(shù)據(jù)庫訪問并顯著提高網(wǎng)站性能。

?Memcached ?以一個守護進程的形式運行，并且被分配了指定數(shù)量的 RAM。它所做的就是提供一個快速接口用于在緩存中添加，檢索和刪除數(shù)據(jù)。所有數(shù)據(jù)都直接存儲在內(nèi)存中，因此不會產(chǎn)生數(shù)據(jù)庫或文件系統(tǒng)使用的開銷。

在安裝了 ?Memcached ?本身之后，你需要安裝一個 ?Memcached ?綁定。有幾個 Python ?Memcached ?綁定可用；Django 支持的兩個綁定是 ?pylibmc ?和 ?pymemcache ?。

在 Django 中使用 ?Memcached ?：

設(shè)置 ?BACKEND ?為 ?django.core.cache.backends.memcached.PyMemcacheCache? 或 ?django.core.cache.backends.memcached.PyLibMCCache? （取決于你選擇的 ?memcached ?綁定）。
將 ?LOCATION ?設(shè)置為 ?ip:port? 值，其中 ?ip ?是 ?Memcached ?守護進程的 ?IP ?地址，?port ?是 ?Memcached ?運行的端口，或者設(shè)置為 ?unix:path? 值，其中 ?path ?是 ?Memcached Unix socket? 文件的路徑。

在這個例子中，?Memcached ?運行在 localhost（127.0.0.1）端口 11211，使用 ?pymemcache ?綁定：

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

在這個例子中，?Memcached ?可以通過本地 ?Unix ?套接字文件 ?/tmp/memcached.sock? 使用 ?pymemcache ?綁定：

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

?Memcached ?有一個很好的特性，就是它可以在多臺服務(wù)器上共享一個緩存。這意味著你可以在多臺機器上運行 ?Memcached ?守護進程，程序?qū)堰@組機器作為一個 單一 的緩存，而不需要在每臺機器上重復(fù)緩存值。要利用這個特性，請在 ?LOCATION ?中包含所有服務(wù)器地址，可以是分號或逗號分隔的字符串，也可以是一個列表。
在這個例子中，緩存是通過運行在 IP 地址 172.19.26.240 和 172.19.26.242 上的 ?Memcached ?實例共享的，這兩個實例都在 11211 端口上：

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',
        ]
    }
}

關(guān)于 ?Memcached ?的最后一點是，基于內(nèi)存的緩存有一個缺點：因為緩存的數(shù)據(jù)存儲在內(nèi)存中，如果你的服務(wù)器崩潰，數(shù)據(jù)將丟失。顯然，內(nèi)存并不是用來永久存儲數(shù)據(jù)的，所以不要依賴基于內(nèi)存的緩存作為你唯一的數(shù)據(jù)存儲。毫無疑問，Django 緩存后端中的 每個 都不應(yīng)該用于永久存儲 —— 它們的目的都是為了緩存的解決方案，而不是存儲 —— 但我們在這里指出這一點是因為基于內(nèi)存的緩存是格外臨時的。

Redis

Redis 是一個可用于緩存的內(nèi)存數(shù)據(jù)庫。 首先，您需要一個在本地或遠程機器上運行的 Redis 服務(wù)器。

設(shè)置 Redis 服務(wù)器后，您需要為 Redis 安裝 Python 綁定。 redis-py 是 Django 原生支持的綁定。 還建議安裝額外的hiredis-py 包。

使用 Redis 作為 Django 的緩存后端：

• 將 ?BACKEND ?設(shè)置為 ?django.core.cache.backends.redis.RedisCache?
• 使用適當?shù)姆桨笇?nbsp;?LOCATION ?設(shè)置為指向您的 Redis 實例的 URL。

例如，如果 Redis 在 localhost (127.0.0.1) 端口 6379 上運行：

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

Redis 服務(wù)器通常受到身份驗證的保護。 為了提供用戶名和密碼，請將它們與 URL 一起添加到 ?LOCATION?：

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

如果您在復(fù)制模式下設(shè)置了多個 Redis 服務(wù)器，則可以將服務(wù)器指定為分號或逗號分隔的字符串，或者作為列表。 使用多臺服務(wù)器時，寫入操作在第一臺服務(wù)器（領(lǐng)導(dǎo)者）上執(zhí)行。 讀取操作在隨機選擇的其他服務(wù)器（副本）上執(zhí)行：

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
        ],
    }
}

數(shù)據(jù)庫緩存

Django 可以在數(shù)據(jù)庫中存儲緩存數(shù)據(jù)。如果你有一個快速、索引正常的數(shù)據(jù)庫服務(wù)器，這種緩存效果最好。
用數(shù)據(jù)庫表作為你的緩存后端：

• 將 ?BACKEND ?設(shè)置為 ?django.core.cache.backends.db.DatabaseCache?
• 將 ?LOCATION ?設(shè)置為數(shù)據(jù)庫表的 ?tablename?。這個表名可以是沒有使用過的任何符合要求的名稱。

在這個例子中，緩存表的名稱是 ?my_cache_table ?：

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

與其他緩存后端不同，數(shù)據(jù)庫緩存不支持在數(shù)據(jù)庫級別自動剔除過期條目。 相反，每次調(diào)用 ?add()?、?set()? 或 ?touch()? 時都會剔除過期的緩存條目。

創(chuàng)建緩存表

使用數(shù)據(jù)庫緩存之前，必須通過下面的命令創(chuàng)建緩存表：

python manage.py createcachetable

這將在數(shù)據(jù)庫中創(chuàng)建一個表，該表的格式與 Django 數(shù)據(jù)庫緩存系統(tǒng)期望的一致。該表的表名取自 ?LOCATION ?。
如果你正在使用多個數(shù)據(jù)庫緩存， ?createcachetable ?會為每個緩存創(chuàng)建一個表。
如果你正在使用多個數(shù)據(jù)庫， ?createcachetable ?觀察你的數(shù)據(jù)庫路由器的 ?allow_migrate() ?方法。
像 ?migrate ?一樣， ?createcachetable ?不會影響已經(jīng)存在的表，它只創(chuàng)建缺失的表。
要打印即將運行的 SQL，而不是運行它，請使用 ?createcachetable --dry-run? 選項。

多數(shù)據(jù)庫

如果在多數(shù)據(jù)庫中使用緩存，你也需要設(shè)置數(shù)據(jù)庫緩存表的路由指令。因為路由的原因，數(shù)據(jù)庫緩存表在 ?django_cache ?應(yīng)用程序中顯示為 ?CacheEntry ?的模型名。這個模型不會出現(xiàn)在模型緩存中，但模型詳情可用于路由目的。
比如，下面的路由可以將所有緩存讀取操作指向 ?cache_replica ?，并且所有的寫操作指向 ?cache_primary?。緩存表將會只同步到 ?cache_primary?。

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

如果你沒有指定路由指向數(shù)據(jù)庫緩存模型，緩存后端將使用 默認 的數(shù)據(jù)庫。
如果沒使用數(shù)據(jù)庫緩存后端，則無需擔心為數(shù)據(jù)庫緩存模型提供路由指令。

文件系統(tǒng)緩存

基于文件的后端序列化并保存每個緩存值作為單獨的文件。要使用此后端，可將 ?BACKEND ?設(shè)置為 ?django.core.cache.backends.filebased.FileBasedCache?并將 ?LOCATION ?設(shè)置為一個合適的路徑。比如，在 ?/var/tmp/django_cache? 存儲緩存數(shù)據(jù)，使用以下配置：

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

如果使用 Windows 系統(tǒng)，將驅(qū)動器號放在路徑開頭，如下：

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

目錄路徑應(yīng)該是絕對路徑——因此，它應(yīng)該以文件系統(tǒng)根目錄開始。無需擔心是否需要以斜杠結(jié)尾。

確保此設(shè)置指向的目錄存在并且可讀可寫，或者它可以由運行 Web 服務(wù)器的系統(tǒng)用戶創(chuàng)建。 繼續(xù)上面的例子，如果你的服務(wù)器以用戶 ?apache ?運行，確保目錄 ?/var/tmp/django_cache? 存在并且用戶 ?apache ?可讀寫，或者它可以由用戶 ?apache ?創(chuàng)建。

當緩存 ?LOCATION ?包含在 ?MEDIA_ROOT ?或 ?STATICFILES_FINDERS ?中，敏感數(shù)據(jù)可能被暴露。
獲得訪問緩存文件的攻擊者不僅可以偽造 HTML 內(nèi)容，你的網(wǎng)站會信任它，而且還可以遠程執(zhí)行任意代碼，因為數(shù)據(jù)是用 ?pickle ?序列化的。

本地內(nèi)存緩存

如果你的配置文件中沒有指定其他緩存，那么這是默認的緩存。如果你想獲得內(nèi)存緩存的速度優(yōu)勢，但又不具備運行 ?Memcached ?的能力，可以考慮使用本地內(nèi)存緩存后端。這個緩存是每進程所有和線程安全的。要使用它，可以將 ?BACKEND ?設(shè)置為 ?django.core.cache.backends.locmem.LocMemCache?。例如：

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

?LOCATION ?被用于標識各個內(nèi)存存儲。如果只有一個 ?locmem ?緩存，你可以忽略 ?LOCATION? 。但是如果你有多個本地內(nèi)存緩存，那么你至少要為其中一個起個名字，以便將它們區(qū)分開。
這種緩存使用最近最少使用（LRU）的淘汰策略。
請注意，每個進程都會有自己的私有緩存實例，這意味著不可能進行跨進程緩存。這也意味著本地內(nèi)存緩存的內(nèi)存效率不是特別高，所以對于生產(chǎn)環(huán)境來說，它可能不是一個好的選擇。對于開發(fā)來說是不錯的選擇。

虛擬緩存（用于開發(fā)環(huán)境）

最后，Django 帶有一個實際上不是緩存的 虛擬緩存，它只是實現(xiàn)緩存接口，并不做其他操作。
如果你有一個生產(chǎn)網(wǎng)站，在不同的地方使用了大量的緩存，但在開發(fā)／測試環(huán)境中，你不想緩存，也不想單獨修改你的代碼，那么這就很有用。要激活虛擬緩存，可以像這樣設(shè)置 ?BACKEND ?：

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

使用自定義緩存后端

雖然 Django 包含了許多開箱即用的緩存后端支持，但有時你可能會想使用一個自定義的緩存后端。要在 Django 中使用外部緩存后端，使用 Python 導(dǎo)入路徑作為 ?BACKEND ?的 ?CACHES ?配置中的 ?BACKEND?，像這樣：

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

如果你正在創(chuàng)建自己的后端，你可以使用標準緩存作為參考實現(xiàn)。你可以在 Django 源代碼的 ?django/core/cache/backends/? 目錄找到代碼。
注意：除非是令人信服的理由，諸如服務(wù)器不支持緩存，否則你應(yīng)該使用 Django 附帶的緩存后端。他們經(jīng)過了良好的測試并有完整文檔。

緩存參數(shù)

每個緩存后端可以通過額外的參數(shù)來控制緩存行為。這些參數(shù)在 ?CACHES ?配置中作為附加鍵提供。有效參數(shù)如下：

• ?TIMEOUT ?：緩存的默認超時時間，以秒為單位。這個參數(shù)默認為 300 秒（5 分鐘）。你可以將 ?TIMEOUT ?設(shè)置為 ?None?，這樣，默認情況下，緩存鍵永遠不會過期。值為 0 會導(dǎo)致鍵立即過期（實際上是 “不緩存”）。
• ?OPTIONS ?：任何應(yīng)該傳遞給緩存后端的選項。有效的選項列表會隨著每個后端而變化，由第三方庫支持的緩存后端會直接將其選項傳遞給底層緩存庫。

實施自有緩存策略的緩存后端（即 ?locmem?、?filesystem ?和 ?database ?后端）將尊重以下選項：

• ?MAX_ENTRIES ?：刪除舊值之前允許緩存的最大條目。默認是 300 。
• ?CULL_FREQUENCY ?：當達到 ?MAX_ENTRIES ?時，被刪除的條目的比例。實際比例是 1 / CULL_FREQUENCY，所以將 ?CULL_FREQUENCY ?設(shè)置為 2，即當達到 ?MAX_ENTRIES ?時將刪除一半的條目。這個參數(shù)應(yīng)該是一個整數(shù)，默認為 3。
• ?CULL_FREQUENCY ?的值為 0 意味著當達到 ?MAX_ENTRIES ?時，整個緩存將被轉(zhuǎn)儲。在某些后端（特別是 ?database ?），這使得緩存速度更快，但代價是緩存未命中更多。

Memcached 和 Redis 后端將 ?OPTIONS ?的內(nèi)容作為關(guān)鍵字參數(shù)傳遞給客戶端構(gòu)造函數(shù)，從而允許對客戶端行為進行更高級的控制。 

• ?KEY_PREFIX?：一個自動包含在 Django 服務(wù)器使用的所有緩存鍵中的字符串（默認為前綴）。
• ?VERSION ?：Django 服務(wù)器生成的緩存鍵的默認版本號。
• ?KEY_FUNCTION ?：一個字符串，包含一個函數(shù)的點分隔路徑，該函數(shù)定義了如何將前綴、版本和鍵組成一個最終的緩存鍵。

在本例中，正在配置一個文件系統(tǒng)后端，超時為 60 秒，最大容量 1000 項：

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

下面是一個基于 ?pylibmc ?的后端配置的例子，它啟用了二進制協(xié)議、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／網(wǎng)絡(luò)錯誤視為緩存失效，并在連接的 socket 上設(shè)置了 ?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 的后端的示例配置，它選擇數(shù)據(jù)庫 10（默認情況下 Redis 附帶 16 個邏輯數(shù)據(jù)庫），指定解析器類（如果安裝了?hiredis-py? 包，則默認使用 ?redis.connection.HiredisParser?），以及 設(shè)置自定義連接池類（默認使用?redis.ConnectionPool?）：

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