Discussion :

[Looping2605]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

[kaymak]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Looping2605]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

[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.
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Looping2605]

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 ?

[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.

[Looping2605]

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

[kaymak]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

 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