Accès objet à MySQL avec PHP5
Date de publication : 20 août 2011
Par
Mbella Demazy
Cet article explique :
Comment accéder à une base de donnée MySQL en orienté objet avec PHP 5 en utilisant l'extension mysqli.
I. Introduction
II. Prérequis
III. Les classes de l'extension Mysqli.
III-1. La classe mysqli.
III-1-1. Propriétés
III-1-2. méthodes
III-2. La classe mysqli_result
III-2-1. Propriétés
III-2-2. Méthodes
III-3. La classe mysqli_stmt
III-3-1. Propriétés
III-3-2. Méthodes
III-4. La classe mysqli_driver
III-4-1. Propriétés
III-4-2. Méthodes
IV. Mise en œuvre
IV-1. La base de données
IV-2. Connexion et déconnexion à la base de données
IV-3. La classe Produit
IV-4. La classe MonIterateur
IV-5. La couche de traitement de la classe "Produit"
IV-6. Test de l'application
IV-6-1. Insertion d'un nouvel enregistrement dans la table "produit"
IV-6-2. Affichage des données de la table produit
IV-6-3. Details/Modification
IV-6-4. Suppression d'un enregistrement
V. Conclusion
VI. Remerciements
I. Introduction
Lorsqu'on décide de faire du PHP orienté objet sans avoir à faire de la programmation procédurale, très souvent on est coincé lorsqu'il s'agit d'accéder à une base de donnée et plus particulièrement à MySQL.
En effet, l'extension mysql très souvent utilisée en PHP pour se connecter à une base de données Mysql, et qui n'est d'ailleur plus maintenu est une extension exclusivement procédurale et n'offre de ce fait,
aucun mécanisme d'accès aux données en orienté objet.
Cependant, la version 5 de PHP, à savoir PHP5, ayant été conçu pour accroître les capacités orientées objet de PHP, a prévu des moyens de le faire et nous verons comment.
Grâce à l évolution qu'a connu le langage PHP entre la version 4 et la version 5, la programmation orienté objet avec ce langage a connu pas mal d'évolution et d'amélioration.
L'accès aux données n'est pas resté en marge de cette logique, et c'est ainsi que l'accès objet à une base de donnée MySQL est désormais possible grâce à l'utilisation des extensions PDO(PHP Data Objects) et mysqli (mysql improved) de PHP.
Dans cet article nous parlerons de l'extension mysqli.
Cette extension mysqli a les avantages suivants par rapport à ces prédécesseurs :
- Une interface orienté objet ;
- Le support des commandes préparées ;
- Le support des commandes multiples ;
- Le support des transactions ;
- Des capacités de débogage avancées.
II. Prérequis
Pour une bonne compréhension de cet article vous devez comprendre les concepts suivants :
-
Les bases de la programmation avec le langage PHP ;
-
La POO et son implémentation dans PHP 5 ;
-
Les itérateurs en PHP5
-
Le langage SQL et son utilisation avec le SGBD Mysql: les versions de MySQL recommandées pour utiliser mysqli
sont: la version 4.1.13 ou plus récente, et la version 5.0.7 ou plus récente ;
-
Il faut également que l'extention mysqli soit activé dans votre configuration de php: si vous utiliser un package comme Wamp dans
ses dernières version , cette extention est activé par défaut. Dans le cas contraire vous pouver aller dans votre fichier
php.ini et décommenter (en supprimant le ";" du début de ligne) la ligne "extension=php_mysqli.dll"
III. Les classes de l'extension Mysqli.
Mysqli possède les classes suivantes à l'origine de ces avantages :
- La classe mysqli : elle permet de créer des objets de types mysqli_object. Cette dernière possède des méthodes et des propriétés nécessaires pour permettre par exemple
de se connecter à la base de données, d'envoyer des requêtes préparées à cette dernière, ou alors d'effectuer des transactions ;
- La classe mysqli_result : elle permet de gérer les résultats des requêtes SQL effectuées à l'aide de l'objet mysqli précédent.
C'est ainsi qu'elle possède des méthodes et des propriétés permettant de manipuler de plusieurs manières les résultats issus d'une requête SQL en rendant par exemple ceux-ci sous forme
de tableau associatif, de tableau indicé, d'obtenir le nombre de tuple d'un résultat … etc ;
- La classe mysqli_stmt : elle permet d'effectuer des requêtes préparées sur la base de données ;
- La classe mysqli_driver : elle permet la gestion des drivers mysqli ;
III-1. La classe mysqli.
Cette classe possède un certain nombre de propriétés et de méthodes. Nous nous limiterons à n'évoquer que quelques-unes.
III-1-1. Propriétés
mysqli->affected_rows : contient le nombre de lignes affectées par la dernière requêtes INSERT, UPDATE ,REPLACE ou DELETE.
mysqli->insert_id : retourne l'identifiant automatiquement généré pour un attribut déclaré AUTO_INCREMENT.
III-1-2. méthodes
mysqli ( [string $host [, string $username [, string $passwd [, string $base [, int $port [,
string $socket]]]]]] ) : permet de créer un objet mysqli, afin de se connecter à la base de données MySQL.
close(void) : permet de fermer une connexion à la base de donnée Mysql ; elle retourne true en cas de succès et false si non.
query(string $query [, int $mode]) : permet d'exécuter une requête sur la base de données ;
le paramètre $mode est une constante valant MYSQLI_USE_RESULT ou MYSQLI_STORE_RESULT (valeur par défaut) suivant le comportement désiré.
select_db(string $db) : permet de sélectionner une base de données.
III-2. La classe mysqli_result
III-2-1. Propriétés
mysqli_result->field_count : récupère le nombre de champs dans un jeu de résultat.
mysqli_result->num_rows : retourne le nombre de lignes d'un résultat.
III-2-2. Méthodes
fetch_all ([ int $resulttype ]) : permet de lire tous les résultats d'une requête et de les retourner sous forme de tableau associatif,
numérique ou les deux à la fois ceci suivant la valeur du paramètre $resulttype qui peut être : MYSQLI_ASSOC pour un tableau associatif MYSQLI_NUM pour un tableau numérique ;
cette valeur étant la valeur par défaut, MYSQLI_BOTH pour les deux.
fetch_array ([ int $resulttype ] ) : permet de retourner une ligne de résultat sous forme d'un tableau associatif, d'un tableau indexé,
ou les deux suivant la valeur du paramètre $resulttype qui peut être : MYSQLI_ASSOC, MYSQLI_NUM, MYSQLI_BOTH (valeur par défaut).
fetch_assoc ( void ) : permet de récupérer une ligne de résultat sous forme de tableau associatif ;
fetch_object ([ string $class_name [, array $params ]]) : retourne la ligne courante d'un jeu de résultat sous forme d'objet ;
en paramètre nous avons $class_name qui représente le nom de la classe à instancier , et $params un tableau contenant la liste des paramètres à passer au constructeur de cette classe.
fetch_row ( void ) : permet de récupérer une ligne de résultat sous forme de tableau indexé.
III-3. La classe mysqli_stmt
III-3-1. Propriétés
mysqli_stmt->affected_rows : retourne le nombre total de lignes modifiées, effacées, ou insérées par la dernière requête.
mysqli_stmt->insert_id : récupère l'ID généré par la dernière requête INSERT.
mysqli_stmt ->num_rows : retourne le nombre de ligne d'un résultat MySQL.
III-3-2. Méthodes
prepare( string $query ) : permet de préparer une requête SQL pour exécution.
reset( void ) : permet d'annuler une requête préparée.
III-4. La classe mysqli_driver
III-4-1. Propriétés
Cette classe est pour le moment très peu documentée mais possède néanmoins les propriétés suivantes :
- client_version : qui indique la version du client ;
- driver_version : qui indique la version du driver MySQLi.
III-4-2. Méthodes
Il n'y en a que deux pour le moment et sont également peu documentées il s'agit de :
- embedded_server_end(void) : qui permet d'arrêter le serveur embarqué ;
- embedded_server_start ( bool $start , array $arguments , array $groups ) : qui permet d'initialiser et de démarrer le serveur embarqué.
IV. Mise en œuvre
Pour illustrer l'utilisation de mysqli pour accéder à MySQL, nous allons mettre en place une application web basique à trois couches:
une couche pour l'accès aux données, une couche pour l'interface et une couche de traitement qui sert d'intermédiaire entre les 2 couches précédentes.
 |
Dans l'exemple que nous prenons, l'aspect sécurité est peu ou pas assez pris en compte ;
il est donc possible que le code qui suit puisse être vulnérable aux attaques comme les SQL Injections ou toute autre attaque courante.
|
IV-1. La base de données
Pour pouvoir observer comment tout ceci est mis en œuvre, nous avons besoin d'une base de données MySql.
Cette base de données s'appellera " cabinet" et possèdera une table, la table " produit ".
Le script SQL correspondant pour cette base de données est le suivant :
CREATE DATABASE `cabinet` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci;
USE cabinet;
CREATE TABLE `produit` (
`prd_id` bigint(20) NOT NULL auto_increment COMMENT 'identification du produit, clé primaire de la table produit',
`prd_libelle` varchar(200) NOT NULL COMMENT 'libellé du produit',
`prd_reference` varchar(20) NOT NULL COMMENT 'reférence du produit:; doit etre unique',
`prd_fabricant` varchar(200) NOT NULL COMMENT 'fabricant du produit',
`prd_qteStock` int(11) NOT NULL COMMENT 'quantite de produit en stock',
`prd_qteAllert` int(11) NOT NULL COMMENT 'le stock d''alerte pour necessité un approvisionnement',
`prd_unite` varchar(100) default NULL COMMENT 'unité du produit',
PRIMARY KEY (`prd_id`),
UNIQUE KEY `prd_reference` (`prd_reference`)
) TYPE=InnoDB AUTO_INCREMENT=1 ;
|
IV-2. Connexion et déconnexion à la base de données
Nous allons illustrer le mécanisme de connexion et de déconnexion à la base de données à travers une classe qui héritera de la classe mysqli et qui possédera comme membres deux méthodes :
une méthode pour la connexion à la BD : connect(), et une autre pour la déconnexion à celle-ci : disconnect() .
Etant donné que la connexion à la base de données nécessite des paramètres de connexion que sont l'hôte, l'utilisateur, le login, le mot de passe, ainsi que le nom de la base de données
à laquelle on souhaite se connecter, ces paramètres seront également définis en tant que constante de classe.
Le code complet de cette classe que nous appellerons Connexion sera contenu dans le fichier connexion.class.php dont le contenu est le suivant:
class Connexion extends mysqli
{
const HOST = 'localhost';
const USER = 'root';
const PASSWORD = 'laboratoire';
const DATABASE = 'cabinet';
public function connect()
{
try
{
$con = new mysqli(self::HOST,self::USER,self::PASSWORD,self::DATABASE);
$con->set_charset("utf8");
if(mysqli_connect_error())
{
$con = 'echec de la connexion à la base de données ('. mysqli_connect_errno().')'. mysqli_connect_error();
print $con;
return false;
}
else
{
return $con;
}
}
catch (Exception $e)
{
print_r($e->getMessage());
}
}
public function disconnect(mysqli $con)
{
try
{
$val = $con->close();
if($val)
{
return true;
}
else
{
return false;
}
}
catch (Exception $e)
{
print_r($e->getMessage());
}
}
}
|
IV-3. La classe Produit
Précédemment nous avons fait allusion à la table " produit " dans notre base de données ; maintenant, nous allons écrire la classe
correspondante et nous écrirons également les méthodes d'accès aux enregistrements de cette table.
Ainsi une méthodes comme get_id() permet d'obtenir la valeur de la propriété $prd_id de la classe Produit, tant disque la méthode set_id($id) permet de définir ou de modifier cette valeur.
La classe "Produit" sera contenu dans le fichier produit.class.php. Elle possède en plus des propriétés, des accesseurs, des mutateurs et du constructeur,
elle possède également les méthodes suivantes qui agiront sur les données, chacune à sa manière :
- GetOneProduit : elle prend en entrée l'objet mysqli de connexion à MySQL et l'identifiant d'un produit dans la table produit, afin de le retourner sous la forme d'un objet de type " Produit ".
- GetAllProduit : cette méthode prend en entrée l'objet mysqli de connexion à la base de données, l'ordre dans lequel les résultats devront être retournés, et la colonne suivant laquelle les résultats seront triés.
Elle retourne la liste des produits présents dans la table " produit " sous forme d'un objet de type " Moniterateur ".
- UpdateProduit : cette méthode permet de mettre à jour une ligne dans la table " produit "; elle prend en entrée l'objet mysqli de connexion à la BD et d'autres paramètres correspondant aux propriétés de la classe " Produit ".
Elle retourne true en cas de succès ou un message d'erreur si non.
- SetProduit : cette méthode qui prend en entrée un objet mysqli de connexion à la BD, permet d'insérer un enregistrement dans la table " produit " ; elle retourne true en cas de succès, ou un message d'erreur si non.
- DeleteOneProduit : elle permet de supprimer un enregistrement dans la table produit; elle prend en entrée l'identifiant du produit à supprimer dans la table et l'objet mysqli de connexion à la BD.
Le code de cette classe Produit est le suivant :
class Produit
{
private $prd_id;
private $prd_libelle;
private $prd_reference;
private $prd_fabricant;
private $prd_qteStock;
private $prd_qteAllert;
private $prd_unite;
public function __construct()
{
$this->prd_id = "";
$this->prd_libelle ="";
$this->prd_reference = "";
$this->prd_fabricant = "";
$this->prd_qteStock = "";
$this->prd_qteAllert = "";
$this->prd_unite = "";
}
public function get_id()
{
return $this->prd_id;
}
public function set_id($id)
{
$this->prd_id = $id;
}
public function get_libelle()
{
return $this->prd_libelle;
}
public function set_libelle($libelle)
{
$this->prd_libelle = $libelle;
}
public function get_reference()
{
return $this->prd_reference;
}
public function set_reference($reference)
{
$this->prd_reference= $reference;
}
public function get_fabricant()
{
return $this->prd_fabricant;
}
public function set_fabricant($fabricant)
{
$this->prd_fabricant=$fabricant;
}
public function get_qteStock()
{
return $this->prd_qteStock;
}
public function set_qteStock($qteStock)
{
$this->prd_qteStock=$qteStock;
}
public function get_qteAllert()
{
return $this->prd_qteAllert;
}
public function set_qteAllert($qteAllert)
{
$this->prd_qteAllert = $qteAllert;
}
public function get_unite()
{
return $this->prd_unite;
}
public function set_unite($unite)
{
$this->prd_unite = $unite;
}
public function GetOneProduit(mysqli $id_con,$id)
{
try
{
if(ctype_digit($id))
{
$sql = "SELECT * FROM produit WHERE prd_id ='$id'";
$result = $id_con->query($sql);
$ligne = $result->fetch_assoc();
$unobjet = new Produit();
$unobjet->set_id($ligne['prd_id']);
$unobjet->set_libelle($ligne['prd_libelle']);
$unobjet->set_reference($ligne['prd_reference']);
$unobjet->set_qteStock($ligne['prd_qteStock']);
$unobjet->set_qteAllert($ligne['prd_qteAllert']);
$unobjet->set_unite($ligne['prd_unite']);
$unobjet->set_fabricant($ligne['prd_fabricant']);
return $unobjet;
}
}
catch (Exception $e)
{
printf("une erreur s'est produite avec le message : %s",$e->getMessage());
}
}
public function GetAllProduit(mysqli $id_con, $order, $by)
{
$tab = array('prd_id','prd_libelle','prd_reference','prd_fabricant','prd_qteStock','prd_qteAllert','prd_unite');
try
{
if((strtoupper($order)=="ASC" || strtoupper($order)=="DESC") && in_array($by,$tab))
{
$sql = "SELECT * FROM produit ORDER BY $by $order";
$myIt = new Moniterateur($sql,$id_con);
return $myIt;
}
}
catch (Exception $e)
{
printf("une erreur s'est produite avec le message : %s",$e->getMessage());
}
}
public function SetProduit(mysqli $id_con)
{
$id = $this->get_id();
$libelle = $this->get_libelle();
$reference = $this->get_reference();
$fabricant = $this->get_fabricant();
$qteStock = $this->get_qteStock();
$qteAllert = $this->get_qteAllert();
$unite = $this->get_unite();
$sql = "INSERT INTO produit VALUES ('$id','$libelle','$reference','$fabricant','$qteStock','$qteAllert','$unite')";
try
{
$result = $id_con->query($sql);
return $result;
}
catch (Exception $e)
{
printf("une erreur s'est produite avec le message : %s",$e->getMessage());
}
}
public function DeleteOneProduit($id,mysqli $id_con)
{
try
{
if(ctype_digit($id))
{
$sql = "DELETE FROM produit WHERE prd_id = '$id'";
$result = $id_con->query($sql);
return $result;
}
}
catch (Exception $e)
{
printf("une erreur s'est produite avec le message : %s",$e->getMessage());
}
}
|
On se rend bien compte en lisant les méthodes de cette classe que la logique est pratiquement la même :
- Dans un premier temps on écrit la requête SQL qui doit être exécutée ;
- Ensuite on l'exécute, via la méthode " query " de l'objet mysqli ;
- Enfin les résultats sont récupérés et traités en utilisant la méthode " fetch_assoc " de l'objet mysqli_result en vu d'être retourner sous le format souhaiter : un objet ou un itérateur.
IV-4. La classe MonIterateur
Il s'agit d'une classe qui implémente l'interface Iterator de PHP agissant sur les collections. Elle nous sera utile afin de parcourir la liste des enregistrements de notre table "produit"
via la méthode GetAllProduit de la classe "Produit".
class Moniterateur implements Iterator
{
private $result = null;
private $current = null;
private $key = 0;
protected $sql = null;
function __construct($sql,mysqli $con)
{
$this->result = $con->query($sql);
}
public function current()
{
return $this->current;
}
public function key()
{
return $this->key;
}
public function next()
{
$this->current = $this->result->fetch_assoc();
$this->key++;
}
public function rewind()
{
$this->result->data_seek(0);
$this->key = -1;
$this->next();
}
public function valid()
{
return is_array($this->current);
}
}
|
IV-5. La couche de traitement de la classe "Produit"
Maintenant nous allons créer un fichier ctrl.produit.php qui contient les codes nécessaires aux différents traitements qui seront effectués et qui concerne les produits.
Avant tout traitement, la méthode "connect" de connexion à la base de données est appelée et à la fin de chaque traitement, la méthode de déconnexion, "disconnect" est appelée.
Dans chaque partie il y est question d'un traitement spécifique appelant une méthode précise de la classe "Produit".
- $operation == new : ici le traitement à effectuer est l'enregistrement d'une nouvelle ligne dans la table "produit".
- $operation == update : ici le traitement c'est la mise à jour d'un enregistrement dans la table "produit".
- $operation == delete : ici le traitement c'est la suppression d'un enregistrement dans la table "produit".
include_once 'auto.php';
$cobj = new Connexion();
$operation = trim($_GET['action']);
if(isset($_GET['id'])&& ctype_digit($_GET['id']))
{
$id= trim($_GET['id']);
}
$mod = trim($_GET['mod']);
$id_con = $cobj->connect();
switch ($mod)
{
case "produit":
{
if($operation == 'update')
{
$prd = new Produit();
$prd->set_id($id);
$prd->set_fabricant(trim($_POST['fabricant']));
$prd->set_libelle(trim($_POST['nom_produit']));
$prd->set_qteAllert(trim($_POST['stock_allert']));
$prd->set_qteStock(trim($_POST['qte_stock']));
$prd->set_reference(trim($_POST['reference']));
$prd->set_unite(trim($_POST['unite']));
$result = $prd->UpdateProduit($id_con,$prd->get_id(),$prd->get_libelle(),$prd->get_reference(),$prd->get_fabricant(),
$prd->get_qteStock(),$prd->get_qteAllert(),$prd->get_unite());
$cobj->disconnect($id_con);
}
if($operation =='delete')
{
$prd = new Produit();
$result = $prd->DeleteOneProduit($id,$id_con);
$cobj->disconnect($id_con);
}
if($operation =='new')
{
$prd = new Produit();
$prd->set_fabricant(trim($_POST['fabricant']));
$prd->set_libelle(trim($_POST['nom_produit']));
$prd->set_qteAllert(trim($_POST['stock_allert']));
$prd->set_qteStock(trim($_POST['qte_stock']));
$prd->set_reference(trim($_POST['reference']));
$prd->set_unite(trim($_POST['unite']));
$result = $prd->SetProduit($id_con);
$cobj->disconnect($id_con);
}
break;
}
}
|
IV-6. Test de l'application
Nous allons maintenant utiliser les méthodes de notre classe "Produit" en vue d'illustrer de manière pratique ce que nous obtenons comme résultat.
IV-6-1. Insertion d'un nouvel enregistrement dans la table "produit"
Nous allons dans un premier temps créer un simple formulaire qui va nous permettre d'enregistrer les données dans la table "produit" on l'appelera "new_produit.php" .
Ensuite Nous allons enregistrer le produit Vitamine C via cette interface. Le code complet de ce formulaire est le suivant :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Nouveau Produit</title>
</head>
<body>
<div>
<form action="ctrl.produit.php?action=new&mod=produit" name="form_produit" id="form_produit" method="post" >
<fieldset>
<legend>
Gestion des Produits
</legend>
<table>
<tr>
<td><label>Nom Produit</label></td>
<td><input name="nom_produit" type="text" id="nom_produit"/></td>
</tr>
<tr>
<td><label>Fabricant</label></td>
<td><input name="fabricant" type="text" id="fabricant" /></td>
</tr>
<tr>
<td><label>Quantité en Stock</label></td>
<td><input name="qte_stock" type="text" id="qte_stock"/></td>
</tr>
<tr>
<td><label>Stock d'alerte</label></td>
<td><input name="stock_allert" type="text" id="stock_allert"/></td>
</tr>
<tr>
<td><label>Unité Produit</label></td>
<td><input name="unite" type="text" id="unite" /></td>
</tr>
<tr>
<td><label>Réference Produit</label></td>
<td><input name="reference" type="text" id="reference"/></td>
</tr>
<tr>
<td> </td>
<td> </td>
</tr>
<tr>
<td align="center"><input name="Enregistrer" type="submit" value="Enregistrer" /></td>
<td align="center"><input name="Annuler" type="reset" value="Annuler" /></td>
</tr>
</table>
</fieldset>
</form>
</div>
</body>
</html>
|
Et à l'execution, on obtient le résultat suivant :
Fig.1 enregistrement d'un nouveau produit
IV-6-2. Affichage des données de la table produit
Pour cela, nous allons utiliser un itérateur. Il s'agit d'une interface qui fournit un ensemble de méthodes permettant de passer en revue
une collection d'objet en utilisant l'opérateur foreach comme on le fait de manière classique pour un tableau.
Nous utiliserons pour notre cas l'itérateur Iterator : il possède les méthodes suivantes que nous avons redéfini dans la classe MonIterateur:
- current(): retourne l'élément courant de la collection ;
- key(): retourne la valeur de la clé de l'élément courant de la collection.
- next(): permet de se positionner sur l'élément suivant de la collection.
- rewind(): permet de se positionner sur le premier élément de la collection.
- valid(): permet de savoir si l'on a atteint la fin de la collection.
le code source complet de l'interface "liste produit" qui permet d'afficher sous forme de tableau la liste des produits présents dans la table "produit "
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Liste des Produits</title>
</head>
<body>
<?php
include_once 'auto.php';
$cobj = new Connexion();
$id_con=$cobj->connect();
$prd = new Produit();
$lst_prd = $prd->GetAllProduit($id_con,'ASC','prd_libelle');
?>
<table width="600" border="1" cellpadding="1" cellspacing="0">
<tr>
<th scope="col">Libelle</th>
<th scope="col">Fabricant</th>
<th scope="col">Unité</th>
<th scope="col">Quantité en stock</th>
<th scope="col">Stock d'allerte</th>
<th scope="col">Opération</th>
</tr>
<?php
foreach ($lst_prd as $prd)
{
echo(
"<tr>".
"<td><a href='update_produit.php?id=".$prd['prd_id']."'>".$prd['prd_libelle']."</a></td>".
"<td>".$prd['prd_fabricant']."</td>".
"<td>".$prd['prd_unite']."</td>".
"<td>".$prd['prd_qteStock']."</td>".
"<td>".$prd['prd_qteAllert']."</td>".
"<td><a href='ctrl.produit.php?action=delete&mod=produit&id=".$prd['prd_id']."'>Supprimer</td>".
"</tr>");
}
//deconnexion de la BD
$cobj->disconnect($id_con);
?>
</table>
</body>
</html>
|
Et à l'execution, on obtient le résultat suivant dans un navigateur :
Fig. 2 : liste des produits
|
On remarque bien la présence de notre nouvel enregistrement " vitamine c " à la dernière ligne de notre tableau.
|
IV-6-3. Details/Modification
Dans cette partie, nous allons maintenant créer une page permettant de voir les détailles et de modifier les données relatives à un produit donné.
Par la suite, nous modifierons notre produit vitamine C
Le code complet pour cette page est le suivant :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<title>Mise à jour Produit</title>
</head>
<body>
<div>
<?php
include_once 'config.class.php';
$id = trim($_GET['id']);
$cobj = new Config();
$id_con=$cobj->connect();
$prd = new Produit();
$ligne = $prd->GetOneProduit($id_con,$id);
?>
<form action="ctrl.produit.php?action=update&id=<?php echo $id;?>&mod=produit" name="form_produit" id="form_produit" method="post" >
<fieldset><legend>Mise à jour d'un Produit</legend>
<table>
<tr>
<td><label>Nom Produit</label></td>
<td><input name="nom_produit" type="text" id="nom_produit" value="<?php echo $ligne->get_libelle();?>"/></td>
</tr>
<tr>
<td><label>Fabricant</label></td>
<td><input name="fabricant" type="text" id="fabricant" value="<?php echo $ligne->get_fabricant();?>"/></td>
</tr>
<tr>
<td><label>Quantité en Stock</label></td>
<td><input name="qte_stock" type="text" id="qte_stock" value="<?php echo $ligne->get_qteStock();?>"/></td>
</tr>
<tr>
<td><label>Stock d'alerte</label></td>
<td><input name="stock_allert" type="text" id="stock_allert" value="<?php echo $ligne->get_qteAllert();?>"/></td>
</tr>
<tr>
<td><label>Unité Produit</label></td>
<td><input name="unite" type="text" id="unite" value="<?php echo $ligne->get_unite();?>"/></td>
</tr>
<tr>
<td><label>Référence Produit</label></td>
<td><input name="reference" type="text" id="reference" value="<?php echo $ligne->get_reference();?>"/></td>
</tr>
<tr>
<td> </td>
<td> </td>
</tr>
<tr>
<td align="center"><input name="Modiffier" type="submit" value="Modiffier"/></td>
<td align="center"><input name="Annuler" type="reset" value="Annuler" /></td>
</tr>
</table>
</fieldset>
</form>
</div>
</body>
</html>
|
Fig. 3 : détailles / modification d'un produit
IV-6-4. Suppression d'un enregistrement
La colonne opération du tableau de la liste des produits contient un lien permettant de supprimer un produit de notre base de données.
Ce lien pointe directement sur le fichier ctrl.produit.php dont nous avons parlé plus haut, et nous pouvons donc cliquer sur
celui-ci pour supprimer notre produit " vitamine C " de la base de données. En revenant à notre listing, on se rend bien compte comme le montre
la capture d'écran ci-dessous que ce produit n'existe plus dans notre liste.
Fig. 4 suppression d'un produit
V. Conclusion
Nous venons à travers cet article de voir comment accéder à Mysql en orienté objet grâce à l'extension mysqli ;
nous avons également pu effectuer des traitements grâce aux classes mysqli_stmt et mysqli_result et à leurs méthodes.
Désormais vous pouvez développer votre application PHP5 en adoptant une approche complètement orienté objet, même au niveau de l'accès aux données.
Cependant pour ceux qui ne sont pas encore familiarisés à l'approche orientée objet de PHP5 et veulent pouvoir tirer profit des avantages de l'extension mysqli,
ils peuvent dans ce cas opter pour l'approche procédurale de cette API ; cella pourrait d'ailleurs faire l'objet d'un article futur.
d'autre part, pour ceux qui se demande comment utilisé plutôt PDO il peuvent se reférer à l'article suivant de
Julien Pauli :
pdo
VI. Remerciements
Copyright © 2011 Mbella Demazy.
Aucune reproduction, même partielle, ne peut être faite
de ce site ni de l'ensemble de son contenu : textes, documents, images, etc.
sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à
trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.
