[MySQL][ADOdB] Interaction classes ADOdB / classes personelles

Version imprimable

Bonjour,

je suis en train de développer une application PHP5/Mysql.
Je souhaiterais utiliser ADOdB pour l'abstraction.

Mon problème : comment faire intéragir ADOdB avec mes classes ?

Mon Code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 class Profil { private $id; private $nom; private $prenom; private $conn; public function __construct() { $this->conn = ADONewConnection('mysql'); $this->conn->PConnect(MYSQL_HOST, MYSQL_USER, MYSQL_PASS, MYSQL_BASE); } // methods for nom public function get_nom($id) { $sql = "SELECT `nom` FROM `table_users` WHERE `id` = '$id'"; $result = $this->conn->Execute($sql); return $result->fields['nom']; } // methods for prenom public function get_prenom($id) { $sql = "SELECT `prenom` FROM `table_users` WHERE `id` = '$id'"; $result = $this->conn->Execute($sql); return $result->fields['prenom']; } }
Ma question :
Est-ce que je suis la bonne route ?
Chaque constructeur de mes classes est ADONewConnection, vais-je avoir autant de connexions à la base que d'objet ? Est-ce la bonne méthode ?

Merci d'avance pour votre aide...

Salut,

de la même manière que si tu utilisais PDO, passe par un singleton.

Si tu ne connais pas, cela consiste à créer une méthode static qui vas nous retourner un objet. Dans ce cas un objet ADODB. Ce qui est bien dans cette méthode c'est qu'elle vas s'assurer de n'instancier cet objet qu'une et une seule fois.

Voici la classe que j'utilise pour faire un singleton de PDO, que j'utilise à la place d'ADODB.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 <? ////////////////////////////////////////////////////////// /// \class dp /// Singleton de la classe PDO ////////////////////////////////////////////////////////// class dp { ////////////////////////////////////////////////////////// // Prorpiétés du singleton ////////////////////////////////////////////////////////// public static $host; public static $db; public static $user; public static $mdp; private static $instance; ////////////////////////////////////////////////////////// /// constructeur ////////////////////////////////////////////////////////// private function __construct() { } ////////////////////////////////////////////////////////// /// Singleton ////////////////////////////////////////////////////////// public static function inst() { if( self::$instance == NULL) { self::$instance = new PDO("mysql:host=".self::$host.";dbname=".self::$db."", self::$user, self::$mdp ); self::$instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); } return self::$instance; } } ?>
Pour m'en servir, j'attribue les propriétés de connexion à la bdd dans ma classe d'initialisation.
Sa ressembleà cela :
Code:

1 2 3 4 dp::$host = "localhost"; dp::$db = "ma_bdd"; dp::$user = "*******"; dp::$mdp = "******";
Enfin pour m'en servir, dans mes objets je fais ainsi :
Code:

1 2 3 4 5 $sql = "SELECT * FROM editions WHERE id = :id"; $stmt = dp::inst()->prepare( $sql ); $stmt->bindParam(':id', $id , PDO::PARAM_INT );
Le fais d'appeller la métode inst de la classe dp, vas instancier et ouvrir la connection si ce n'est pas déja fait. Puis me retourner un objet PDO. Sur lequel j'appel la méthode prepare.
De cette manière je suis certain de n'avoir qu'une connection simultanée. De plus je n'ai pas à me soucier de l'ouverture de la bdd, quel que soit l'objet utilisé, la connection sera ouverte si besoin.

Mon exemple est tourné vers PDO, mais tu peux en faire autant avec ADODB.

voila,
bye

Citation:

Envoyé par kaymak

De cette manière je suis certain de n'avoir qu'une connection simultanée. De plus je n'ai pas à me soucier de l'ouverture de la bdd, quel que soit l'objet utilisé, la connection sera ouverte si besoin.

Tout d'abord désolé de ne pas avoir répondu plus tôt, j'étais parti en vacances.

J'ai implémenté le Design Pattern Singleton comme tu me l'avais recommandé :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
class Singleton {
	public static $host;
	public static $db;
	public static $user;
	public static $mdp;
	private static $instance;
 
	private function __construct() {
	}
 
	public static function GetInstance() {
		if (!isset(self::$instance)) {
			self::$instance = ADONewConnection('mysql');
			self::$instance->PConnect(MYSQL_HOST, MYSQL_USER, MYSQL_PASS, MYSQL_BASE);
			self::$instance->SetFetchMode(ADODB_FETCH_ASSOC); 
		}
 
		return self::$instance;
	}
}

J'ai également une classe DAO_User pour me connecté à la base et récupérer les infos d'un user :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
class DAO_User extends Singleton {
	private static $instance = NULL;
 
	public function __construct() {
	}
 
	public static function & get_instance(&$da) {
		if (self :: $instance == NULL) {
			self :: $instance = & new DAO_user(& $da);
		}
		return self :: $instance;
	}
 
	public function & load_by_id($id) {
		$sql = "SELECT `id`, `nom`, `prenom`, `initiales`, `pseudo`, `password`, `email`, `msn`, `telephone`, `voiture` FROM `table_users` WHERE `id` = '$id'";
		$result = Singleton::GetInstance()->Execute($sql);
 
		$user = new User();
		$user->set_nom($result->fields['nom']);
		$user->set_prenom($result->fields['prenom']);
		return $user;
	}
}

et une classe User pour créer/récupérer les infos d'un objet User :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
class User {
	private $id;
	private $nom;
	private $prenom;
 
	public function __construct() {
	}
 
	// DAO calls
	public static function & load_by_id($id) {
		$da = Singleton :: GetInstance();
		$daovar = & DAO_user :: get_instance(& $da);
		$usr = & $daovar->load_by_id($id);
		return $usr;
	}
 
	// methods for nom
	public function get_nom() {
		return $this->nom;
	}
	public function set_nom($nom) {
		$this->nom = $nom;
	}
 
	// methods for prenom
	public function get_prenom() {
		return $this->prenom;
	}
	public function set_prenom($prenom) {
		$this->prenom = $prenom;
	}
 
}

pour afficher les informations :

Code:

1
2
3
4
5
6
 
$O_DAO_user = new User();
$O_user = $O_DAO_user->load_by_id('1');
 
echo $O_user->get_nom();
echo $O_user->get_prenom();

Ma question : suis-je sur la bonne voie ? Voyez vous des erreurs dans mes classes ?

Merci d'avance...

Salut,

Nétant pas adepte de la méthode utilisant les classes de DAO je laisserai d'autres personnes plus avisés que moi sur ce sujet te répondre.

Cependant, je n'ai pas compris l'héritage que tu as effectué entre la classe de singleton, et la classe DAO_User.
Aussi pourquoi avoir nommé ta classe de connexion à la base de donnée Singleton ?
La question peut sembler un peu idiote, mais ta classe n'est pas une classe de singleton, c'est une classe qui créé des connexions à des bases de données en utilisant le pattern singleton.

Aussi au lieu de passer par des pérénigrations impossible dans la méthode User::load_by_id, pourquoi ne pas avoir tous simplement utiliser des méthodes static pour la classe de DAO_User ????
La classe de DAO_User comme je la voit actuellement n'à a priori aucune raison d'être instancier.

voila comme je voit chose.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 interface IDao { public static function construireDePuisTuple( $resultat ); } class DAO_User implements IDao { private function __construct() { } public static function load_by_id($id) { $sql = "SELECT `id`, `nom`, `prenom`, `initiales`, `pseudo`, `password`, `email`, `msn`, `telephone`, `voiture` FROM `table_users` WHERE `id` = '$id'"; $result = Singleton::GetInstance()->Execute($sql); return self::construireDePuisTuple( $result ); } public static function construireDePuisTuple( $resultat ) { $user = new User(); $user->set_nom($resultat->fields['nom']); $user->set_prenom($resultat->fields['prenom']); return $user; } }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 class User { private $id; private $nom; private $prenom; public function __construct() { } // DAO calls public static function & load_by_id($id) { $usr = DAO_user::load_by_id($id); return $usr; } // methods for nom public function get_nom() { return $this->nom; } public function set_nom($nom) { $this->nom = $nom; } // methods for prenom public function get_prenom() { return $this->prenom; } public function set_prenom($prenom) { $this->prenom = $prenom; } }
L'interface, c'est pour faire jolie, donner un peu de structure à tes classes de DAO. A toi de te pencher sur le problème pour lui donner une véritable raison d'exister.

Sinon j'ai ajouté une méthode construireDepuisTuple, car c'est le genre de chose que l'on peut factoriser facilement, et qui ne seront pas des freins à l'avenir.

En ce qui conerne la méthode User::load_by_id, comme tu peux le constater elle est beaucoup plus simple.

Autrement en PHP5, il est strictement inutile de continuer d'utiliser les éperlouette &&&.

Sinon, par simple curiosité, pourquoi utiliser ADODB alors qu'en PHP5 PDO est disponible ?

bye

06/03/2007, 21h21
Looping2605

Citation:

Envoyé par kaymak

Sinon, par simple curiosité, pourquoi utiliser ADODB alors qu'en PHP5 PDO est disponible ?

Je développe en PHP4 depuis 3 ans mais jamais en POO. Je commence a me documenter sur la POO donc sur PHP5.
Je développe en local sur PHP5 mais en serveur pour l'instant je n'ai que Free donc je ne sais pas si PDO est accessible sur ces serveurs vu qu'on ne peux pas modifier php.ini

Tu conseilles vraiment PDO ?
06/03/2007, 21h37
kaymak

Je ne le conseille pas particulièrement, je demandais ; )
Je ne connias pas particulièrement ADODB, je me demandais quel était l'intéret d'utiliser cette solution vis-à-vis de PDO qui est le standard pour PHP désormais.
07/03/2007, 20h18
Looping2605
Citation:

Envoyé par kaymak

Salut,
Nétant pas adepte de la méthode utilisant les classes de DAO je laisserai d'autres personnes plus avisés que moi sur ce sujet te répondre.

Cependant, je n'ai pas compris l'héritage que tu as effectué entre la classe de singleton, et la classe DAO_User.

En fait je ne sais pas si je me suis bien fais comprendre.
Voila ce que j'ai à l'esprit :
1. Récupérer par exemple les informations d'un utilisateur.
2. Créer un objet avec ses informations.
  $O_DAO_user = new User();
  $O_user = $O_DAO_user->load_by_id('1');
3. Dans la page affichée dans le navigateur n'avoir plus qu'a faire $user->get_nom() pour récupérer le nom, $user->get_prenom() pour récupérer le prénom, et ainsi de suite sans utiliser de boucles...
  echo $O_user->get_nom();
  echo $O_user->get_prenom();
Ce que je cherche à éviter c'est d'avoir 5 requetes pour récupérer 5 informations sur un user, et d'avoir a ecrir 30 lignes pour récupérer juste le nom du user par exemple.

Je viens de regarder à PDO je vais utiliser cette solution car elle est native PHP5. Mais je ne trouve aucun tutoriel sur le web répondant à mon problème.

En tout cas merci à toi de t'occuper de moi ;)

Salut,

Effectivement je pense qu'il y à une incompréhension dans l'air... Mais je ne voit pas encore laquelle.

Quoi qu'il en soit l'exemple que je t'ai présenté est capable, de faire ce que tu décris. Tout comme ce que tu avais présenté. Cependant, j'ai ré écrit une partie de ton code, car j'avais le sentiment que tu t'etait un peu perdu en route avec ces histoires de singleton ect.

Dans le code que je t'ai présenté, l'idée était de faire cela pour instancier un user :

Code:

$MyUser = User::load_by_id($id);

Citation:

Ce que je cherche à éviter c'est d'avoir 5 requetes pour récupérer 5 informations sur un user, et d'avoir a ecrir 30 lignes pour récupérer juste le nom du user par exemple.

Justement moi aussi je suis plutot faineant. C'est en partie pour cela que j'ai évoqué l'idée d'une méhode construireDepuisTuple.
Avec cet exemple particulier si je reprend la class DAO_User, et que je souhaite ajouter une méthode lireParNom, sa donnerait ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 class DAO_User implements IDao { private function __construct() { } public static function load_by_id($id) { $sql = "SELECT `id`, `nom`, `prenom`, `initiales`, `pseudo`, `password`, `email`, `msn`, `telephone`, `voiture` FROM `table_users` WHERE `id` = '$id'"; $result = Singleton::GetInstance()->Execute($sql); return self::construireDePuisTuple( $result ); } public static function load_by_name($name) { $sql = "SELECT `id`, `nom`, `prenom`, `initiales`, `pseudo`, `password`, `email`, `msn`, `telephone`, `voiture` FROM `table_users` WHERE `nom` = '$name'"; $result = Singleton::GetInstance()->Execute($sql); return self::construireDePuisTuple( $result ); } public static function construireDePuisTuple( $resultat ) { $user = new User(); $user->set_nom($resultat->fields['nom']); $user->set_prenom($resultat->fields['prenom']); return $user; } }
La méthode se concentre sur sa spécifité. Le reste est générique.
Il existe des solutions plus poussée, mais elles sont aussi plus compliquées à maintenir en cas de bug. Elle requiert aussi plus de commpétences...

Citation:

Je viens de regarder à PDO je vais utiliser cette solution car elle est native PHP5. Mais je ne trouve aucun tutoriel sur le web répondant à mon problème.

PDO, tout comme ADODB, ne fait pas cela.
En réalité si..... mais au départ il à été créé pour disposer d'une méthode d'accès commune à différentes sources de données. Tout comme ADODB !

PDO, peut réaliser une partie du boulot d'attribution des données dans des objets en spécifiant la méthode de retour des résultats.
Mais comme cette méthode me parait terriblement obscure, et assez peu flexible je ne m'en suis jamais servit.

Pour faire cela avec PDO il faut appeler la méthode setFetchMode qui possède cette signature

Code:

bool PDOStatement::setFetchMode ( int PDO::FETCH_INTO, object object )

cf http://www.php.net/manual/fr/functio...tFetchMode.php

Donc PDO peut être utilisé comme couche de DAO. Mais il a ces limites.
Enfin tout comme ADODB il peut être utilisé pour n'être qu'une méthode d'accès standard à différentes sources de données dans une appli utilisant une couche DAO, ou pas.

voila en esperant ne pas avoir répondu trop à coté,
bye

Citation:

Envoyé par kaymak

Donc PDO peut être utilisé comme couche de DAO. Mais il a ces limites.
Enfin tout comme ADODB il peut être utilisé pour n'être qu'une méthode d'accès standard à différentes sources de données dans une appli utilisant une couche DAO, ou pas.

voila en esperant ne pas avoir répondu trop à coté,

Je viens de regarder un peu à PDO et voici ce que j'ai mis en place suite à tes conseils :

PDO_MySQL

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
<?php
require_once (dirname(__FILE__) . '/../admin/config.php');
 
class PDO_MySQL {
	private static $instance;
 
	private function __construct() {
	}
 
	public static function GetInstance() {
		if( self::$instance == NULL) {
			self::$instance = new PDO("mysql:host=" . MYSQL_HOST . ";dbname=" . MYSQL_BASE . "", MYSQL_USER, MYSQL_PASS);							
			self::$instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
		}
		return self::$instance;
	}
}
?>

PDO_User

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
<?php
require_once (dirname(__FILE__) . '/PDO_MySQL.php');
 
class PDO_User extends PDO_MySQL {
	private $nom;
	private $prenom;
 
	private function __construct() {
	}
 
	// Methode pour construire un objet PDO_User
	public static function ConstruireObjet($result) {
		$user = new PDO_User();
		$user->set_nom($result['nom']);
		$user->set_prenom($result['prenom']);
 
		return $user;
	}
 
 
	// Methodes pour le nom
	public function set_nom($nom) {
		$this->nom = $nom;
	}
 
	public function get_nom() {
		return $this->nom;
	}
 
 
	// Methodes pour le prenom
	public function set_prenom($prenom) {
		$this->prenom = $prenom;
	}
 
	public function get_prenom() {
		return $this->prenom;
	}
 
 
	// Methode
	public static function load_by_id($id) {
		$sql = "SELECT `id`, `nom`, `prenom`, `initiales`, `pseudo`, `password`, `email`, `msn`, `telephone`, `voiture` FROM `table_users` WHERE id = :id";
		$instance = PDO_MySQL::GetInstance()->prepare($sql);
		$instance->bindParam(':id', $id, PDO::PARAM_INT);
		$instance->execute();
 
		$result = $instance->fetch(PDO::FETCH_ASSOC);
 
		return self::ConstruireObjet($result);
	}
}
?>

Penses-tu que je suis enfin dans le bon chemin ?

En tout cas merci pour ton dévouement !

12/03/2007, 21h39
kaymak

Salut,

Citation:

Penses-tu que je suis enfin dans le bon chemin ?

C'est très subjectif sa : )
Mais bon le code que tu présentes est clair, simple à maintenir est exprime clairement ce que la classe réalise.
Donc de ce point de vue là moi j'aime beaucoup. C'est d'ailleurs très ressemblant à ce que j'écrit habituellement.

Maintenant je regrette un peu de pas avoir eu plus d'avis de personnes qui utilise la couche de DAO... Pour contre balancer mes propos.

Citation:

En tout cas merci pour ton dévouement !

Bah écoutes ... avec plasir ; )

bye
12/03/2007, 21h43
Looping2605

Merci pour tout...

Citation:

Envoyé par kaymak

Maintenant je regrette un peu de pas avoir eu plus d'avis de personnes qui utilise la couche de DAO... Pour contre balancer mes propos.

Je le regrette aussi. Pourtant je suis sur que beaucoup de personnes utilise une couche DAO...