Classe de connexion à une base de donnée mysql

Soyez le premier à donner votre avis sur cette source.

Snippet vu 27 473 fois - Téléchargée 19 fois

Contenu du snippet

Voila c'est la toute premiere source que je poste, j'ai fait cette classe pour commencer la programmation objet en PHP, j'ai voulu respecter le design pattern Singleton. J'aimerais avoir le maximum d'avis sur le code ( proposez des optimisations possible, me signaler des maladroitesses de programmation) et sur la conception (respect du Singleton, utilisation de la notion d'objets).
Je penseque le code est assez documenté mais si vous avez des questions n'hesitez pas à meles posez.
Merci
Zefyre

Source / Exemple :


<?php
/*
 *

  • Auteur: Zefyre
*
  • Fichier: connexion.php
*
  • Date: 24 mar. 07
*
  • /
class Connexion { /**
  • *La classe Connexion permet lors d'une instanciaction de créer une connexion a une base de données, à partir d'un nom d'hote(serveur), un nom d'utilisateur et d'un mot de passe de selecionner la base d'étude et de détruire la connexion. Pour s'assurer qu'une seule connection est établie à la base on déclare le constructeur de la classe privé et l'unique facon de créer un objet et d'utiliser la seule méthose public getConnection qui verifie l'unicité de la connection ce schema s'inspire du pattern Singleton dessiné en uml:
  • /
/* |+++++++++++++++++++| | Singleton | |+++++++++++++++++++| | -instance: | | Connection | | (static) | | | |+++++++++++++++++++| | -Singleton() | | +getInstance() | | (static) | |+++++++++++++++++++|
  • /
/**
  • Une connection est definie par:
  • -Un identifiant de connexion (id)
  • -Un nom de serveur (host)
  • -Un nom d'utilisateur (user)
  • -Un mot de passe (pass)
  • -Une base visée (base)
  • -Une instance de Connexion (instance)
*
  • /
/**
  • *L'identifiant de connexion
  • /
private $id; /**
  • *Le nom d'hote
  • /
private $host; /**
  • *Le nom d'utilisateur
  • /
private $user; /**
  • *Le mot de passe
  • /
private $pass; /**
  • *Le nom de de la base d'etude
  • /
private $base; /**
  • *Une instance static de Connexion
  • /
private static $instance; /**
  • *Constructeur de la classe Connexion
  • /
private function __construct($host, $user, $pass, $base) { $this->setHost($host); //Les differents setter $this->setUser($user); //Methodes permettant l'acces en erciture des variables $this->setPass($pass); $this->setBase($base); try { $this->id = $this->connect($this->host, $this->user, $this->pass); } //Tentative de connexion à la base catch (Exception $e) { // Gestion de l'exception header("Location:./erreur.php?erreur='" . $e->getMessage() . "'&code='1'"); //Redirection et affichage du message, du fichier et de la ligne d'origine de l'exception // DEBUGAGE echo $e->getMessage().'<br>Fichier: '.$e->getFile().'<br>Ligne: '.$e->getLine(); } try { $this->selection($base, $this->id); } //Tentative de selection de la base catch (Exception $e) { header("Location:./erreur.php?erreur='" . $e->getMessage() . "'&code='1'"); // DEBUGAGE echo $e->getMessage().'<br>Fichier: '.$e->getFile().'<br>Ligne: '.$e->getLine(); } } /**
  • *Permet de modifier la valeur de la variable host
  • /
private function setHost($host) { if (!isset($host)) // test si lavariable est initialisé header("Location:./erreur.php?erreur='serveur_vide'&code='1'"); //Si non -> redirection else $this->host = $host; //Si oui affectation } /**
  • *Permet de modifier la valeur de la variable user
  • /
private function setUser($user) { if (!isset($user)) header("Location:./erreur.php?ereur='user_vide'&code='1'"); else $this->user = $user; } /**
  • *Permet de modifier la valeur de la variable pass
  • /
private function setPass($pass) { if (!isset($pass)) header("Location:./erreur.php?erreur='pass_vide'&code='1'"); else $this->pass = $pass; } /**
  • *Permet de modifier la valeur de la variable base
  • /
private function setBase($base) { if (!isset($base)) header("Location:./erreur.php?erreur='base_vide'&code='1'"); else $this->base = $base; } /**
  • *Permet de selectionner une base
  • /
private function selection ($base, $db) { $ret = mysql_select_db($base, $db); //fonction de selection PHP if (isset($ret) && empty($ret)) // Test si le code de retour de la fonction est existant et vide throw new Exception("selection_base_impossible"); //Gestion de l'erreur return $ret; } /**
  • *Permet de se connecter a la base de données MySQL
  • /
private function connect($host, $user, $pass) { $ret = mysql_connect($host, $user, $pass) or die(); //fonction de connexion a la base if (isset($ret) && empty($ret)) throw new Exception("connexion_base_impossible"); return $ret; } /**
  • *Permet d'obtenir une instance de Connection
  • /
public static function getConnexion($host, $user, $pass, $base) { if ((!isset($instance))) // Si aucune instance de Connexion $instance = new Connexion($host, $user, $pass, $base); //Alors on en créer une return $instance; //Dans tous les cas on retourne une instance (soit la nouvelle soit l'existante) } /**
  • *Execute une requete SQL qui ne ne retourne aucun resultat (INSERT,UPDATE,DELETE).
  • /
public function execute($requete) { if (!isset($this->id) && empty($this->id)) // Test si une connexion existe si elle n'existe pas $this->getConnexion($host, $user, $pass, $base); //on essaye dans créer une. else { if (!isset($requete) && empty($requete)) header("Location:./erreur.php?erreur='requete_invalide'&code='1'"); else { try { mysql_query($requete) or die("Erreur" . mysql_error()); } catch(Exception $e) { header("Location:./erreur.php?erreur='requete_impossible'&code='1'"); } } } } /**
  • *Retourne le nombre de lignes affectées par la dernière opération SQL.
  • /
public function getNbLignes() { if (!isset($this->id) && empty($this->id)) // Test si une connexion existe si elle n'existe pas $this->getConnexion($host, $user, $pass, $base); //on essaye dans créer une. else return mysql_affected_rows($this->id); //On retourne le nombre de lignes } /**
  • *Retourne le resultat brut d'une selection
  • /
public function select($req) { if (!isset($this->id) && empty($this->id)) // Test si une connexion existe si elle n'existe pas $this->getConnexion($host, $user, $pass, $base); //on essaye dans créer une. else { if (!isset($req) && empty($req)) header("Location:./erreur.php?erreur='requete_invalide'&code='1'"); else { try { $resultat = mysql_query($req);; } catch(Exception $e) { header("Location:./erreur.php?erreur='requete_impossible'&code='1'"); } return $resultat; } } } /**
  • *Destructeur de la classe Connection
  • /
public function __destruct() { if ( !isset($this->instance) && empty($this->instance)) //On ne détruit l'instance que si elle existe { try { mysql_close($this->id); } catch(Exception $e) { header("Location:./erreur.php?erreur='fermeture_impossible'&code='1'"); } } else header("Location:./erreur.php?erreur='fermeture_impossible'&code='1'"); } } ?>

A voir également

Ajouter un commentaire

Commentaires

Messages postés
3
Date d'inscription
dimanche 25 janvier 2009
Statut
Membre
Dernière intervention
30 juillet 2012

voici mon code

<?php
class Mysql
{
var $login;
var $pass;
var $serveur;
var $base;
var $connexion;

function __construct()
{
$this->login = "root";
$this->pass = "";
$this->serveur = "localhost";
$this->base = "festayresdatabase";
$this->connecter();
}

function connecter()
{
/* se connecter */
$this->connexion = mysql_connect($this->serveur, $this->login, $this->pass) or die ("Connexion impossible");
mysql_select_db($this->base, $this->connexion) or die ("Base introuvable");

}
?>
Messages postés
3
Date d'inscription
dimanche 25 janvier 2009
Statut
Membre
Dernière intervention
30 juillet 2012

bonjour a vous , je suis un debutant en php5 et je voudrais faire ma classe de connexion Mysql pour interagir avec d'autre classe . merci de m'indiquer comment je pourrais proceder pour la premiere fois
Messages postés
1
Date d'inscription
mardi 5 octobre 2010
Statut
Membre
Dernière intervention
20 juillet 2011

ce sujet est un peut vieux mais bon pas grâve !

comme le dit web2004 ta classe n'est pas un sigleton car elle retourne plusieurs instances de la classe

pour arranger ceci ( ça peut servir on sais jamais ! ) juste remplacer

if ((!isset($instance))) // Si aucune instance de Connexion
$instance = new Connexion($host, $user, $pass, $base); //Alors on en créer une
return $instance; //Dans tous les cas on retourne une instance (soit la nouvelle soit l'existante)

par :

if (!isset(self::$instance)) {
$c = __CLASS__;
self::$instance = new $c($host, $user, $pass, $base);
}
return self::$instance;

et ça marche comme un charme !
Messages postés
12
Date d'inscription
vendredi 6 février 2004
Statut
Membre
Dernière intervention
27 janvier 2009

c'est bien beau mais ton singleton ne fonctionne pas correctement !!! il insctancie plusieurs fois meme lorsque ton objet existe déja !!! je suppose que tu t'en es rendu compte sinon suffit de tester cette boucle pour s'en apercevoir :
$sql = Connexion::getConnexion('localhost','root','','em');
for($i=0; $i<10; $i++) {
$cnx = Connexion::getConnexion('localhost','root','','em');
echo '';
var_dump($cnx);
echo '

';
}

pour plus de lisiblité ajouter un message "instance n'existait pas" et "instance existait déja" dans ta méthode getConnextion tu verras mieux.

bonne continuation
Messages postés
6
Date d'inscription
dimanche 8 août 2004
Statut
Membre
Dernière intervention
26 avril 2011

Bonjour et meilleurs voeux. Je mets tout doucement à la POO et j'aurai aimer savoir à quoi sert concrètement une classe de connexion. Qu'est-ce qui la diffère d'une connexion procédurale et si une âme charitable pouvait m'éclairer via un exemple d'utilisation comme par exemple l'authentification via login et mot de passe qui serait issue d'une classe utilisateur avec l'utilisation des sessions. C'est jouable ? Merci de votre aide. Cordialement, aeterna.
Afficher les 12 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.