Arbetar med @cache_page() dekoratör i django-redis-cache

cache_page dekoratör är en django dekoratör, inte en django-redis dekoratör. Så, om du använde en standardcache som memcached i django, skulle cache_page-dekoratören ha gjort samma nycklar i memcached. Här är dekoratörens baskod längs doc-strängen:

https://github.com/django/django/blob/711123e1cdaf3b08c876c045d8d38decdc7a63d3/django/views/decorators/cache.py#L8

"""Dekoratör för vyer som försöker hämta sidan från cachen och fyller i cachen om sidan inte finns i cachen ännu. Cacheminnet knappas av URL:en och vissa data från rubrikerna. Dessutom finns nyckelprefixet som är används för att särskilja olika cacheområden i en multi-site-inställning. Du kan till exempel använda theget_current_site().domain, eftersom den är unik över ett Djangoprojekt. Dessutom kommer alla rubriker från svarets Vary-rubrik att beaktas vid cachning -- bara som mellanvaran gör."""

Så, i sig skapar det flera nycklar, en för rubriker och en för HTTPResponse-innehållet. Den skapar nycklarna baserat på rubrik och innehåll, så att varje ändring i header ogiltigförklarar cachen (till exempel vid vary headers), d.v.s. även med samma parametrar i webbadressen, men olika innehåll i begäran-headers kommer du att ha separata cachar . Exempel på olika förfrågningsrubriker kan vara att skicka inloggningsinformation om samma sida för olika inloggade användare, eller att servera olika innehåll för samma webbadress baserat på information om mobil/desktop användaragent som finns i rubriker. Här är cache-nyckelkoden i django :

def _generate_cache_key(request, method, headerlist, key_prefix):
    """Return a cache key from the headers given in the header list."""
    ctx = hashlib.md5()
    for header in headerlist:
        value = request.META.get(header)
        if value is not None:
            ctx.update(force_bytes(value))
    url = hashlib.md5(force_bytes(iri_to_uri(request.build_absolute_uri())))
    cache_key = 'views.decorators.cache.cache_page.%s.%s.%s.%s' % (
        key_prefix, method, url.hexdigest(), ctx.hexdigest())
    return _i18n_cache_key_suffix(request, cache_key)


def _generate_cache_header_key(key_prefix, request):
    """Return a cache key for the header cache."""
    url = hashlib.md5(force_bytes(iri_to_uri(request.build_absolute_uri())))
    cache_key = 'views.decorators.cache.cache_header.%s.%s' % (
        key_prefix, url.hexdigest())
    return _i18n_cache_key_suffix(request, cache_key)


def get_cache_key(request, key_prefix=None, method='GET', cache=None):
    """
    Return a cache key based on the request URL and query. It can be used
    in the request phase because it pulls the list of headers to take into
    account from the global URL registry and uses those to build a cache key
    to check against.
    If there isn't a headerlist stored, return None, indicating that the page
    needs to be rebuilt.
    """
    if key_prefix is None:
        key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX
    cache_key = _generate_cache_header_key(key_prefix, request)
    if cache is None:
        cache = caches[settings.CACHE_MIDDLEWARE_ALIAS]
    headerlist = cache.get(cache_key)
    if headerlist is not None:
        return _generate_cache_key(request, method, headerlist, key_prefix)
    else:
        return None