Français
Français
Dans la stratégie de cache de PHP, la fonction APCU_ENTRY () est largement utilisée pour simplifier les opérations de lecture et d'écriture du cache. Il rend le code plus concis en fournissant une fonction de rappel qui génère et stocke automatiquement les données lorsque le cache n'existe pas. Cependant, s'ils sont mal utilisés, il peut entraîner des problèmes de «pénétration du cache», ce qui entraînera un fardeau supplémentaire sur le système.
Cet article explorera comment éviter efficacement la pénétration du cache dans le processus d'utilisation d'APCU_ENTRY () .
La pénétration du cache fait référence à la situation où la requête du système de cache est manquée et la base de données backend ne peut pas trouver de données. Les attaquants ou les robots peuvent constamment demander des données inexistantes, contourner la couche de cache et accéder directement à la base de données, provoquant une augmentation soudaine de la pression de la base de données.
Dans le contexte d' APCU_ENTRY () , si une requête de base de données est effectuée sur chaque clé manquée, elle équivaut à donner au cache un canal vert.
$value = apcu_entry("user_123", function() {
// Obtenez des données de la base de données
return fetch_user_from_db(123);
});
Ce code est logiquement concis. Si la clé n'existe pas, la fonction de rappel sera automatiquement appelée et le résultat de retour sera stocké dans le cache. Cependant, si fetch_user_from_db () renvoie null (comme l'utilisateur n'existe pas), Null sera-t-il également mis en cache? La valeur par défaut est oui. Le problème est:
Si Null n'est pas mis en cache, la base de données sera déclenchée à chaque demande;
Si Null est mis en cache, vous devez également faire attention au temps de cache et comment distinguer les «vérification sans données» et «l'expiration des données».
Lorsque la base de données ne peut pas trouver de données, une valeur de signalisation spéciale est renvoyée et un court délai d'expiration est défini. Par exemple:
$value = apcu_entry("user_123", function() {
$user = fetch_user_from_db(123);
return $user !== null ? $user : '__NULL__';
});
Lorsque vous l'utilisez, jugez:
if ($value === '__NULL__') {
// Les données n'existent pas，Ignorer ou revenir en toute sécurité 404
} else {
// Utilisation normale des données
}
Cela peut éviter efficacement le problème de l'accès répété à la base de données.
Afin d'éviter les grandes quantités de données "non valides", vous pouvez définir le temps de cache des valeurs nuls, telles que l'utilisation d'APCU_STORE () au lieu d' APCU_ENTRY () :
$key = "user_123";
if (!apcu_exists($key)) {
$user = fetch_user_from_db(123);
$value = $user !== null ? $user : '__NULL__';
apcu_store($key, $value, $user !== null ? 600 : 60);
} else {
$value = apcu_fetch($key);
}
Cette méthode est plus flexible et adaptée aux scénarios où un contrôle à grain fin est requis.
La pénétration du cache est souvent causée par des clés illégales ou aléatoires. Vous pouvez vérifier la clé, par exemple si l'ID utilisateur est un entier ou s'il se trouve dans la plage juridique:
function is_valid_user_id($id) {
return is_numeric($id) && $id > 0 && $id < 1000000;
}
if (!is_valid_user_id($id)) {
exit('Invalid user ID');
}
Seul un ID légitime permet un accès continu à la base de données ou au système de cache.
Lorsque vous utilisez APCU_ENTRY () , s'il n'y a pas de stratégie de traitement de valeur nulle, il est très facile de causer des problèmes de pénétration du cache. Nous pouvons éviter efficacement ce risque en mettant en cache les valeurs nuls, en contrôlant le temps d'expiration et en vérification clé. L'utilisation rationnelle des stratégies de cache peut non seulement améliorer les performances, mais également améliorer la résistance à la compression du système.
N'oubliez pas que l'objectif de la conception du cache n'est pas de "sauver toutes les données", mais de "rester la plupart des demandes sur la couche de cache".
Pour pratiquer davantage ces suggestions, vous pouvez déployer dans votre propre environnement, par exemple:
$url = "https://gitbox.net/api/user/123";
En utilisant des scénarios réels pour tester la logique du cache et de la pénétration du cache, cela aide à approfondir la compréhension et à optimiser l'implémentation.
