Comment définir un fichier comme plug-in en php

Comment définir un fichier comme plug-in en php ? Une solution d'implémentation du mécanisme de plug-in en PHP

Plug-in, également connu sous le nom de Plug-in, fait référence à un type spécifique de module fonctionnel (généralement implémenté par des développeurs tiers). les caractéristiques sont les suivantes : activez-le lorsque vous en avez besoin, désactivez-le lorsque vous n'en avez pas besoin ; et qu'il soit activé ou désactivé, cela n'affectera pas le fonctionnement du module central du système. -in est une conception modulaire non intrusive qui permet un couplage lâche des programmes principaux et des plug-ins. Un exemple typique est celui des nombreux plug-ins tiers présents dans WordPress, comme le plug-in Akimet, utilisé pour filtrer le spam sur les commentaires des utilisateurs.

Un mécanisme de plug-in robuste, je pense, doit avoir les caractéristiques suivantes :

● Surveillance et chargement dynamiques des plug-ins (Lookup)

● Déclenchement dynamique de plug-ins

La mise en œuvre des deux points ci-dessus n'affectera pas le fonctionnement du programme principal

Pour implémenter des plug-ins dans le programme, la première chose que nous devrait penser est de définir différents hooks (Hooks); "Hooks" C'est un concept logique très vivant. Vous pouvez le considérer comme une condition de déclenchement de plug-in réservée par le système. Son principe logique est le suivant : lorsque le système exécute un certain hook, il déterminera si les conditions du hook sont remplies, si elles sont remplies, il appellera d'abord la fonction spécifiée par le hook, puis reviendra pour continuer l'exécution du hook ; reste du programme ; si ce n’est pas le cas, il appellera d’abord la fonction spécifiée par le hook , ignorez-la simplement. C'est un peu la logique de "protection contre les interruptions" en assemblage.

Certains hooks peuvent avoir été conçus par le système à l'avance, comme le hook que j'ai mentionné plus tôt à propos du filtrage du spam dans les commentaires. Il a généralement été conçu par les développeurs du système principal dans la logique de traitement des commentaires ; être personnalisé par les utilisateurs (développés par des développeurs tiers) et existe généralement dans la couche de présentation, comme une page d'affichage de formulaire PHP ordinaire.

Peut-être trouvez-vous les mots ci-dessus ennuyeux et somnolents, mais pour comprendre le code que j'ai écrit ci-dessous, il est essentiel de comprendre les principes ci-dessus ;

Ce qui suit est l'implémentation principale du mécanisme de plug-in en PHP. Le cœur de l'ensemble du mécanisme est divisé en trois parties principales :

Une classe de gestionnaire de plug-in : c'est la classe. noyau du noyau. Il s’agit d’un objet Global d’application. Il a trois responsabilités principales :

● Responsable de la surveillance de tous les plug-ins enregistrés et de l'instanciation de ces objets plug-in.

● Responsable de l'enregistrement de tous les plug-ins.

● Lorsque la condition de hook est remplie, la méthode objet correspondante est déclenchée.

Implémentation de la fonction du plug-in : ceci est principalement effectué par des développeurs tiers, mais certaines règles doivent être respectées. Cette règle est stipulée par le mécanisme du plug-in et varie en fonction du mécanisme du plug-in. Vous verrez le code d'affichage suivant Voir cette règle.

Déclenchement du plug-in : c'est-à-dire la condition de déclenchement du hook. Plus précisément, il s'agit d'un petit morceau de code placé là où vous avez besoin de l'implémentation du plug-in pour déclencher ce hook.

J'ai parlé de beaucoup de principes, jetons un œil à mon plan de mise en œuvre :

Plugin Manager Classe PluginManager :

<?
/**
* STBLOG PluginManager Class
*
* 插件机制的实现核心类
*
* @package        STBLOG
* @subpackage    Libraries
* @category    Libraries
* @author        Saturn
*/
class PluginManager
{
    /**
     * 监听已注册的插件
     *
     * @access private
     * @var array
     */
    private $_listeners = array();
     /**
     * 构造函数
     *  
     * @access public
     * @return void
     */
    public function __construct()
    {
        #这里$plugin数组包含我们获取已经由用户激活的插件信息
     #为演示方便，我们假定$plugin中至少包含
     #$plugin = array(
        #    &#39;name&#39; => &#39;插件名称&#39;,
        #    &#39;directory&#39;=>&#39;插件安装目录&#39;
        #);
        $plugins = get_active_plugins();#这个函数请自行实现
        if($plugins)
        {
            foreach($plugins as $plugin)
            {//假定每个插件文件夹中包含一个actions.php文件，它是插件的具体实现
                if (@file_exists(STPATH .&#39;plugins/&#39;.$plugin[&#39;directory&#39;].&#39;/actions.php&#39;))
                {
                    include_once(STPATH .&#39;plugins/&#39;.$plugin[&#39;directory&#39;].&#39;/actions.php&#39;);
                    $class = $plugin[&#39;name&#39;].&#39;_actions&#39;;
                    if (class_exists($class))  
                    {
                        //初始化所有插件
                        new $class($this);
                    }
                }
            }
        }
        #此处做些日志记录方面的东西
    }
     
    /**
     * 注册需要监听的插件方法（钩子）
     *
     * @param string $hook
     * @param object $reference
     * @param string $method
     */
    function register($hook, &$reference, $method)
    {
        //获取插件要实现的方法
        $key = get_class($reference).&#39;->&#39;.$method;
        //将插件的引用连同方法push进监听数组中
        $this->_listeners[$hook][$key] = array(&$reference, $method);
        #此处做些日志记录方面的东西
    }
    /**
     * 触发一个钩子
     *
     * @param string $hook 钩子的名称
     * @param mixed $data 钩子的入参
     *    @return mixed
     */
    function trigger($hook, $data=&#39;&#39;)
    {
        $result = &#39;&#39;;
        //查看要实现的钩子，是否在监听数组之中
        if (isset($this->_listeners[$hook]) && is_array($this->_listeners[$hook]) && count($this->_listeners[$hook]) > 0)
        {
            // 循环调用开始
            foreach ($this->_listeners[$hook] as $listener)
            {
                // 取出插件对象的引用和方法
                $class =& $listener[0];
                $method = $listener[1];
                if(method_exists($class,$method))
                {
                    // 动态调用插件的方法
                    $result .= $class->$method($data);
                }
            }
        }
        #此处做些日志记录方面的东西
        return $result;
    }
}
?>

Le code ci-dessus plus les commentaires ne doivent pas dépasser 100 lignes, ce qui complète le cœur de l'ensemble du mécanisme du plug-in. Ce qu'il faut expliquer à nouveau, c'est que vous devez la définir comme classe globale et la charger en premier là où le plug-in est nécessaire. Les endroits commentés par # sont les parties que vous devez compléter vous-même, y compris l'acquisition et la journalisation des plug-ins, etc.

Ce qui suit est l'implémentation d'un simple plug-in. ​​

<?
/**
* 这是一个Hello World简单插件的实现
*
* @package        DEMO
* @subpackage    DEMO
* @category    Plugins
* @author        Saturn
*/
/**
*需要注意的几个默认规则：
*    1. 本插件类的文件名必须是action
*    2. 插件类的名称必须是{插件名_actions}
*/
class DEMO_actions
{
    //解析函数的参数是pluginManager的引用
    function __construct(&$pluginManager)
    {
        //注册这个插件
        //第一个参数是钩子的名称
        //第二个参数是pluginManager的引用
        //第三个是插件所执行的方法
        $pluginManager->register(&#39;demo&#39;, $this, &#39;say_hello&#39;);
    }
     
    function say_hello()
    {
        echo &#39;Hello World&#39;;
    }
}
?>

Il s'agit d'un simple plug-in Hello World, utilisé pour générer une phrase. Dans des situations réelles, say_hello peut inclure des opérations sur la base de données, ou une autre logique spécifique, comme l'appel de l'API Akimet.

Les règles par défaut pour la mise en œuvre du plug-in sont déterminées par les développeurs du système principal eux-mêmes. Par exemple, j’ai clairement écrit certaines des règles par défaut dans cet exemple dans les commentaires, je n’entrerai donc pas dans les détails ici. Une attention particulière doit être portée à ne pas répéter les noms de crochets.

La dernière étape consiste à définir le déclenchement du hook. Là où vous placez le hook, la méthode du plug-in ci-dessus démarrera. Par exemple, si je veux mettre say_hello sur la page d'accueil de mon blog, Index.php, alors vous écrivez quelque part dans index.php :

$pluginManager->trigger('demo','');

Le premier paramètre représente le nom du hook, dans ce cas il est demo ; Le deuxième paramètre est le paramètre d'entrée de la méthode correspondante du plug-in. Puisqu'il n'y a pas de paramètres d'entrée dans cet exemple, il est vide.

Résumé

Cet article présente une méthode et une idée pour implémenter le mécanisme de plug-in en PHP, ainsi que ma propre compréhension du mécanisme de plug-in. Lorsque vous entrez en contact avec cette chose pour la première fois, elle peut vous paraître un peu inconnue et difficile à comprendre. Mais lorsque vous le combinez avec des exemples réels et réfléchissez au processus d’exécution du programme, l’idée peut devenir plus claire. Rendu :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!