Discussion :

[dancom5]

Bonjour.

Je ne sais pas si je suis vraiment au bon endroit, j'expose quand même.

J'ai une requête qui utilise PDO, et je veux faire une Class avec les éléments suivants:

Mon code, c'est du procédural, mais j'aimerais penser objet et je souhaiterais ne pas faire
quelque chose de compliqué dans le but de cerner la chose.
Je comprends le principe d'une class, attribut, méthode et l'instance.

Code :

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

1
2
3
4
5
6
7
8
9
10
<?php
    $pdo = new PDO('mysql:host=127.0.0.1;dbname=ptg', 'root', '');
    $id = '2';
    $stmt = $pdo->prepare('SELECT * FROM artistes WHERE id = :id');
    $stmt->bindParam(':id', $id, PDO::PARAM_INT);
    $stmt->execute();
    foreach($stmt->fetchAll(PDO::FETCH_OBJ) as $t){
    echo $t->id;
    }
?>

J'aimerais un exemple. Merci.

[Dendrite]

D'abord, tu peux faire du PDO juste pour gérer tes connexions en ne faisant par ailleurs que du procédural, pas grave du tout.
Mais si tu veux vraiment développer orienté objet, l'idée serait la suivante :

Tu crées une classe Artiste avec tous les attributs et les méthodes qui vont bien.
Ici, c'est un modèle logique, totalement abstrait, pas de connexion aux bases. Juste tes règles de gestion en quelque sorte.

Tu crées une seconde classe, du genre Artiste_manager, qui prend pour paramètre un objet de connexion PDO (et ne le mets surtout pas en propriété, mais passe le en paramètre dans toutes tes fonctions, car si un jour tu veux mettre ton objet en session... il n'acceptera pas qu'un objet PDO soit mis en session).

C'est Artiste_Manager (lol, le jeu de mot involontaire) qui à la fois instanciera Artiste, l'hydratera, et gèrera toute la partie persistence (dialogue avec les bases).

Exemple dans le script final :

Code :

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

1
2
3
4
5
6
7
8
9
$monPdo=new PDO ('blabla');
$AM=new Artiste_Manager($monPdo,54);
$AM->creeAlbum($monPdo,'Hits de ouf');
$AM->modifSalaire($monPdo,'cat_A');
 
//etc...
 
$AM=NULL;
$monPdo=NULL;

Voilà, en espérant que ça t'aide...

[dancom5]

Merci pour Dendrite, mais, j'ai pas vraiment compris votre solution.

Ce que je vois en équivalence, c'est 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
<?php 
class Artistes{
    private $id;
    public function __construct(){
    }
    public function afficher($id){
      $pdo = new PDO('mysql:host=127.0.0.1;dbname=ptg', 'root', '');
      $stmt = $pdo->prepare('SELECT * FROM artistes WHERE id = :id');
      $stmt->bindParam(':id', $id, PDO::PARAM_INT);
      $stmt->execute();  
      return $stmt->fetchAll(PDO::FETCH_OBJ);
    }
}
$a =new Artistes();
$oa = $a->afficher(2);
foreach($oa as $t){
  echo $t->nom;
}
?>

J'ai beaucoup à faire. Ma connexion PDO devrait se trouver dans une autre classe.
A part, cela, la fonction afficher semble correcte à la base?

[dancom5]

J'ai fait de quoi de mieux mais j'aimerais rendre moins répétitif dans la méthode constructeur.

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
41
42
43
44
45
46
47
48
49
50
<?php
$dnsh = "mysql:host=localhost;dbname=ptg";
$user = "root";
$pass = "";
 
class dbcon
{
  private static $_instance;
  public static function pdo_connection($dnsh, $user, $pass)
  {
    if (!self::$_instance)
    {
      self::$_instance = new PDO($dnsh, $user, $pass);
      self::$_instance->setAttribute(PDO::ATTR_PERSISTENT,true);
      self::$_instance->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
    }
    return self::$_instance;
  }
  private function __construct(){}
  private function __clone(){}
}
 
 
 
 
class artiste
{
    private $_conn;
    public function __construct($dnsh,$user,$pass)
    {
    $this->_conn = dbcon::pdo_connection($dnsh,$user,$pass);
    }
 
    public function lister()
    {
        $stmt = $this->_conn->query("SELECT * FROM artistes WHERE id=2");
        $rows = $stmt->fetchAll(PDO::FETCH_OBJ);
        return $rows;
    }
}
 
 
$oArtiste = new artiste($dnsh,$user,$pass);
$aListeArtistes = $oArtiste->lister();
 
foreach($aListeArtistes as $artiste) 
{
  echo $artiste->nom;
}
?>

Ma partie constructeur de ma classe artiste, va-t-il falloir que je mette cela à toutes mes
classes? Y a pas moyen de le mettre une seule fois genre dans "dbcon" et comme argument l'instanciation artiste?

Pour chaque class, je peux mettre autant de functions que je veux, comme des functions delete, update, etc.

[MaitrePylos]

Quoi que tu fasses, il te faudra renseigner la connexion vers ta db.

Alors soit tu le fais via un fichier de configuration ou via des defines ou à l'instanciation, il te faudra le noté quelque part.

Après tu as pleins de solution.

Perso j'ai une préférence de passer par un Registre, mais cela reste une question de goùt, tu peux aussi mettre des variables Global.

ou simplement dans ta classe db comme tu le fais

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
 
<?php
 
 
class dbcon
{
 
  $dnsh = "mysql:host=localhost;dbname=ptg";
 $user = "root";
 $pass = "";
 $db = null;
 
 
  public function __construct(){
  $this->db = new PDO($dnsh, $user, $pass);
 
}
 
}

Ensuite dans ta class artiste tu appel ta classe de connexion

Code :

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

1
2
3
4
5
6
7
8
 
class artiste
{
    private $_conn;
    public function __construct(dbcon $connexion)
    {
    $this->_conn = $connexion->db ;
    }

et tu l'instancie en même temps que ta classe artiste

Code :

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

1
2
 
$a =new artiste(new dbcon());

Il y a pleins de façon de faire.

[Spartacusply]

La méthode que j'aime bien, par héritage, ça permet de bien restreindre l'utilisation de la BD que là où elle doit être utilisé :

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
class BD {
 
    private $db;
 
    public function __construct() {
        $this->db = new PDO($dnsh, $user, $pass);
    }
 
    protected function query($query) {
        return $this->db->query($query);
    }
 
}
 
class artiste extends BD {
 
    public function lister() {
        $stmt = $this->query("SELECT * FROM artistes WHERE id=2");
        $rows = $stmt->fetchAll(PDO::FETCH_OBJ);
        return $rows;
    }
 
}

[rawsrc]

@Spartacusply

Sûrement pas !! Tout ce que tu veux sauf l'héritage.
C'est une grossière erreur : l'héritage fonctionnel est à bannir.
Tiens un peu de lecture : http://blog.developpez.com/rawsrc/p1...es_classes_poo

[Tsilefy]

Je plussoie. D'ailleurs, en règle générale, à chaque fois que le choix se pose, préférer la composition et les interfaces à l'héritage.

[Spartacusply]

Non je maintiens ce que j'ai dit, mais je peux préciser mon propos : disons qu'ici la classe artiste ne devrait pas s'appeler "artiste" mais "ArtisteDAO" (comme DataAccessObject) par exemple. Ces deux classes se doivent bien d'être deux classes distinctes. Ici, "artiste" n'est pas la représentation d'une entité de la table Artiste, mais bien la classe qui permet d'accéder à la table artiste dans la base de données (lister, mettre à jour, etc...). A partir de là, cette classe peut parfaitement hériter de "BD" (ou "DAO" même pour être le plus cohérent possible), elle hérite des fonctionnalités permettant d'accéder à la base de données. Si on veut implémenter totalement une ORM, cette classe pourrait renvoyer des objets de type "Artiste", qui eux serait vraiment la représentation d'une entité Artiste (et qui bien sur n'hériterait en aucun cas de "DAO").

[rawsrc]

Oui, tu aurais dû être d'emblée beaucoup plus précis et renvoyer sur la théorie du Pattern DAO.

M'est d'avis que ça va dépasser les besoins de dancom5 tout ça...

[Spartacusply]

Dentrite l'a évoqué sans le nommer dès la première réponse.

Après, dans un premier temps c'est bien un DAO que souhaite Dancom5 et c'est pourquoi j'ai ainsi volontairement laissé passer l'abus de langage remplaçant "ArtisteDAO" par "Artiste" et ne pas évoquer le terme de pattern DAO justement pour ne pas l'embrouiller (mais là je crois que pour le coup c'est raté ^^).

[Tsilefy]

Là, d'accord. Une entity autonome et un repository qui s'occupe des CRUD. Encore que je pense personnellement que CRUD et connexion à la BDD sont deux tâches complètement différentes, et je suis plutôt de l'avis de Dendrite, qui consiste à injecter la connexion dans le repository.

[ascito]

je code moi même mes script... don celui ci, qui à la base se sert d'un script de benjamin... au niveau constructeur sa te laisse pas le choix, si tu a une connexion tu la garde, et a coté tu peu assez facilement piocher a gauche et à droite.

voilà comment je vois le code, et j'avoue que des retours de votre part serait positif

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
<?php
	class bdd extends PDO 
	{
		public $dbh; 
		final public function __construct($dsn, $username = '', $password = '', $driverOptions = array())
		{
			$driverOptions += array(self::ATTR_ERRMODE => self::ERRMODE_EXCEPTION,
		self::ATTR_STATEMENT_CLASS => array('Statement'),PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES 'UTF8' ");
			parent::__construct($dsn, $username, $password, $driverOptions);
		}
 
	}
	class Statement extends PDOStatement 
	{
 
	} 
 
	abstract class _mysqlPdo
	{
 
		protected  function connect()
		{ 
 			try {
			$dbh = new bdd('mysql:host='.SERVEUR.';dbname='.BDD, LOG,PASS);
			$dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
			}
			catch (PDOException $e) {
			Jusc::messageErreur($e); 
			}
 
			return $dbh;
		}
 
    }
 
		class mysqlPdo extends _mysqlPdo
		{
 
		    protected static $dbh;
		    protected static $hasActiveTransaction = false;
 
		    public function __construct($bdd='table', $serveur='localhost',$log='root',$pass=''){ 
 
		      if(!defined("SERVEUR")) define ("SERVEUR" ,$serveur );
		      if(!defined("BDD")) define ("BDD" , $bdd );			 
		      if(!defined("LOG")) define ("LOG" , $log );
		      if(!defined("PASS")) define ("PASS" , $pass );
 
		      self::$dbh=$this->connect(); 
		      return self::$dbh;
 
		    }
 
		public function beginTransaction(){
 
			try {
				self::$dbh->beginTransaction();
				self::$hasActiveTransaction = true;
			}
			catch (PDOException $e) {
			Jusc::messageErreur($e); 
			}	 
		}
 
		public function commit(){
			try {
				self::$dbh->commit();
				self::$hasActiveTransaction = false;
			}
			catch (PDOException $e) {
			Jusc::messageErreur($e); 
			}	 
		}
 
		public function rollBack(){
			try {
				self::$dbh->rollBack();
				self::$hasActiveTransaction = false;
			}
			catch (PDOException $e) {
			Jusc::messageErreur($e); 
			}			 
		}
 
		public function prepare($query,$array,$param,$dbh){
			if(false===$dbh){return;}
 
			$this->curentQuery = $dbh->prepare($query);
 
			if(!empty($array)){ 
				foreach($array as $key =>$v ){ 
					$this->curentQuery->bindValue( ':'.$key ,$v); 
				} 
			}		 
		}
		public function lastInsertId(){
 
			return self::$dbh->lastInsertId();
		}
		public function execute(){ 
			$this->curentQuery->execute(); 
		}
 
		public function result(){
			if(substr_count($this->curentQuery->queryString,'SELECT')>0 && substr_count($this->curentQuery->queryString,'INSERT')==0 )
			{
				return $this->curentQuery->fetchAll(PDO::FETCH_CLASS,'mysqlPdo');
			}
			else if(substr_count($this->curentQuery->queryString,'CALL')>0){
				return $this->curentQuery->fetchAll(PDO::FETCH_CLASS,'mysqlPdo');		
			}
			else{
				//return $dbh;
			} 
		} 
 
		public function query($query,$array,$param=null)
		{
			if( self::$hasActiveTransaction === true ){
			$this->prepare($query,$array,$param,self::$dbh);
			$this->execute();
			return $this->result();		
			}else{
				try {
				$this->prepare($query,$array,$param,self::$dbh);
				$this->execute();
				return $this->result();		
				}
				catch (PDOException $e) {
					Jusc::messageErreur($e); 
				} 
			} 
		}
 
 
    }
 
 
 
?>

comme normal => Jusc::messageErreur c'est ma class abstraite ou j’envoie les erreur de PDO , en static pour le coup


ta une gestion du rollBack...


fin au niveau de la demande que l'on peu demander a une class qui ne fait que ca, je la trouve plutôt ouverte et très précise... à l'utilisation elle est sympa , mais ca reste mon avis car c'est moi qui l'ai écrite cette "class mysqlPDO"

[rawsrc]

Salut,

@ascito
Ton code est bancal

Tu étends PDO avec ta classe bdd mais bdd est limitée en dur qu'aux bases MySQL...
Ensuite tu empiles une classe abstraite _mysqlPdo avec une concrète mysqlPdo, il faudrait me dire quelle en est l'utilité. Je me suis posé la question si tu envisageais une gestion de pool de connexions mais à la vue de ton code, non.
Le prototype de ta fonction prepare() attend un paramètre $dbh, je veux bien mais quelle est alors l'utilité alors de toute la cuisine de connexion de la classe ?
Ensuite tu ne gères que le bindValue, aucun contrôle, aucune gestion de type...
Dans result() tu fais deux tests différents pour renvoyer exactement la même chose... Si je fais un INSERT (...) SELECT (...), tu feras comment ?
Pourquoi lors du renvoi de données tu fais PDO::FETCH_CLASS sur ta classe mysqlPdo ? Tu renvoies des données extraites de la base et pas de multiples instances d'une classe connectée à une base de données !

Bref, tu devrais reprendre tout ça, simplifier et ne pas re-coder ce que PDO fait déjà nativement...

[ascito]

Tu étends PDO avec ta classe bdd mais bdd est limitée en dur qu'aux bases MySQL...

oui, c'est le but

Ensuite tu empiles une classe abstraite _mysqlPdo avec une concrète mysqlPdo, il faudrait me dire quelle en est l'utilité. Je me suis posé la question si tu envisageais une gestion de pool de connexions mais à la vue de ton code, non.

la, il s'agit juste de mettre un constructeur et une possibilité d’héritage obligatoire, bon avoir une zone prévu a cet effet.

Le prototype de ta fonction prepare() attend un paramètre $dbh, je veux bien mais quelle est alors l'utilité alors de toute la cuisine de connexion de la classe ?

ne plus avoir a faire de la cuisine dans mes fichiers DAO, et cela vaux pour tout le reste de tes remarques.

je tiens note cependant que ma cuisine est surement pas adapter à quelque chose de très varié, ce n'est pas le but, et peu être à certains niveau, si tu me le confirme et me dit ou précisément et comment modifier, inutile.

mais note aussi que c'est super fonctionnel a l'utilisation.

[dancom5]

@Spartacusply
Tiens un peu de lecture : http://blog.developpez.com/rawsrc/p1...es_classes_poo

Je suis allé lire votre sujet dans le blogue que j'ai trouvé plutôt intéressant. Je me demande sur quel point je devrais plus m'attarder en fonction de ce que je veux.

Je voudrais dire merci à toutes les interventions à mon Topic, c'est apprécié.

On m'a déjà dit qu'il fallait éviter l'héritage à cause que si je voulais rendre portable mon code, qu'il fallait je pense à l'injection (si je ne me trompe pas de mot).

Par rapport au procédural, je trouve qu'il y a plus de lignes en objet pour faire un simple affichage.
Je suis encore divisé entre le procédural et l'objet. Mais, je sais que l'objet est un incontournable.

Pour effectuer une requête à la base de données et l'afficher, je dois faire ceci en gros ce qui suit dans les balises code.
(chose que j'ai montré comme 2e message). Mais que je trouve que les variables se répète un peu trop.

Code :

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

1
2
3
class dbconf{
  // ici, c'est mon singleton
}

et

Code :

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

1
2
3
4
class Artiste{
  // ici, c'est l'appel au singleton
  // la requête mysql
}

Je cherche à faire un équivalent de ce que je ferais en procédural pour faire en PDO une simple requête qui serait fait en Objet afin que je puisse comparé et voir les différences. Mais, c'est de faire selon les meilleures méthodes.

Je verrai par la suite, pour des requêtes plus complexe comme les CRUD par exemple.

Y a des exemples dans les commentaires que je vais voir plus en détails.

Je suis un peu gêné puisque ça fait un bon moment que je suis encore dans le sujet de l'objet.
Pour ce qui est de PDO, j'ai plutôt bien compris.

Je vais porter attention sur tout exemples qui pourrait m'aider à faire un équivalence entre le procédural et l'objet