Cache - Quelle est la signification du numéro de série ajouté avant le nom de la clé Redis définie avec le cache Django ?

Question

Lorsque vous utilisez le module fourni avec Django pour gérer le cache Redis, la clé définie est, par exemple, "banners". Lorsque vous voyez le nom dans la cli redis, elle devient ":1:banners". de Django ? Et redis

from django.core.cache import cache

def get_queryset(self):
        key = "banners"
        queryset = cache.get(key)
        if not queryset:
            queryset = Banner.objects.filter(valid=True)
            cache.set(key, queryset, 3600)
        return queryset

Answer 1

Lors de la configuration de Redis vous-même, vous choisirez la bibliothèque Redis elle-même est divisée en plusieurs bibliothèques, cela dépend de celle que vous configurez

.

Answer 2

C'est le mécanisme du cache Django. La clé se compose du préfixe, du numéro de version et de la vraie clé. Django est utile lors d'une mise à niveau ou d'une refactorisation de code. Vous pouvez déterminer quel numéro de version correspond à la clé pour des raisons de compatibilité (d'autres ajouts sont les bienvenus)

.

1. Premier aperçu de l'implémentation de l'API client Django Redis :

# https://github.com/niwinz/django-redis/blob/master/django_redis/client/default.py
def get(self, key, default=None, version=None, client=None):
    """
    Retrieve a value from the cache.
    Returns decoded value if key is found, the default if not.
    """
    if client is None:
        client = self.get_client(write=False)

    key = self.make_key(key, version=version)

    try:
        value = client.get(key)
    except _main_exceptions as e:
        raise ConnectionInterrupted(connection=client, parent=e)

    if value is None:
        return default

    return self.decode(value)

... 中间省略代码 ...


def make_key(self, key, version=None, prefix=None):
    if isinstance(key, CacheKey):
        return key

    if prefix is None:
        prefix = self._backend.key_prefix

    if version is None:
        version = self._backend.version

    return CacheKey(self._backend.key_func(key, prefix, version))
  

Il utilise la fonction make_key pour créer une nouvelle clé. La vraie clé provient de _backend.key_func.

2. Ensuite, découvrez l'implémentation du backend du cache Django

# https://github.com/django/django/blob/master/django/core/cache/backends/base.py
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
    
class BaseCache(object):
    def __init__(self, params):
    
        ... 中间省略代码 ...
        
        self.key_prefix = params.get('KEY_PREFIX', '')
        self.version = params.get('VERSION', 1)
        self.key_func = get_key_func(params.get('KEY_FUNCTION'))
    

On peut voir que la clé du cache Django Redis est composée d'un préfixe, d'un numéro de version et d'une vraie clé.