Discussion :

[flipflip]

Bonjour à tous,

Je dev un plugin pour le CMS PluXml et je rencontre un problème avec les class.

Mon plugin est composé d'une class principal "portail" qui hérite de class native de PluXml : plxPlugin qui est la partie chargé de gérer les plugins. Pour simplifier la maintenance de mon plugin j'ai créé autant de fichiers class que de type de class et souvent une sous-class doit pouvoir accéder à une fonction d'une autre class.

Ci-dessous le code de portail.php, j'ai supprimé tout ce qui concerne PluXml

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
include __DIR__.'/include/portailUtils.php';
include __DIR__.'/include/portailItm.php';
include __DIR__.'/include/portailExports.php';
include __DIR__.'/include/portailClients.php';
include __DIR__.'/include/portailAdv.php';
include __DIR__.'/include/portailCrm.php';
include __DIR__.'/include/xlsxwriter.class.php';
 
class portail extends plxPlugin {
	private $_database = false;
	private $_portailUtils = false;
	private $_portailItm = false;
	public $_portailExports = false;
	private $_portailClients = false;
	private $_portailAdv = false;
	private $_portailCrm = false;
	private $_xlsxWriter = false;
 
	public function __construct($default_lang) {
		parent::__construct($default_lang);
 
		if(!class_exists('portailUtils')) { die('class portailUtils absent'); }
		$this->_portailUtils = new portailUtils($this->_database);
 
		if(!class_exists('xlsxWriter')) { die('class xlsxWriter absent'); }
		$this->_xlsxWriter = new xlsxWriter();
 
		if(!class_exists('portailClients')) { die('class portailClients absent'); }
		$this->_portailClients = new portailClients($this->_database, $this->_portailUtils);
 
		if(!class_exists('portailItm')) { die('class portailItm absent'); }
		$this->_portailItm = new portailItm($this->_database, $this->_portailUtils, $this->_portailAdv);
 
		if(!class_exists('portailAdv')) { die('class portailAdv absent'); }
		$this->_portailAdv = new portailAdv($this->_database, $this->_portailUtils, $this->_portailItm, $this->_portailClients);
 
		if(!class_exists('portailCrm')) { die('class portailCrm absent'); }
		$this->_portailCrm = new portailCrm($this->_database, $this->_xlsWriter, $this->_portailUtils, $this->_portailItm, $this->_portailClients, $this->_portailAdv);
 
		if(!class_exists('portailExports')) { die('class portailExports absent'); }
		$this->_portailExports = new portailExports($this->_database, $this->_xlsxWriter, $this->_portailUtils, $this->_portailItm, $this->_portailCrm, $this->_portailClients, $this->_portailAdv);
	}
[...]

Mon problème est que pour la class _portailItm j'ai besoin de la class _portailAdv que je déclare juste après tout simplement parce que pour la class _portailAdv j'ai besoin de la class _portailItm... C'est le serpent qui se mord la queue

Est-ce qu'il y a une autre méthode pour déclarer mes class sans tombé dans le problème de dépendance ?

Merci d'avance.

[CosmoKnacki]

Il n'y a pas 36 solutions, tu dois réécrire tes classes de manière à ce qu'elles ne soient pas aussi couplées:

• N'utilise l'héritage que lorsque celui-ci fait sens, exemple: Poème peut hériter de Texte, mais pas de Choucroute (même si au fond c'est très ressemblant). Autrement dit, évite l'héritage lorsqu'il ne s'agit que de récupérer des fonctionnalités (des méthodes) s'il n'y a pas de lien sémantique entre les deux classes.
• Lorsqu'une méthode de classe nécessite une instance d'une autre classe, privilégie l'injection de dépendance. (Il y a toute une littérature sur le web sur le sujet).
• Éventuellement, et lorsque le point précédent sera bien clair pour toi, tu peux étudier les design patterns.

[flipflip]

Il n'y a pas 36 solutions, tu dois réécrire tes classes de manière à ce qu'elles ne soient pas aussi couplées:

J'ai été pleurer un bon coups dans un coin de mon garage

N'utilise l'héritage que lorsque celui-ci fait sens, exemple: Poème peut hériter de Texte, mais pas de Choucroute (même si au fond c'est très ressemblant). Autrement dit, évite l'héritage lorsqu'il ne s'agit que de récupérer des fonctionnalités (des méthodes) s'il n'y a pas de lien sémantique entre les deux classes.

Ok mais par exemple dans ma class _portailAdv j'ai une method qui permet la consultation du stock d'un produit. L'idée est que j'affiche un formulaire, la personne saisie une référence et valide. Magie le stock s'affiche mais en même temps on m'a demandé d'afficher des informations sur le produit (photos, dimensions). Informations que je récupère via la class _portailItm qui est dédié à tout ce qui concerne les produits.

En gros ma logique a été de créer des class "métier" :

• ADV;
• CRM;
• Clients.

Et des class "fonctions" :

• itm;
• utils.

Lorsqu'une méthode de classe nécessite une instance d'une autre classe, privilégie l'injection de dépendance. (Il y a toute une littérature sur le web sur le sujet).

Je suis retourner pleurer mais dans un autre coin de mon garage

J'ai quand même pris le temps de réfléchir et lire un peu mais en fait c'est moi qui ai mal construit mes class. Du coups je part sur des class métiers qui ne font uniquement que collecter les résultats des class "fonctions" et présenter le résultat à l'utilisateur. Est-ce une bonne piste ?

[cavo789]

Bonsoir

Pour faire fi des problèmes de chargement, vois si ton CMS te permet d'utiliser de manière aisée Composer et la notion de autoload. Si cela est possible (le domaine est vaste et compliqué, désolé de ne pas donner plus de détail); je te suggère de t'intéresser à l'autoload. Composer travaille avec des namespaces et ... oui, oui, oui, ce n'est pas évident à appréhender mais si tu souhaites ne plus jamais avoir ces soucis de chargement, c'est la direction vers laquelle tu pourrais te diriger.

Sinon, au survol de ton code, une remarque tatillonne, je vois que tu initialises tes propriétés à la valeur false la plupart du temps. C'est une erreur puisque de ce que je vois, plusieurs variables sont des objets; tu devrais les initialiser à la valeur null dans ce cas.

[flipflip]

Bonjour,

merci pour tes infos.

Pour le moment PluXml n'utilise pas composer, c'est en cours d'évolution. Ca me laissera le temps de me documenter et encore mieux appréhender la POO.

Sinon, au survol de ton code, une remarque tatillonne, je vois que tu initialises tes propriétés à la valeur false la plupart du temps. C'est une erreur puisque de ce que je vois, plusieurs variables sont des objets; tu devrais les initialiser à la valeur null dans ce cas.

Cette partie du code est assez ancienne et c'était mes débuts en POO, je l'ai fais et jamais remis en cause car fonctionnel. Je vais me documenter pour comprendre la différence entre un objet à false ou null

Hier soir j'ai commencé la migration des méthodes dans la bonne class et maintenant après une nuit je me dis que c'est bien plus logique comme ça et que la version précédente n'avait pas de sens... Mais faut bien débuter à un moment.

[grunk]

Vouloir écrire une classe par objet métier c'est très bien. En revanche là ou ca ne va plus c'est que tu crois que tout le monde à besoin de tout le monde ce qui est faux.

Ce dont on besoin les classes c'est éventuellement des données que peut fournir une autre classe. Ca ne veux pas dire qu'elles doivent être couplées.

Si j'ai bien compris ta classe ADV représente ton stock et la classe Itm les éléments de ce stock.

Donc pour avoir le détails d'un ensemble de produits ca peut se limiter à faire :

Code :

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

1
2
3
4
5
$adv = new ADV();
$stock = $adv->getStock();
 
$itm = new ITM();
$details = $itm->getDetailFor($stock);

Les deux classes ne se connaissent pas , elles ont pourtant échangé des données.

Idem pour ton xlsWriter il ne faut surtout pas "l'inclure" dans toutes tes classes.
Il faut simplement lui passer des données :

Code :

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

1
2
3
4
5
$crm = new CRM();
$clients = $crm->getCustomersList();
 
$xls = new XLSWriter();
$xls->write($clients,XLSType::Customer); // La classe à juste besoin de données et de leur type