Français
Français
Lors du développement d'applications PHP, en particulier dans les projets impliquant des opérations de base de données, il est très important d'optimiser les performances des requêtes de base de données. MySQLI_RESULT est une fonction de PHP pour gérer les résultats de la requête MySQL, mais dans certains cas, nous exécutons la même requête de base de données plusieurs fois, ce qui peut entraîner des pertes de performances inutiles. Pour éviter les requêtes en double, nous pouvons utiliser des techniques de mise en cache statiques pour optimiser ces requêtes. Cet article présentera comment utiliser le cache statique pour optimiser la fonction MySQLI_RESULT pour réduire l'accès à la base de données inutile.
Le cache statique fait référence au stockage des résultats de la requête dans la mémoire du serveur. Lorsque la même demande de données redevient, elle récupère directement les données du cache, plutôt que de réinitialiser une requête de base de données. Cette approche peut améliorer considérablement les performances, surtout si les requêtes sont fréquentes et que les résultats ne changent pas fréquemment.
Supposons que nous ayons une simple requête MySQL:
<?php
// Créer une connexion de base de données
$mysqli = new mysqli("localhost", "user", "password", "database");
// Interroger la base de données
$query = "SELECT * FROM users WHERE id = 1";
$result = $mysqli->query($query);
// Traiter les résultats de la requête
if ($result) {
$row = $result->fetch_assoc();
echo "User Name: " . $row['name'];
}
?>
Dans ce cas, chaque fois que cette requête est exécutée, la base de données est accessible et la même requête est exécutée. Pour optimiser ce processus, nous pouvons stocker les résultats dans un cache après la première requête, puis obtenir les données directement à partir du cache dans les demandes ultérieures, au lieu d'exécuter à nouveau la requête de la base de données.
Il existe un moyen facile d'implémenter la mise en cache statique dans PHP, qui est d'utiliser des variables statiques. Les variables statiques conservent leurs valeurs entre les appels de fonction et peuvent stocker efficacement les résultats de la requête. Voici comment modifier le code ci-dessus pour utiliser le cache statique:
<?php
// Créer une connexion de base de données
$mysqli = new mysqli("localhost", "user", "password", "database");
// Définir une variable statique pour mettre en cache les résultats de la requête
function getUserById($id) {
static $cache = [];
// Si les résultats de la requête de l'utilisateur sont déjà dans le cache，Renvoie directement les données mises en cache
if (isset($cache[$id])) {
return $cache[$id];
}
// S'il n'y a pas de cache，Effectuer une requête de base de données
global $mysqli;
$query = "SELECT * FROM users WHERE id = ?";
$stmt = $mysqli->prepare($query);
$stmt->bind_param("i", $id);
$stmt->execute();
$result = $stmt->get_result();
// Si la requête réussit，Enregistrer dans le cache
if ($result) {
$row = $result->fetch_assoc();
$cache[$id] = $row; // Enregistrer dans le cache
return $row;
}
return null;
}
// Interroger l'utilisateur avec cache
$user = getUserById(1);
if ($user) {
echo "User Name: " . $user['name'];
}
?>
Dans le code ci-dessus, la fonction GetUserById utilise une variable statique $ cache pour stocker les résultats de la requête. Lorsqu'un utilisateur est interrogé pour la première fois, le résultat sera stocké dans le tableau de cache $ . Après cela, lorsque vous interrogez à nouveau le même utilisateur, il sera directement récupéré à partir de $ cache et n'aura plus accédé à la base de données.
Bien que les variables statiques soient très efficaces pour les caches simples, il est recommandé d'utiliser une bibliothèque de cache dédiée telle que Redis ou Memcached pour des applications complexes, ou lorsque vous devez partager le cache sur plusieurs demandes. Ces systèmes de cache peuvent fournir un cache distribué, un cache persistant et des capacités de gestion de cache plus puissantes.
<?php
// créer Redis connecter
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);
// Créer une connexion de base de données
$mysqli = new mysqli("localhost", "user", "password", "database");
function getUserById($id) {
global $redis, $mysqli;
// examiner Redis Y a-t-il des données mises en cache
$cachedData = $redis->get("user_{$id}");
if ($cachedData) {
return unserialize($cachedData); // Obtenez des données de Cache
}
// S'il n'y a pas de cache，Effectuer une requête de base de données
$query = "SELECT * FROM users WHERE id = ?";
$stmt = $mysqli->prepare($query);
$stmt->bind_param("i", $id);
$stmt->execute();
$result = $stmt->get_result();
// Si la requête réussit，Sauvegarder Redis cache
if ($result) {
$row = $result->fetch_assoc();
$redis->set("user_{$id}", serialize($row), 3600); // cache1Heure
return $row;
}
return null;
}
// Interroger l'utilisateur avec cache
$user = getUserById(1);
if ($user) {
echo "User Name: " . $user['name'];
}
?>
Dans le code ci-dessus, nous utilisons Redis comme stockage de cache. Lors de l'interrogation de la base de données, si des données mises en cache existent dans Redis, le résultat mis en cache sera renvoyé directement. Sinon, la requête de la base de données sera exécutée et les résultats seront stockés dans Redis.
Un problème important avec la mise en cache est cette défaillance du cache ou la mise à jour. Lorsque les données de la base de données changent, les données du cache doivent être mises à jour ou effacées de manière synchrone. Les stratégies courantes comprennent:
Cache de mise à jour en temps opportun : effacez régulièrement le cache et remettez-vous le cache de mise à jour de la base de données.
Mettez à jour manuellement le cache : lorsque les données changent, effacez manuellement le cache pertinent ou mettez à jour le cache.
En utilisant des caches statiques ou des bibliothèques de cache telles que redis ou memcached, nous pouvons éviter efficacement l'exécution répétée des requêtes de base de données, améliorant considérablement les performances de notre application. Lors de la mise en œuvre de la mise en cache, la stratégie de défaillance du cache doit être prise en compte pour assurer la précision et la cohérence des données. J'espère que cet article peut vous aider à mieux comprendre comment optimiser la requête de base de données de la fonction MySQLI_RESULT .
