Français
Français
Lors du développement d'applications PHP, les extensions MySQLI sont un moyen courant d'interagir avec les bases de données MySQL. Au fur et à mesure que le projet continue de se développer, l'utilisation des fonctions MySQLI peut entraîner directement une duplication du code, un couplage élevé et difficile à maintenir. Afin d'améliorer la réutilisabilité du code et la maintenabilité, nous pouvons encapsuler la fonction MySQLI_RESULT en une couche d'accès aux données commune.
Cet article présentera comment encapsuler la fonction MySQLI_RESULT et fournira des exemples de code pour vous aider à créer une couche d'accès aux données efficace et facile à maintenir.
Le but de la couche d'accès aux données est de séparer les opérations de la base de données de la logique métier, de sorte que la logique d'accès de la base de données n'apparaît pas directement dans le code commercial de l'application. En encapsulant les opérations de la base de données, la réutilisabilité et la maintenabilité du code peuvent être améliorées et la difficulté de remplacer la base de données à l'étape ultérieure peut être réduite.
Voici quelques points à considérer lors de la conception d'une couche d'accès aux données:
Connexions de la base de données encapsulées : Évitez l'écriture répétée du code de connexion à chaque fois que vous utilisez la base de données.
Simplifier le traitement des résultats de la requête : encapsuler le fonctionnement de MySQLI_RESULT et les résultats de la requête de processus de manière unifiée.
Soutenir les opérations CRUD : Soutenir les opérations communes d'addition, de suppression, de modification et de vérification.
Améliorer la réutilisabilité du code : grâce à l'encapsulation, la réutilisabilité du code de fonctionnement de la base de données est plus élevée et la redondance du code est réduite.
Tout d'abord, nous devons créer une classe de base de données pour gérer les opérations de connexion et de requête de la base de données.
class Database {
private $connection;
// Le constructeur initialise la connexion de la base de données
public function __construct($host, $user, $password, $dbname) {
$this->connection = new mysqli($host, $user, $password, $dbname);
if ($this->connection->connect_error) {
die("Échec de la connexion: " . $this->connection->connect_error);
}
}
// Exécuter une requête，Ensemble de résultats de retour
public function query($sql) {
$result = $this->connection->query($sql);
if (!$result) {
die("La requête a échoué: " . $this->connection->error);
}
return $result;
}
// Fermez la connexion de la base de données
public function close() {
$this->connection->close();
}
}
Dans le code ci-dessus, nous encapsulons une classe de base de données avec un constructeur pour initialiser la connexion de la base de données, et une méthode de requête pour exécuter les requêtes SQL et renvoyer le jeu de résultats.
MySQLI_RESULT est un objet dans MySQLI qui est utilisé pour stocker les résultats de la requête. Lorsque nous construisons la couche d'accès aux données, nous devons généralement encapsuler mysqli_result pour rendre le fonctionnement de l'ensemble de résultats plus concis.
Voici un exemple de code de la façon de résumer mysqli_result :
class DbResult {
private $result;
// Le constructeur reçoit les résultats de la requête
public function __construct($result) {
$this->result = $result;
}
// Obtenez tous les résultats
public function fetchAll() {
$rows = [];
while ($row = $this->result->fetch_assoc()) {
$rows[] = $row;
}
return $rows;
}
// Obtenez des résultats à une seule ligne
public function fetchOne() {
return $this->result->fetch_assoc();
}
// Obtenez le nombre de lignes
public function numRows() {
return $this->result->num_rows;
}
}
Dans le code ci-dessus, la classe DBRESULT résume l'objet MySQLI_RESULT et fournit les méthodes suivantes:
fetchall () : obtenez tous les résultats de la requête.
fetchone () : obtenez le résultat d'une seule requête.
numRows () : renvoie le nombre de lignes dans le résultat de la requête.
En combinant la classe de base de données et la classe d'encapsulation du jeu de résultats, nous pouvons créer une couche d'accès des données complète, comme indiqué ci-dessous:
class DataAccessLayer {
private $db;
// Le constructeur initialise la connexion de la base de données
public function __construct($host, $user, $password, $dbname) {
$this->db = new Database($host, $user, $password, $dbname);
}
// Interroger les données et renvoyer l'ensemble de résultats encapsulé
public function fetchData($sql) {
$result = $this->db->query($sql);
$dbResult = new DbResult($result);
return $dbResult;
}
// Insérer des données
public function insertData($sql) {
return $this->db->query($sql);
}
// Mettre à jour les données
public function updateData($sql) {
return $this->db->query($sql);
}
// Supprimer les données
public function deleteData($sql) {
return $this->db->query($sql);
}
// Fermer la connexion
public function close() {
$this->db->close();
}
}
Dans cet exemple, la classe DataAccesslayer résume les opérations de base de données communes telles que la requête, l'insertion, la mise à jour et la suppression. Nous utilisons la classe DBRESULT pour encapsuler les résultats de la requête, ce qui rend le fonctionnement des résultats plus pratique.
Nous pouvons maintenant utiliser la couche d'accès aux données encapsulées dans notre code commercial:
// Créer un objet d'accès à la base de données
$dal = new DataAccessLayer('localhost', 'root', '', 'test_db');
// Données de requête
$sql = "SELECT * FROM users";
$dbResult = $dal->fetchData($sql);
// Obtenez les résultats de la requête
$users = $dbResult->fetchAll();
foreach ($users as $user) {
echo $user['username'] . "<br>";
}
// Fermez la connexion de la base de données
$dal->close();
De cette façon, nous pouvons facilement effectuer des opérations de base de données sans écrire à plusieurs reprises une logique telle que les connexions, le traitement des résultats de requête, etc. dans chaque page.
En encapsulant le jeu de résultats MySQLI_RESULT et la connexion de la base de données, nous créons une couche d'accès aux données commune. Cette couche d'accès aux données rend les opérations de base de données plus concises, réutilisables et améliore la maintenabilité du code. Vous pouvez étendre davantage cette couche d'accès aux données en fonction des besoins de votre entreprise et prendre en charge davantage d'opérations de base de données, telles que la gestion des transactions, l'insertion par lots, etc.
Si vous souhaitez gérer les connexions de la base de données plus flexibles, vous pouvez introduire un modèle singleton pour éviter de créer des connexions de base de données plusieurs fois.
J'espère que cet article peut vous aider à créer une couche de fonctionnement de base de données plus efficace et maintenable et à améliorer votre efficacité de développement.
