Français
Français
Lors du développement à l'aide de PHP, en particulier dans l'architecture MVC (modèle-View-Controller), comment gérer les opérations de base de données est un problème clé. L'extension MySQLI est un moyen courant d'accéder aux bases de données MySQL dans PHP, et la fonction MySQLI_RESULT est utilisée pour obtenir l'ensemble de résultats à partir d'une requête de base de données. Dans l'architecture MVC, si les requêtes de base de données et les ensembles de résultats sont traitées directement dans le contrôleur, cela peut faire gonfler le code, difficile à maintenir et même difficile à évoluer. Par conséquent, comment encapsuler élégamment la fonction MySqli_Result pour améliorer la maintenabilité et l'évolutivité du code est un problème que les développeurs doivent résoudre.
Cet article présentera comment résumer élégamment l'utilisation de MySQLI_RESULT en mode MVC et donner des exemples de code pertinents.
Dans l'architecture MVC, la division des responsabilités est très importante:
Modèle : responsable de l'interaction avec les sources de données (telles que des bases de données), de l'encapsulation de la requête de données et des opérations de mise à jour.
Voir : responsable de l'affichage des données, n'implique généralement pas les opérations de base de données.
Contrôleur : reçoit une entrée utilisateur, appelle le modèle correspondant pour traiter les données et transmet le résultat à la vue.
Afin de garder le code clair et cohésif, nous devons concentrer la logique de l'interaction avec la base de données sur la couche de modèle, et le contrôleur n'a besoin que d'appeler des méthodes dans le modèle pour obtenir les données.
L'objet mysqli_result est le jeu de résultats renvoyé en exécutant l'instruction de requête. Afin d'améliorer la maintenabilité et l'évolutivité du code, nous devons éviter de manipuler directement l'objet mysqli_result dans le contrôleur. Les raisons comprennent:
Duplication de code : lors du traitement de la requête, il en résulte plusieurs endroits, il est facile de provoquer du code en double.
Difficile à tester : la manipulation directe de l'objet mysqli_result rend les tests unitaires difficiles.
Mauvaise évolutivité : le fonctionnement directement de MySQLI_RESULT rendra difficile l'élargissement du pilote de base de données plus tard (comme passer de MySQL à PostgreSQL).
Par conséquent, nous devons résumer le fonctionnement de l'objet MySQLI_RESULT afin qu'il devienne un module indépendant qui peut être réutilisé dans différents scénarios et peut être modifié et élargi plus facilement.
Tout d'abord, nous pouvons créer une classe abstraite de base de données responsable de la gestion des connexions de base de données et des opérations de requête. Cette classe renverra l'ensemble de résultats encapsulé pour éviter de manipuler directement l'objet mysqli_result dans le contrôleur.
<?php
abstract class Database {
protected $connection;
public function __construct($host, $username, $password, $dbname) {
$this->connection = new mysqli($host, $username, $password, $dbname);
if ($this->connection->connect_error) {
die("Connection failed: " . $this->connection->connect_error);
}
}
abstract public function query($sql);
}
?>
Ensuite, créez une classe de base de données spécifique qui hérite de la classe de base de données . Cette classe résumera les opérations de requête et d'obtention de l'ensemble de résultats.
<?php
class MySQLDatabase extends Database {
public function query($sql) {
$result = $this->connection->query($sql);
if ($result === false) {
return false; // Retour lorsque la requête échoue false
}
return new MySQLResult($result); // Renvoie l'objet SET des résultats encapsulés
}
}
?>
Ensuite, nous créons une classe mysqlresult pour encapsuler l'objet mysqli_result . Cette classe fournira quelques méthodes pratiques pour simplifier le fonctionnement des résultats de la requête.
<?php
class MySQLResult {
private $result;
public function __construct(mysqli_result $result) {
$this->result = $result;
}
public function fetchAll() {
return $this->result->fetch_all(MYSQLI_ASSOC); // Obtenez toutes les données
}
public function fetchRow() {
return $this->result->fetch_assoc(); // Obtenez une ligne de données
}
public function numRows() {
return $this->result->num_rows; // Obtenez le nombre de lignes dans l'ensemble de résultats
}
public function free() {
$this->result->free(); // Libérez l'ensemble de résultats
}
}
?>
Dans cette classe, nous encapsulons certaines opérations communes de MySQLI_RESULT , telles que: obtenir toutes les lignes, obtenir une seule ligne, obtenir un numéro de jeu de résultats et libérer le jeu de résultats. Cela rend les opérations de requête de base de données plus concises et plus faciles à maintenir.
Dans le contrôleur, nous pouvons obtenir des données en appelant des méthodes dans le modèle sans se soucier de la façon de faire fonctionner l'objet mysqli_result .
<?php
class UserController {
private $db;
public function __construct() {
$this->db = new MySQLDatabase('localhost', 'root', '', 'my_database');
}
public function getUserList() {
$sql = "SELECT * FROM users";
$result = $this->db->query($sql);
if ($result === false) {
echo "Query failed.";
return;
}
$users = $result->fetchAll(); // Obtenez toutes les données utilisateur
foreach ($users as $user) {
echo "User: " . $user['name'] . "<br>";
}
$result->free(); // Libérez l'ensemble de résultats
}
}
?>
Dans le contrôleur, nous appelons la méthode de requête du modèle de base de données pour la requête. L'objet mysqlresult renvoyé peut obtenir tous les résultats via fetchall () , ou utiliser fetchrow () pour obtenir des données à ligne unique. De cette façon, le code du contrôleur devient très concis et la logique est complètement séparée de l'opération de base de données, ce qui facilite le maintien et le développement.
En encapsulant l'objet MySQLI_RESULT dans l'architecture MVC, nous concentrons non seulement les opérations de base de données sur la couche de modèle, mais améliorons également la maintenabilité et l'évolutivité de notre code. L'utilisation de la classe MySqlResult encapsulée peut simplifier le traitement des résultats de la requête, permettant au contrôleur de se concentrer sur la logique métier sans se soucier de l'implémentation de la base de données sous-jacente. Cette approche présente de grands avantages pour la collaboration d'équipe et l'expansion ultérieure.
