[PHP 5.3] POO agrégation et bonne pratique

[yannux]

Salut à tous, je me pose une question concernant les bonnes pratiques / qualités de code / performance. J'ai une classe principale qui va instancier (automatiquement) des classes modules en passant à leur constructeur sa propre classe $this....
Une fois instancier ces objets sont gardés dans un array de ma classe maitre.

Je trouve ça plutôt pratique car j'aimerais utilisé certaines méthodes (add_post_meta, add_post_meta, save_post_meta, etc....) de ma classe maitre (Social) dans mes classes modules (Social_Facebook par exemples) .

Ci-dessous le code (raccourcis) des classes en question.

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
55
56
57
58
59
60
61
62
63
64
<?php
class Social
{
	public static $pluginPath 	= '/Social/';
	public static $pluginUrl  	= '/Social/';
 
	private $_modules = array(
		'Facebook' 	=> true,
		'Twitter'	=> true,
		'Googleplus'=> false,
	);
 
	private $_modulesObject = array();
 
	public function __construct()
	{	
		self::$pluginPath 	= WPMU_PLUGIN_DIR . self::$pluginPath;
		self::$pluginUrl	= WPMU_PLUGIN_URL . self::$pluginUrl;
 
		$this->_loadModules();
	}
 
	private function _loadModules()
	{
		foreach($this->_modules as $moduleKey => $state) {
			if (!$state) continue;
 
			include(self::$pluginPath . $moduleKey . '.php');
			$var 	= "_s{$moduleKey}";
			$class 	= "Social_{$moduleKey}";
			$this->_oModules[$moduleKey] = $var;
 
			$this->$var 	= new $class($this);
		}
	}
 
	public function add_post_meta($moduleKey, $metaKey, $metaValue)
	{
		$this->_postMetaKey[$moduleKey][$metaKey] = $metaValue;
	}
 
	public function delete_post_meta($moduleKey, $metaKey)
	{
		unset($this->_postMetaKey[$moduleKey][$metaKey]);
	}
 
	public function save_post_meta()
	{
 
		 update_post_meta($post_id, $meta_key, $meta_value, $prev_value);
	}
 
 
<?php
 
class Social_Facebook
{
	public function __construct(&$parent)
	{
 
		$this->_parent = $parent;
	}
}
?>

Je suis contrarié dans mon idée car l'idéal serait surement d'avoir une classe Social_Data par exemple qui me serve à gérer tout ajout/supression etc..

De plus je passe à mes classes modules une référence à la classe maitre et cette dernière contient déjà les instance de mes objets modules....
En faite je me demande si ce n'est pas un peu bourrin comme méthode...

Vous avez déjà expérimenté ? Des avis techniques ?

[rawsrc]

Bonjour,

Tu devrais privilégier l'approche lazy loading : ne charger les modules que lorsque tu en as besoin et pas avant. Il se peut très bien que dans un traitement tu n'ais pas besoin du tout d'un module, il serait dommage d'y consacrer des ressources pour le charger inutilement.

Passer explicitement par référence des instance est totalement inutile les instances passent déjà par défaut par référence.

A vouloir tout connecter, c'est le meilleur moyen pour t'y perdre. Sans compter toutes les redondances... Et puis avoir accès à tout partout dans ton code va t'amener à enfreindre un paquet de règles et de bonnes pratiques de la POO. Tu vas te retrouver avec des (trains) de chaînes à n'en plus finir : $this->_parent->modules()->social()->twitter()->database()->getInstance()->create();Bref ingérable, crois-moi.

Reprends ton design et penses abstraction, encapsulation, réutilisabilité...

[grunk]

Pourquoi ne pas simplement dérivé d'une classe sociale tes classes spécialisée avec éventuellement si nécessaire avoir une factory d'objet social ?

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
class SocialFactory 
{
   public static function create ($socialType,$login,$password){
      switch ($socialType){
         case 'facebook':
            $social = new SocialFacebook($login,$password);
            break;
         case 'twitter':
            $social = new SocialTwitter ($login,$password);
            break;
         default:
            throw new Exception ('Type social inconnu');
      }
      return $social;
   }
}
 
class SocialFacebook extends Social 
{
	public function __construct($login,$password)
	{
	//...
	}
}
 
$facebook = SocialFactory::create('facebook','foo','bar');

[yannux]

Envoyé par rawsrc

Bonjour,
Tu devrais privilégier l'approche lazy loading : ne charger les modules que lorsque tu en as besoin et pas avant. Il se peut très bien que dans un traitement tu n'ais pas besoin du tout d'un module, il serait dommage d'y consacrer des ressources pour le charger inutilement.
....
A vouloir tout connecter, c'est le meilleur moyen pour t'y perdre. Sans compter toutes les redondances...

En faite il n'y a pas tout le code là, mais les modules ne sont chargés uniquement si ils sont activés et sur les partis de l'application où j'en ai besoin.
Comme tu le précise c'est la redondance qui ne me plaisait pas dans ce que j'ai fait, un module qui contient une ref a l'objet parent qui contient lui meme l'objet module.... pas très clean, mais quelques avis extérieurs sont toujours bons

Pourquoi ne pas simplement dérivé d'une classe sociale tes classes spécialisée avec éventuellement si nécessaire avoir une factory d'objet social ?

J'ai besoin d'une classe maitre qui va tout chargé aux moment requis ( c'est un plugin wordpress ), par contre je vais faie dérivé mes modules d'une classe Social_Module et gérer les méthodes communes pour sauvegarder / gérer les données requises dans une classe Social_Data...