[PHP 5.3] [POO]Utilisation de methodes venant d'une autre classe

[yann18]

Bonjour/ bonsoir,

Toujours dans l'apprentissage de la POO, je réécris régulièrement mon code...
J'ai écris la classe de connexion suivante:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Database {
 
    private $db_host = 'XXX';
    private $db_user = 'XXX';
    private $db_pass = '';
    private $PDO;
 
    private function setConnection() {
        try {
            $this->PDO = new PDO($this->db_host, $this->db_user, $this->db_pass);
           ...
 
        } catch (PDOException $e) {//sinon, capture de l'erreur et affichage
            echo 'La base de donnée n\'est pas disponible. <br>Merci de rééssayer plus tard';
        }
    }
 
    public function getConnection(){
        return $this->PDO;
    }
 
}

Autant je crois avoir compris comment exploiter les propriétés et méthodes d'une classe seule, autant je ne comprends pas comment y faire appel dans une autre classe (je ne parle pas de classe fille)
J'ai créée mon objet dans le même fichier:

Code :

1
2
$connection = new Database();
$auth = new Auth();

Et je veux maintenant m'en servir pour faire fonctionner la seconde classe:

Code :

1
2
3
4
5
6
class Auth {
...
public function login($data) {
$select = $connection->getConnection()->prepare(...);
...
}

Et là, je me retrouve avec un beau

Undefined variable: connection in C:\wamp\www...

ainsi que

Fatal error: Call to a member function getConnection() on a non-object in C:\wamp\www...

L'objet n'est pas reconnu. Que fois-je faire ?
merci,

[vorace]

moi je dirai soit tu rajoutes un attribut de type Database dans ta classe Auth e à ce moment la c'est pas de l'héritage mais une relation d'agrégation je crois ou soit tu passe ton objet Database en paramètre à ta méthode login()...

[grunk]

Comment $connection pourrait il être défini dans ta class Auth alors que tu le défini en dehors ?

Tu dois le passer en argument à ta classe Auth pour pouvoir l'utiliser :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
 
$connection = new Database();
$auth = new Auth($connection);
 
class Auth {
    private $db
    public function __construct($db) {
        $this->db = $db;
    }
    public function login($data) {
    $select = $this->db->getConnection()->prepare(...);
...
}

Au passage quel est l'intéret de wrapper la classe PDO si tu n'y ajoutes aucune fonctionnalité ?

[yann18]

quel est l'intéret de wrapper la classe PDO

En français s'il te plaît ? Merci pour ta réponse...

[Benjamin Delespierre]

En français s'il te plaît ? Merci pour ta réponse...

Un Wrapper (embalage en français) est une classe destinée à en encapsuler une autre pour fournir une façade ou une adaptation (voir les patterns façade et adaptateur).

Je ne comprends pas non plus pourquoi tu fais un wrapper... La classe PDO se suffit à elle même et ta classe Database n'apporte rien. Généralement, on fabrique des Singleton PDO de cette façon:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class Database {
  protected static function $_instance;
 
  protected function __construct () {}
 
  public static function instance ($dsn = null, $user = null, $pass = null, $do = array()) {
     if (!isset(static::$_instance)) {
        static::$_instance = new PDO($dsn,$user,$pass, $do);
     }
     return static::$_instance;
  }
}

Stealth35 à une autre approche du singleton beaucoup plus fun:

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
 
class Singleton
{
    protected static $_instances;
 
    public static function __callStatic($name, array $arguments)
    {    
        if(empty(static::$_instances[$name]) || !empty($arguments))
        {
                if(strpos($name, '\\') === 0)
                {
                $name = substr($name, 1);
                }
 
                $classname = '\\' . $name;
 
            if(method_exists($classname, '__construct'))
            {
                $class = new \ReflectionClass($classname);
                static::$_instances[$name] = $class->newInstanceArgs($arguments);
            }
            else
            {
                static::$_instances[$name] = new \$classname;
            }
        }
 
        return static::$_instances[$name];
    }
}

Dans les deux cas, l'intérêt du Singleton est d'assurer l'unicité de l'instance de PDO dans tout le système. Les détracteurs du pattern Singleton argumenteront en disant qu'un singleton est une forme détournée de variable globale et lui préfèrent une approche plus souple qui consiste pour les classes modèle à connaitre la référence de l'objet PDO qu'elles utilisent. Ils ont 100x raison mais pour des raisons pratiques, je ne me suis jamais totalement défait de mes singletons.

[s.n.a.f.u]

Pour ajouter ma pierre à l'édifice un peu branlant...
Avant de t'attaquer à la POO et aux notions d'héritage et de composition, tu devrais t'assurer de maîtriser la portée des variables en PHP dans des fonctions toute simples. (voir le mot clé global, pas pour l'utiliser, mais pour le comprendre)

Ce n'est nullement péjoratif de ma part, tout le monde commence un jour et il faut encourager les bonnes volontés.

Mais il faut aussi canaliser les enthousiasmes débordants en leur conseillant de commencer par le début...