La meilleure façon de permettre à des plugins pour une application en PHP

Donc, disons que vous ne voulez pas le pattern observer, car il vous demande de changer vos méthodes de la classe pour gérer la tâche de l'écoute, et que vous voulez quelque chose de générique. Et disons que vous ne souhaitez pas utiliser extends héritage, car vous avez peut-être déjà hériter de votre classe à partir d'une autre classe. Ne serait-il pas génial d'avoir un générique façon de faire toute la classe enfichables sans trop d'effort? Voici comment:

<?php
////////////////////
//PART 1
////////////////////
class Plugin {
private $_RefObject;
private $_Class = '';
public function __construct(&$RefObject) {
$this->_Class = get_class(&$RefObject);
$this->_RefObject = $RefObject;
}
public function __set($sProperty,$mixed) {
$sPlugin = $this->_Class . '_' . $sProperty . '_setEvent';
if (is_callable($sPlugin)) {
$mixed = call_user_func_array($sPlugin, $mixed);
}   
$this->_RefObject->$sProperty = $mixed;
}
public function __get($sProperty) {
$asItems = (array) $this->_RefObject;
$mixed = $asItems[$sProperty];
$sPlugin = $this->_Class . '_' . $sProperty . '_getEvent';
if (is_callable($sPlugin)) {
$mixed = call_user_func_array($sPlugin, $mixed);
}   
return $mixed;
}
public function __call($sMethod,$mixed) {
$sPlugin = $this->_Class . '_' .  $sMethod . '_beforeEvent';
if (is_callable($sPlugin)) {
$mixed = call_user_func_array($sPlugin, $mixed);
}
if ($mixed != 'BLOCK_EVENT') {
call_user_func_array(array(&$this->_RefObject, $sMethod), $mixed);
$sPlugin = $this->_Class . '_' . $sMethod . '_afterEvent';
if (is_callable($sPlugin)) {
call_user_func_array($sPlugin, $mixed);
}       
} 
}
} //end class Plugin
class Pluggable extends Plugin {
} //end class Pluggable
////////////////////
//PART 2
////////////////////
class Dog {
public $Name = '';
public function bark(&$sHow) {
echo "$sHow<br />\n";
}
public function sayName() {
echo "<br />\nMy Name is: " . $this->Name . "<br />\n";
}
} //end class Dog
$Dog = new Dog();
////////////////////
//PART 3
////////////////////
$PDog = new Pluggable($Dog);
function Dog_bark_beforeEvent(&$mixed) {
$mixed = 'Woof'; //Override saying 'meow' with 'Woof'
//$mixed = 'BLOCK_EVENT'; //if you want to block the event
return $mixed;
}
function Dog_bark_afterEvent(&$mixed) {
echo $mixed; //show the override
}
function Dog_Name_setEvent(&$mixed) {
$mixed = 'Coco'; //override 'Fido' with 'Coco'
return $mixed;
}
function Dog_Name_getEvent(&$mixed) {
$mixed = 'Different'; //override 'Coco' with 'Different'
return $mixed;
}
////////////////////
//PART 4
////////////////////
$PDog->Name = 'Fido';
$PDog->Bark('meow');
$PDog->SayName();
echo 'My New Name is: ' . $PDog->Name;

Dans la Partie 1, c'est ce que vous pouvez inclure dans un require_once() appel en haut de votre script PHP. Il charge les classes pour faire quelque chose enfichable.

Dans la Partie 2, où nous en charge une classe. Remarque je n'avais pas à faire quelque chose de spécial à la classe, ce qui est significativement différente de celle du modèle Observateur.

Dans la Partie 3, c'est là que nous allons passer notre classe autour de en étant "pluggable" (qui est, prend en charge les plugins qui permettent de remplacer les méthodes de la classe et de propriétés). Ainsi, par exemple, si vous avez une application web, vous pourriez avoir un plugin de registre, et vous pourriez activer les plugins ici. Remarquez aussi la Dog_bark_beforeEvent() fonction. Si j'ai mis $mixed = 'BLOCK_EVENT' avant l'instruction de retour, il va bloquer le chien d'aboyer et serait également bloquer le Dog_bark_afterEvent parce qu'il n'y aurait pas de cas.

Dans la Partie 4, qui est le fonctionnement normal de code, mais notez que ce que vous pourriez penser irait ne fonctionne pas du tout comme ça. Par exemple, le chien n'a pas l'annoncer, c'est le nom que "Fido", mais "Coco". Le chien n'a pas dit "miaou", mais "Woof'. Et lorsque vous voulez regarder le nom du chien par la suite, vous trouvez qu'il est "Différent" au lieu de "Coco". Tous ces substitutions ont été fournis dans la Partie 3.

Alors, comment cela fonctionne? Eh bien, nous allons exclure eval() (dont tout le monde dit qui est "mal") et de la règle qu'il n'est pas un modèle Observateur. Donc, la façon dont il fonctionne, c'est le sournois classe vide appelé Enfichable, qui ne contient pas les méthodes et les propriétés utilisées par la classe Chien. Ainsi, dès que cela se produit, les méthodes magiques vont s'engager pour nous. C'est pourquoi, dans les parties 3 et 4, nous avons jouer avec les objets dérivés de la Enfichable de la classe, pas le Chien de la classe elle-même. Au lieu de cela, nous laissons la classe de Plugin ne le "toucher" sur le Chien objet pour nous. (Si c'est une sorte de modèle de conception, je ne sais pas-s'il vous plaît laissez-moi savoir.)

Ici est une approche que j'ai utilisée, c'est une tentative de copie de Qt signaux/slots mécanisme, une sorte de pattern observer.
Les objets peuvent émettre des signaux.
Chaque signal a un ID dans le système - il est composé par l'expéditeur id + nom de l'objet
Chaque signal peut être appliqué à des récepteurs, ce qui est simplement un "callable"
Vous utilisez un bus de la classe pour transmettre les signaux à toute personne intéressée de recevoir
Lorsque quelque chose arrive, vous "envoyer" un signal.
Ci-dessous est et exemple de mise en œuvre

    <?php
class SignalsHandler {
/**
* hash of senders/signals to slots
*
* @var array
*/
private static $connections = array();
/**
* current sender
*
* @var class|object
*/
private static $sender;
/**
* connects an object/signal with a slot
*
* @param class|object $sender
* @param string $signal
* @param callable $slot
*/
public static function connect($sender, $signal, $slot) {
if (is_object($sender)) {
self::$connections[spl_object_hash($sender)][$signal][] = $slot;
}
else {
self::$connections[md5($sender)][$signal][] = $slot;
}
}
/**
* sends a signal, so all connected slots are called
*
* @param class|object $sender
* @param string $signal
* @param array $params
*/
public static function signal($sender, $signal, $params = array()) {
self::$sender = $sender;
if (is_object($sender)) {
if ( ! isset(self::$connections[spl_object_hash($sender)][$signal])) {
return;
}
foreach (self::$connections[spl_object_hash($sender)][$signal] as $slot) {
call_user_func_array($slot, (array)$params);
}
}
else {
if ( ! isset(self::$connections[md5($sender)][$signal])) {
return;
}
foreach (self::$connections[md5($sender)][$signal] as $slot) {
call_user_func_array($slot, (array)$params);
}
}
self::$sender = null;
}
/**
* returns a current signal sender
*
* @return class|object
*/
public static function sender() {
return self::$sender;
}
}   
class User {
public function login() {
/**
* try to login
*/
if ( ! $logged ) {
SignalsHandler::signal(this, 'loginFailed', 'login failed - username not valid' );
}
}
}
class App {
public static function onFailedLogin($message) {
print $message;
}
}
$user = new User();
SignalsHandler::connect($user, 'loginFailed', array($Log, 'writeLog'));
SignalsHandler::connect($user, 'loginFailed', array('App', 'onFailedLogin'));
$user->login();
?>

Il y a une jolie projet appelé Épinoche par Matt Zandstra à Yahoo qui gère une grande partie du travail pour la manipulation des plugins en PHP.

Il veille au respect de l'interface d'une classe de plugin, prend en charge une interface de ligne de commande et n'est pas trop dur de se lever et courir, surtout si vous lisez l'histoire de la couverture de ce sujet dans le PHP architecte magazine.

Je suis surpris de voir que la plupart des réponses ici semblent être orientés sur les greffons qui sont locales à l'application web, c'est à dire, les plugins qui s'exécutent sur le serveur web local.

Ce sujet si vous vouliez que les plugins pour fonctionner sur un autre - serveur - distant? La meilleure façon de le faire serait de fournir un formulaire qui vous permet de définir les différentes Url qui sera appelé lorsque certains événements se produisent dans votre application.

Différents événements allaient envoyer des informations différentes en fonction de l'événement qui vient de se produire.

Cette façon, vous n', il suffit de faire une boucle appel à l'URL qui vous a été fourni à votre demande (par exemple via https) où des serveurs distants peuvent effectuer des tâches basées sur l'information qui a été envoyé par votre application.

Cela offre deux avantages:

1. Vous n'avez pas à accueillir n'importe quel code sur votre serveur local (sécurité)
2. Le code peut être sur des serveurs distants (extensibilité) dans les différentes langues autres que PHP (portabilité)