Framework

Rendre son module compatible avec l'interface de communication

Table des matières
  1. Avant-propos
  2. Très brèves notions sur l'héritage
  3. monmodule_interface.class.php
  4. Réalisation de la classe MonModuleInterface
    1. Réalisation minimaliste
    2. Exemple de réalisation plus complet
    3. Les méthodes Interdites
  5. Remarques diverses
  6. Voir aussi

Avant-propos



Avant de vous lancer, dans ce tutoriel, assurez vous que votre module est déjà fonctionnel et non buggé, c'est toujours mieux.
Une fois ceci réalisé, voici comment tout cela va fonctionner.


De bonnes notions en Programmation Orientée Objet (POO) sont requises.
De plus, il est nécessaire de connaitre le fonctionnement de l'héritage

Dans ce tutoriel, seule l'utilité de l'héritage sera expliqué, mais dans tous les cas, utilisez les liens ci-dessus pour comprendre ce tutoriel.


Tout d'abord il faut imaginer qu'un autre développeur va utiliser votre module, pour cela il utilisera les méthodes décrites ici.

La première chose qu'il va donc essayer de faire avec votre module c'est de l'instancier.
Pour cela, vous aurez besoin d'implémenter une classe que l'interface de communication pourra allé lire et exécuter.
Ensuite, il va simplement appelé des méthodes de la classe que vous venez d'implémenter.

C'est aussi simple que cela. Nous allons donc voir chacun des deux points en détail.


Très brèves notions sur l'héritage



L'héritage consiste en fait à dire que l'héritier dispose des propriétés du père.

Ainsi votre classe MonModuleInterface (vue plus bas) héritera de la classe ModuleInterface.
Ceci va donc lui ajouter certaines méthodes qui vont lui permettre d'autotester la présence de fonctionnalités.

Pour en savoir plus, lisez



monmodule_interface.class.php



Maintenant que vous savez comment cela va fonctionner en théorie, il est temps de voir cela fonctionne en pratique.

Pour rendre votre module compatible, vous avez juste besoin de faire UN fichier.
Oui, un seul petit fichier, il n'y a pas besoin de réorganiser votre module (à partir du moment ou les fonctionnalités sont bien séparées à l'intérieur).

Comment cela est possible?
Et bien lorsqu'un développeur va vouloir utiliser votre module, il fera appel à la méthode Modules::GetModule() qui va tenter d'instancier l'objet interface de votre module.

Pour cela il va regarder si le fichier
Code PHP :
$NomDeVotreModule.'/'.$NomDeVotreModule.'_interface.class.php'
existe et si oui, si il contient bien une classe nommée
Code PHP :
ucfirst($NomDeVotreModule).'Interface'

Il pourra alors appelé n'importe quelle méthode de cette classe.


Le nom du fichier est nomdumodule_interface.class.php, tout en minuscule.
Le nom de la classe est NomdumoduleInterface avec une majuscule au nom du module.


Exemple pour le module Wiki
  • Nom du fichier : 'wiki/wiki_interface.class.php'
  • Nom de la classe : 'WikiInterface'



Réalisation de la classe MonModuleInterface



Nous allons maintenant voir ce qu'il faut mettre dans ce fichier monmodule_interface.class.php

Le contenu de ce fichier se résume à une classe MonmoduleInterface qui hérite de la classe ModuleInterface
Voyons maintenant ce qu'il faut y mettre dedans.


Réalisation minimaliste



Voici une réalisation minimaliste servant de base à ce qui va suivre.

Code PHP :
 
<?php
 
// Inclusion du fichier contenant la classe ModuleInterface
require_once('../kernel/framework/modules/module_interface.class.php');
 
// Classe MonmoduleInterface qui hérite de la classe ModuleInterface
class MonmoduleInterface extends ModuleInterface
{
    //----------------------------------------------------------------- PUBLIC
    //----------------------------------------------------- Méthodes publiques
 
    //----------------------------------------------------------- Constructeur
    function MonmoduleInterface (  )
    /**
     * Constructeur de la classe Module
     */
    {
        // Appel obligatoire au tout début du constructeur
        parent::ModuleInterface('monmodule');
        // Cela permet de lister des informations utiles pour les autres développeurs
 
        // Suite du constructeur
    }
}
 
?>
 


Comme on peut le voir ici, il n'y a quasiment rien à faire, pour commencer à rendre son module compatible avec les autres.
Cependant à ce stade là, ce qu'on a fait ne sert strictement à rien dans la mesure ou l'on peut juste construire un objet de type MonmoduleInterface.

Pour que ce soit utilisable, il ne reste plus qu'à implémenter les méthodes que vous désirez voire utilisées dans d'autres modules. Cela se fait en définissant de nouvelles méthodes à votre classe MonmoduleInterface. Les seules connaissances que vous nécessitez alors sont celle de la programmation orienté objet.


Exemple de réalisation plus complet



Code PHP :
 
<?php
 
// Inclusion du fichier contenant la classe ModuleInterface
require_once('../kernel/framework/modules/module_interface.class.php');
 
// Classe MonmoduleInterface qui hérite de la classe ModuleInterface
class MonmoduleInterface extends ModuleInterface
{
    //----------------------------------------------------------------- PUBLIC
    //----------------------------------------------------- Méthodes publiques
 
    function methode1 ( $monArgument1, $monArgument2, ... )
    /**
     *  Renvoie le résultat correspondant à ...
     */
    {
        // Mon traitement
        return $monResultat;
    }
 
    function methode2 ( $monArgument1, ... )
    /**
     *  Renvoie le résultat correspondant à ...
     */
    {
        // Mon traitement
        return $monResultat;
    }
 
    //----------------------------------------------------------- Constructeur
    function MonmoduleInterface (  )
    /**
     * Constructeur de la classe Module
     */
    {
        // Appel obligatoire au tout début du constructeur
        parent::ModuleInterface('monmodule');
        // Cela permet de lister des informations utiles pour les autres développeurs
 
        // Suite du constructeur
    }
 
    //------------------------------------------------------------------ PRIVE
    /**
     *  Pour des raisons de compatibilité avec PHP 4, les mots-clés private,
     *  protected et public ne sont pas utilisé.
     *  
     *  L'appel aux méthodes et/ou attributs PRIVE/PROTEGE est donc possible.
     *  Cependant il est strictement déconseillé, car cette partie du code
     *  est suceptible de changer sans avertissement et donc vos modules ne
     *  fonctionnerai plus.
     *  
     *  Bref, utilisation à vos risques et périls !!!
     *  
     */
    //----------------------------------------------------- Méthodes protégées
 
    //----------------------------------------------------- Attributs protégés
    var $monAttribut1;
    var $monAttribut2;
    var $monAttribut3;
}
 
?>
 



Les méthodes Interdites



Certains noms de méthodes ne peuvent être définis dans votre classe MonmodulInterface et ce car ils sont utilisés par la classe ModuleInterface.

En voici la liste :
  • GetInfo
  • Functionnality
  • HasFunctionnality
  • GetErrors
  • ModuleInterface
  • setError
  • clearFunctionnalityError



Remarques diverses



  • Il est important de faire de modules sécurisés et exempt d'erreurs, surtout si des fonctionnalités de ce module peuvent-être appelées par d'autres.
  • Les méthodes qui sont définies dans votre classe MonModuleInterface doivent être constantes dans le temps.
    C'est à dire, qu'il faut bien penser la fonctionnalité avant de la proposer afin que le nom, les arguments et la valeur de retour de la méthode ne change pas au fil de l'évolution du module.
    Seul son implémentation peut-changer!
    Par exemple pour corriger des bugs, améliorer les performances, ...

    Tout ceci pour une raison très simple, c'est que si vous changez une des caractéristiques précédemment énoncée de votre méthode, alors tous les modules utilisant cette fonctionnalité devront eux aussi être modifié en conséquence, ce qui est facheux.
  • Ne mettez dans cette classe que les méthodes que vous autorisez à être appelée de l'extérieur.
    En effet, PHP 4 n'utilise pas les notions PUBLIC, PRIVATE et PROTECTED.
    En conséquent, vos méthodes pourront quand même être appelées de l'extérieur.
  • Et enfin dernier point, documentez chaque méthode de cette interface afin qu'elle soit facilement utilisable par d'autres.



Voir aussi



Cette page a été vue 2228 fois