Discussion :

[oxman]

Bonjour,

Je me pose une question sur les injections de dépendance.
Admettons que j'ai une méthode request appelé par un webservice, je ne peux pas mettre la dependency injection de cette façon :
request($myDependance, $otherArgs)

Je me dis donc que je vais utiliser l'injection de dépendance via setter, mais je n'ai pas toujours besoin d'injecter la dépendance, elle est par défaut à une valeur, donc je fais un truc tordu et crade de cette façon :

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
 
<?php
 
class classSoap
{   
 
    public function __construct() {}
 
    public function request($bouh)
    {
 
        $a = $this->getSay();
        $a->say();
 
    }
 
    public function setSay(say $say)
    {
 
        $this->_say = $say;
 
    }
 
    public function getSay()
    {
 
        if (isset($this->_say) === false) {
            return new sayThat();
        } else {
            return $this->_say;
        }
 
    }
 
 
}
 
interface say {
    public function say();
}
 
class sayThat implements say {
    public function say()
    {
        echo 'Hello';
    }
}
 
 
$soap = new classSoap();
//$soap->setSay(new sayThat());
$soap->request('bouh');
 
?>

On doit forcément pouvoir faire mieux ou plus propre non ?

[rawsrc]

Bon à part du sucre syntaxique, je vois pas trop comment améliorer ce code. Il est clair que si l'instance de la classe classSoap doit voyager afin d'avoir ses paramètres définis, il est impossible de faire autrement qu'avec un set/get.

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
<?php
 
class classSoap {   
 
	private $_say;
 
	function request($bouh) {
		$this->getSay()->say($bouh);
	}
 
	function setSay(say $say) {
		$this->_say = $say;
	}
 
	function getSay() {
		return (isset($this->_say)) ? $this->_say : new sayThat();
	} 
}
 
 
interface say {
	function say();
}
 
 
class sayThat implements say {
	function say() {
		echo 'Hello';
	}
}
 
 
$soap = new classSoap();
//$soap->setSay(new sayThat());
$soap->request('bouh');
 
?>

[Halleck]

A vue de nez tu pourrais aussi faire ceci (après ça dépend de ton code, là avec juste ton exemple ça irait) :

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
abstract class soapInstance {
	private static $_instance;
 
	public static function &getInstance() {
		if(is_null(self::$_instance)) {
			self::$_instance	= new sayThat;
		}
 
		return self::$_instance);
	}
}
 
 
class classSoap {   
     public function __construct() {}
 
    public function request($bouh)
    {
        $a = soapInstance::getInstance();
        $a->say();
 
    } 
}

Tu pourrais également penser à utiliser le pattern Strategy.

[ThomasR]

Juste un ptit commentaire,

@Hallek, les objets sont tous passés par référence (à moins de retourner une évaluation ou de cloner l'objet bien sûr), l'opérateur de retour par référence dans ta fonction getInstance est inutile, voire déprécié :

Code :

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

1
2
3
4
5
6
7
 
public static function getInstance() {
    if(self::$_instance === NULL) {
        self::$_instance = new sayThat;
    }
    return self::$_instance;
}