Comment utiliser le cache Python pour améliorer la vitesse d'accès aux données

Python utilise la mise en cache

Lors du développement d'applications Web ou de systèmes distribués, la mise en cache est l'une des solutions courantes, qui peut considérablement améliorer les performances du système. En Python, nous pouvons utiliser le cache mémoire (par exemple, en utilisant functools.lru_cache) ou le stockage externe (par exemple, en utilisant Redis) pour implémenter la fonction de cache. functools.lru_cache）或者外部存储（例如使用Redis）来实现缓存功能。

Django项目接入Redis

Django是一个非常流行的Python Web框架，其内置了很多的功能模块，包括缓存。Django框架默认的缓存后端是内存缓存，然而在实际应用中，内存缓存很容易就会出现OOM（Out of Memory）错误，因此我们需要将Django项目接入到外部的缓存服务中，例如Redis。

为了接入Redis，我们可以使用django-redis这个Django插件。首先在项目的settings.py文件中，我们需要配置Redis的连接信息，例如：

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}

这里我们使用了默认的django-redis缓存后端。其中LOCATION参数指定了Redis的连接地址和端口，OPTIONS参数中的CLIENT_CLASS参数指定了Redis连接客户端的类名。

接下来我们可以在代码中使用cache对象来进行缓存操作，例如：

from django.core.cache import cache
...
data = cache.get(key)
if not data:
    data = db.query(...)
    cache.set(key, data, timeout=60)

这里我们使用了cache.get来获取缓存数据，如果缓存中没有数据，则使用数据库查询操作来获取数据，并通过cache.set将数据写入缓存中。其中timeout参数指定了缓存数据的过期时间，单位是秒。

为视图提供缓存服务

在Django中，我们可以为视图提供缓存服务，以提高视图的响应速度。为了提供缓存服务，我们可以使用django.views.decorators.cache模块中提供的装饰器。

声明式缓存

cache_page装饰器可以将视图的响应结果缓存到Redis中，例如：

from django.views.decorators.cache import cache_page
...
@cache_page(60)
def my_view(request):
    ...

这里我们使用了cache_page装饰器，将视图的响应结果缓存到Redis中，过期时间为60秒。

需要注意的是，cache_page装饰器只能用于函数视图，而不能用于类视图。这是因为它是装饰函数的装饰器，而类视图的方法是不能直接装饰的。因此，Django框架提供了method_decorator来解决这个问题，method_decorator是一个装饰类的装饰器。例如：

from django.utils.decorators import method_decorator
from django.views.decorators.cache import cache_page
@method_decorator(cache_page(timeout=60), name='get')
class MyView(View):
    ...

这里我们使用了method_decorator将cache_page装饰器应用到类视图的get方法上。

编程式缓存

除了声明式缓存之外，我们也可以使用编程式缓存来实现对视图的缓存控制。例如：

def my_view(request):
    # 先尝试从缓存中获取数据
    data = cache.get(key)
    if not data:
        # 如果缓存中没有数据，则查询数据库
        data = db.query(...)
        # 将查询结果缓存到Redis中
        cache.set(key, data, timeout=60)
    return HttpResponse(data)

这里我们使用了cache.get来尝试从Redis中获取数据，如果没有获取到，则进行数据库查询操作，并将查询结果写入到Redis中。

需要注意的是，Django框架提供了cache和caches两个现成的变量来支持缓存操作。向cache对象发送get和set消息就可以实现对缓存的读和写操作，但是这种方式能做的操作有限。如果需要更加灵活的对缓存进行操作，我们可以使用caches['default']

Le projet Django est connecté à Redis

Django est un framework Web Python très populaire avec de nombreux modules fonctionnels intégrés, y compris la mise en cache. Le backend de cache par défaut du framework Django est le cache mémoire. Cependant, dans les applications réelles, le cache mémoire peut facilement provoquer des erreurs MOO (mémoire insuffisante), nous devons donc connecter le projet Django à un service de cache externe, tel que Redis.

Pour accéder à Redis, nous pouvons utiliser le plug-in Django django-redis. Tout d'abord, dans le fichier settings.py du projet, nous devons configurer les informations de connexion Redis, par exemple :

from django.core.cache import caches
...
redis_cli = caches['default'].client

Ici, nous utilisons le django-redisbackend de mise en cache. Le paramètre <code>LOCATION spécifie l'adresse et le port de connexion Redis, et le paramètre CLIENT_CLASS dans le paramètre OPTIONS spécifie le nom de classe du client de connexion Redis.

Ensuite, nous pouvons utiliser l'objet cache dans le code pour effectuer des opérations de mise en cache, par exemple :

rrreee
• Ici, nous utilisons cache. get pour obtenir les données mises en cache. S'il n'y a pas de données dans le cache, utilisez l'opération de requête de base de données pour obtenir les données et écrivez les données dans le cache via cache.set. Le paramètre timeout spécifie le délai d'expiration des données mises en cache, en secondes.
  Fournir des services de mise en cache pour les vues
• Dans Django, nous pouvons fournir des services de mise en cache pour les vues afin d'améliorer la vitesse de réponse de la vue. Afin de fournir des services de mise en cache, nous pouvons utiliser les décorateurs fournis dans le module django.views.decorators.cache.
  Declarative Cache
• cache_pageLe décorateur peut mettre en cache les résultats de la réponse de la vue dans Redis, par exemple :

  rrreee#🎜🎜 #Ici, nous utilisons le décorateur cache_page pour mettre en cache les résultats de la réponse de la vue dans Redis, avec un délai d'expiration de 60 secondes.

Il convient de noter que le décorateur cache_page ne peut être utilisé que pour les vues de fonctions, pas les vues de classe. En effet, c'est un décorateur qui décore les fonctions et les méthodes d'affichage de classe ne peuvent pas être décorées directement. Par conséquent, le framework Django fournit method_decorator pour résoudre ce problème. method_decorator est un décorateur pour décorer les classes. Par exemple :

rrreee

Ici, nous utilisons method_decorator pour appliquer le décorateur cache_page à la méthode get de la vue de classe .

Cache programmatique

En plus de la mise en cache déclarative, nous pouvons également utiliser la mise en cache programmatique pour implémenter le contrôle du cache des vues. Par exemple :
• rrreee

  Ici, nous utilisons cache.get pour essayer d'obtenir des données de Redis. Si elles ne sont pas obtenues, effectuez une opération de requête de base de données et écrivez les résultats de la requête dans. Redis.

Il convient de noter que le framework Django fournit deux variables prêtes à l'emploi, cache et caches, pour prendre en charge les opérations de mise en cache. Les opérations de lecture et d'écriture sur le cache peuvent être réalisées en envoyant des messages get et set à l'objet cache, mais les opérations qui peuvent être effectuées dans de cette façon sont limités. Si nous avons besoin d'exploiter le cache de manière plus flexible, nous pouvons utiliser caches['default'] pour obtenir le service de cache spécifié, puis l'exploiter. Par exemple :
• rrreee

  Problèmes liés au cache

Le cache est un moyen très efficace d'optimisation des performances, mais dans les applications réelles, nous devons prêter attention à certains problèmes liés au cache pour éviter de provoquer une erreur inattendue.

• Cache avalanche

Cache avalanche signifie qu'une grande quantité de données dans le cache expire en même temps ou que le serveur de cache est en panne, ce qui rend le cache invalide, provoquant une augmentation instantanée de la pression sur la base de données, voire un phénomène d'effondrement. Afin d'éviter une avalanche de cache, nous pouvons utiliser les méthodes suivantes :

Définissez le délai d'expiration du cache de manière aléatoire pour éviter qu'un grand nombre de caches ne s'invalident en même temps.

#🎜🎜##🎜🎜##🎜🎜# Utilisez des verrous distribués pour garantir la cohérence du cache. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Utilisez un cache à plusieurs niveaux, par exemple en plaçant des données chaudes dans le cache mémoire et des données froides dans Redis pour éviter une augmentation instantanée de la pression causée par une défaillance du cache. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Panne du cache#🎜🎜##🎜🎜#Une panne du cache signifie qu'après l'échec d'un cache, un grand nombre de requêtes affluent dans la base de données en même temps, provoquant une augmentation instantanée de la pression sur la base de données. Phénomène important, voire d'effondrement. Afin d'éviter une panne de cache, nous pouvons utiliser les méthodes suivantes : #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Utilisez des verrous mutex pour éviter qu'un grand nombre de requêtes n'affluent dans la base de données en même temps. #🎜🎜##🎜🎜##🎜🎜##🎜🎜# Préchargez le cache, c'est-à-dire actualisez le cache à l'avance avant l'expiration du cache pour éviter un grand nombre de requêtes lorsque le cache expire. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Utilisez le cache de données de point d'accès pour placer les données fréquemment demandées dans le cache mémoire afin d'éviter un grand nombre de requêtes en cas de panne du cache. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Pénétration du cache#🎜🎜##🎜🎜#La pénétration du cache signifie qu'il n'y a aucune donnée requise dans le cache, ce qui entraîne la demande d'accès direct à la base de données, entraînant une augmentation Pression de la base de données Phénomène important, voire d'effondrement. Afin d'éviter la pénétration du cache, nous pouvons utiliser les méthodes suivantes : #🎜🎜#

• Pour les données qui ne sont pas dans le cache, vous pouvez définir une valeur par défaut pour éviter de demander un accès direct à la base de données.

• Utilisez le filtre Bloom pour enregistrer les données qui n'existent pas dans le cache afin d'éviter un accès direct à la base de données.

• Vérifiez les paramètres de la requête pour éviter les demandes illégales d'accès à la base de données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!