Maison > Article > développement back-end > Comment utiliser le cache Python pour améliorer la vitesse d'accès aux données
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是一个非常流行的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']
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
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 : 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 django.views.decorators.cache
. Declarative Cachecache_page
Le 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.
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 : method_decorator
pour appliquer le décorateur cache_page
à la méthode get
de la vue de classe . Cache programmatique
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.
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 : Problèmes liés au cache
Cache avalanche
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!