Developpez.com - PHP
X

Choisissez d'abord la catégorieensuite la rubrique :


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.

               Version PDF (Miroir)   Version hors-ligne (Miroir)

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 :


II. Prérequis

Pour une bonne compréhension de cet article vous devez comprendre les concepts suivants :


III. Les classes de l'extension Mysqli.

Mysqli possède les classes suivantes à l'origine de ces avantages :


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 :


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 :


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.

info 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 :

				--
				-- Base de données: `cabinet`
				--
				CREATE DATABASE `cabinet` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci;
				USE cabinet;
				-- --------------------------------------------------------
				
				--
				-- Structure de la table `produit`
				--
				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:

					
					//classe de connexion a la base de données
					
					class Connexion  extends mysqli
					{
					const HOST = 'localhost';
						const USER = 'root';
						const PASSWORD = 'laboratoire';
						const DATABASE = 'cabinet';
					
						public function connect()
						{
							//fonction permettant de ce connecter a la bd en utilisant l'extension mysqli
							//elle retourne l'objet de connexion
							try
							{
								$con = new mysqli(self::HOST,self::USER,self::PASSWORD,self::DATABASE);
								$con->set_charset("utf8"); //definition du jeu de caractère par defaut du client
								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)
						{
							//cette fonction, permet de ce déconnecter de la BD
							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 :

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()
							{
								//le constructuer de la classe produit
								$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()
							{
								//retourne l'id du produit courant.
								return  $this->prd_id;
							}
							public function set_id($id)
							{	//definit la valeur de l'id du produit
								$this->prd_id = $id;
							}
							
							public function get_libelle()
							{
								//retourne le libelle du produit courant
								return $this->prd_libelle;
							}
							public function set_libelle($libelle)
							{
								//defini le libelle du produit
								 $this->prd_libelle = $libelle;
							}
							
							public function get_reference()
							{
								//retourne la reference du produit courant
								return $this->prd_reference;
							}
							public function set_reference($reference)
							{
								//definila reference du produit courant
								 $this->prd_reference= $reference;
							}
							
							public function get_fabricant()
							{
								//retourne le fabricant du produit
								return $this->prd_fabricant;
							}
							public function set_fabricant($fabricant)
							{
								//defini le fabricant du produit
								 $this->prd_fabricant=$fabricant;
							}
							public function get_qteStock()
							{
								//retourne la quantité en stock
								return $this->prd_qteStock;
							}
							public function set_qteStock($qteStock)
							{
								//defini la quantité en stock
								 $this->prd_qteStock=$qteStock;
							}
							
							public function get_qteAllert()
							{	//retourne la quantité d'alerte
								return $this->prd_qteAllert;
							}
							public function set_qteAllert($qteAllert)
							{	//defini la quantité d'alerte
								 $this->prd_qteAllert = $qteAllert;
							}
							
							public function get_unite()
							{	//retourne l'unite
								return $this->prd_unite;
							}
							public function set_unite($unite)
							{	//retourne l'unite
								 $this->prd_unite = $unite;
							}
							
							public function GetOneProduit(mysqli $id_con,$id)
							{
								/*
								 * cette methode permet d'obtenir un tuple de la table produit à partir
								 * de son id et de l'id de connection à la bd
								 * elle retourne un objet produit
								 */
								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)
							{
								/*cette méthode permet d'obtenir la liste des produits da la base de données
								 * elle prend en entrée:
								 *  $id_con : l'objet de connexion a la base de donnée,
								 * 	$by : la collone suivant laquelle les resultats seront ordonnés
								 * 	$order : l'odre de tri des résultats : ASC ou DESC
								 * cette méthode retourne un itérateur de type Moniterateur
								 * */
								$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)
							{
								/*
								 * cette methode permet d'insérer un nouvel enregistrement 
								 * dans la table produit;
								 * en entrée on a l'identifiant de la connexion à la BD
								 */
								$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)
							{
								/*
								 * cette methode se charge de supprimer un tuple dans la table 
								 * produit identifié par son id
								 * en entrée on a :
								 * - l'id du produit à supprimer
								 * - l'identifiant de connexion à la BD
								 */
								
								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 :


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)
							{
								//le constructerur de la classe: il prend en entrée une requette sql
								//et un identifiant de connexion à la base de données mysql
								$this->result = $con->query($sql);
							}
							
							public function current() 
							{
								//retourne la valeur de l'élément courant de notre collection
								return $this->current;
							}
							
							public function key() 
							{
								//retourne la clé de lélément courant de notre collection
								return $this->key;
							}
							
						    public function next() 
							{
								//cette méthode retourne l'élément suivant de notre collection
								$this->current = $this->result->fetch_assoc();
					            $this->key++;
							}
							
							public function rewind() 
							{
								//on déplace le pointeur vers la première enregistrement de notre collection
								$this->result->data_seek(0);
								$this->key = -1;
								$this->next();
							}
							
							public function valid() 
							{
								//on teste si le résultat courrant est correcte: en d'autre terme s'il s'agit d'un tableau  
								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".


						##ce fichier représente la couche de traitement de la classe Produit
						
							include_once 'auto.php';//pour faire appel a la fonction autoload
						
							$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":
							{
								//gestion de ce qui concerne la table 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>&nbsp;</td>
												<td>&nbsp;</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 :

enregistrement d'un nouveau produit
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:

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();
							//connexion a la BD
						  $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 :

liste des produits
Fig. 2 : liste des produits
info 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 
//récupération de l'enregistrement a partir de son id 
include_once 'config.class.php';
$id = trim($_GET['id']);
$cobj = new Config();
//connexion a la BD
$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>&nbsp;</td>
<td>&nbsp;</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>						
détailles / modification d'un produit
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.

suppression d'un produit
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 :fr pdo


VI. Remerciements



               Version PDF (Miroir)   Version hors-ligne (Miroir)

Valid XHTML 1.0 TransitionalValid CSS!

Copyright © 2011 Mbella Demazy. Aucune reproduction, même partielle, ne peut être faite de ce site et 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.

Contacter le responsable de la rubrique PHP