Décharger classe dynamique en PHP

J'ai mis en place le chargement dynamique des plugins de la manière suivante:

function processPlugin( $plgFile, $db ) {
  require_once( $plgFile );
  $plgin = new PlginImpl();
  $plgin->setDb($db);
  $ret = $plgin->process();
  return $ret;
}

Chaque plugin définit une classe nommée PlginImpl, qui fonctionne très bien. Mais il devrait être possible de convoquer d'autres plugins spécifié dans l'intérieur de la valeur de retour de process(). Qui ferait la même méthode indiquée ci-dessus, mais échoue avec:

Fatal error: Cannot redeclare class PlginImpl in ..

Veuillez noter que chaque plugin est une classe, c'est à dire:

class PlginImpl extends Plugin implements PluginInterface

Plugin offre quelques fonctions utiles tout en PluginInterface définit c'est à dire process().

Je suppose que le fait que tous les plugins sont nommés PlginImpl les causes du problème, d'où ma question: est-il un moyen de décharger une classe (PlginImpl) après le chargement avec require_once? Ou est-il une approche totalement différente, je devrais suivre?

MODIFIER
J'ai essayé sans réussir les choses suivantes:

unset $plgin après process()
appel __destruct() - il n'a pas de travail ni dans processPlugin() ni dans les process méthode

InformationsquelleAutor MrG | 2009-07-23

php

11

Puisque vous ne pouvez pas décharger une classe après que vous avez chargé, la seule option que vous avez est de renommer chaque plugin.

PluginX, PluginY, etc., mais il ne devrait pas que vous pouvez juste les forcer à utiliser l'interface du plugin que vous avez montré.

Pour charger un plugin spécifique, vous pouvez tout simplement quelque chose comme solomongaby suggère, mais au lieu d'un nom de fichier, vous passer le nom du plugin.. quelque chose comme ceci:
```
function loadPlugin($pluginName) {
    require_once $pluginName . '.php';

    $plugin = new $pluginName;
    //do whatever with $plugin
}
```
InformationsquelleAutor Jani Hartikainen
4

Une autre option, bien que je ne le recommande pas, est d'utiliser runkit_import.
- Ne savais pas à ce sujet. Cool 🙂
InformationsquelleAutor Saem
1

Je ne suis pas sûr à 100%, mais je ne crois pas que vous pouvez décharger une classe une fois qu'il est déclaré.

Cependant, il y est une façon d'accomplir ce que vous essayez de faire.

Nom de chaque classe différemment et de détruire une classe avant de créer le suivant:
```
$class1 = "foo";
$class2 = "bar";

$pluginResult = processPlugin($class1);
//do stuff
$pluginResult = processPlugin($class2);

function processPlugin($pluginName, $db) {
    require_once( $pluginName . ".inc" ); //or whatever scheme you want to use.
    $plgin = new $plugin;
    $plgin->setDb($db);
    $ret = $plgin->process();
    unset($plgin);
    return $ret;
}
```
Vous aurez des extra classes définies traîner, mais d'en désactiver le plugin une fois chargé devraient minimiser les problèmes de mémoire.

InformationsquelleAutor Bryan
1

Je sais que la question a été posté il y a plusieurs années, mais j'ai écrasé à cette question aujourd'hui, j'espère que ce journal pourrait aider comment vais avoir le même problème à l'avenir.

Comme il'has été mentionné dans de nombreuses réponses, PHP (au moins jusqu'à 5.3) ne permet pas de décharger les classes; ce que l'on peut faire est d'éviter les conflits entre les noms. En gardant cela à l'esprit, j'ai écrit un code qui charge chaque plugin dans un espace de noms unique.
```
$uniqueContext = 'Context_'.rand();
$content = file_get_contents($actionScript);
if (strstr($content, '<?php')) {
    $content = str_replace('<?php', "<?php namespace $uniqueContext;", $content);
} else {
    if (strstr($content, '<?')) {
        $content = str_replace('<?', "<?php namespace $uniqueContext;", $content);
    } else {
        $content = "namespace $uniqueContext;".$content;
    }
}
$tmp=array_search('uri', @array_flip(stream_get_meta_data($GLOBALS[mt_rand()]=tmpfile())));
file_put_contents($tmp, $content);
require_once($tmp);
```
Le plugin écrivains doivent être conscients que référencé classes sont destinées au contexte que l'hôte crée pour son.
- PHP jusqu'à 5.3 ne vous permet pas de vous décharger d'une classe. Alors, comment le faire en php 5.3+?
InformationsquelleAutor FabioDch
0

Vous pourriez chercher à avoir le plgun->process() appel de la méthode le déconstructeur http://ca.php.net/manual/en/language.oop5.decon.php

Ou

Vous pourriez avoir le résultat de $plgin->process() stockées dans un temp var et puis unset($plgin)
```
function processPlugin( $plgFile, $db ) {
  require_once( $plgFile );
  $plgin = new PlginImpl();
  $plgin->setDb($db);
  $result = $plgin->process();
  unset($plgin);
  return $result;
}
```
Cependant, je pense que vous êtes probablement l'approche du problème dans une voie difficile.

Vous devriez peut-être avoir une classe de Plugin et ensuite mettre en Œuvre() une méthode.
- J'ai essayé d'utiliser unset comme décrit ci-dessus, mais il ne décharge l'instance de PlginImpl, mais la définition reste en mémoire (le 2e terme se trompe jamais). Déconstructeur ne fonctionne pas non plus.
InformationsquelleAutor Thomas Schultz

je voudrais faire une classe permettant de gérer le chargement des plugins

class pluginLoader {
  protected $_plugins = array();
  protected $_db;

  public function setDB($db) {
     $this->_db = $db;
  }


  public function load($plgFile) {
    if (!isset($this->_plugins[$plgFile])) {
      require_once( $plgFile );
      $plgin = new $plgFile();
      $plgin->setDb($this->_db);
      $this->_plugins[$plgFile] = $plgin;
    }
    $this->_plugins[$plgFile]->process();
  }

  public static function instance($db) {
    static $instance;

    if (!$instance instanceof self) {
        $instance = new self($db);
    }
    return $instance;
  }
}

et pour l'utiliser, il faudrait d'abord faire un

pluginLoader::instance($db);

et ensuite de charger un plugin

pluginLoader::instance()->load($plgFile);

Merci beaucoup - mais n'aurais-je pas exécuter dans exactement le même probleme qu'avant en raison du fait que tous les plugins sont appelés "PlginImpl" ?
combiné avec la solution ci-dessus et d'utiliser les noms de plugin pour le fichier de classe

InformationsquelleAutor Gabriel Solomon

Vous devez vous connecter pour publier un commentaire.