How to set a file as a plug-in in php

#How to set a file as a plug-in in php? An implementation solution for the plug-in mechanism in PHP

Plug-in, also known as Plug-in, refers to a specific type of functional module (usually implemented by third-party developers). Its characteristics are: Activate it when you need it, disable/delete it when you don't need it; and whether it is activated or disabled, it will not affect the operation of the core module of the system. In other words, the plug-in is a non-intrusive modular design that achieves Loose coupling of core programs and plug-ins. A typical example is the numerous third-party plug-ins in WordPress, such as the Akimet plug-in, which is used to filter spam on user comments.

A robust plug-in mechanism, I think, must have the following characteristics:

● Dynamic monitoring and loading of plug-ins (Lookup)

● Dynamic triggering of plug-ins

The implementation of the above two points will not affect the operation of the core program

To implement plug-ins in the program, the first thing we should think of is to define different hooks (Hooks); "Hooks" It is a very vivid logical concept. You can think of it as a plug-in trigger condition reserved by the system. Its logic principle is as follows: when the system executes a certain hook, it will determine whether the conditions of the hook are met; if it is met, it will first call the function specified by the hook, and then return to continue executing the rest of the program; if it is not met, it will first call the function specified by the hook. , just skip it. This is a bit like "interrupt protection" logic in assembly.

Some hooks may have been designed by the system in advance. For example, the hook I mentioned earlier about comment spam filtering has usually been designed by the core system developers into the comment processing logic; another category Hooks may be customized by users (developed by third-party developers) and usually exist in the presentation layer, such as an ordinary PHP form display page.

Maybe you find the above words boring and drowsy; but to understand the code I wrote below, it is essential to understand the above principles.

The following is the core implementation of the plug-in mechanism in PHP. The entire mechanism is divided into three major blocks:

A plug-in manager class: This is the core of the core. It is an application global Global object. It has three main responsibilities:

● Responsible for monitoring all registered plug-ins and instantiating these plug-in objects.

● Responsible for registering all plug-ins.

● When the hook condition is met, the corresponding object method is triggered.

Plug-in function implementation: This is mostly done by third-party developers, but certain rules need to be followed. This rule is stipulated by the plug-in mechanism and varies depending on the plug-in mechanism. You will see the following display code See this rule.

Triggering of the plug-in: that is, the triggering condition of the hook. Specifically, this is a small piece of code that is placed where you need the plug-in implementation to trigger this hook.

I talked about a lot of principles, let’s take a look at my implementation plan:

Plugin Manager PluginManager class:

 '插件名称',
        #    'directory'=>'插件安装目录'
        #);
        $plugins = get_active_plugins();#这个函数请自行实现
        if($plugins)
        {
            foreach($plugins as $plugin)
            {//假定每个插件文件夹中包含一个actions.php文件，它是插件的具体实现
                if (@file_exists(STPATH .'plugins/'.$plugin['directory'].'/actions.php'))
                {
                    include_once(STPATH .'plugins/'.$plugin['directory'].'/actions.php');
                    $class = $plugin['name'].'_actions';
                    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).'->'.$method;
        //将插件的引用连同方法push进监听数组中
        $this->_listeners[$hook][$key] = array(&$reference, $method);
        #此处做些日志记录方面的东西
    }
    /**
     * 触发一个钩子
     *
     * @param string $hook 钩子的名称
     * @param mixed $data 钩子的入参
     *    @return mixed
     */
    function trigger($hook, $data='')
    {
        $result = '';
        //查看要实现的钩子，是否在监听数组之中
        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;
    }
}
?>

The above code plus comments should not exceed 100 lines, which completes the core of the entire plug-in mechanism. What needs to be explained again is that you must set it as a global class and load it first wherever the plug-in is needed. The places commented with # are the parts you need to complete yourself, including plug-in acquisition and logging, etc.

The following is the implementation of a simple plug-in.​​

register('demo', $this, 'say_hello');
    }
     
    function say_hello()
    {
        echo 'Hello World';
    }
}
?>

This is a simple Hello World plug-in, used to output a sentence. In actual situations, say_hello may include operations on the database, or some other specific logic, such as calling the Akimet API.

The default rules for plug-in implementation are determined by the core system developers themselves. For example, I have clearly written some of the default rules in this example in the comments, so I won’t go into details here. Special attention should be paid to not repeating hook names.

The last step is to define the triggering of the hook. Where you place the hook, the method of the above plug-in will start. For example, if I want to put say_hello on the home page of my blog, Index.php, then you write somewhere in index.php:

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

The first parameter represents the name of the hook, in this case it is demo; The second parameter is the entry parameter of the corresponding method of the plug-in. Since there are no input parameters in this example, it is empty.

Summary

This article introduces a method and idea of ​​​​implementing the plug-in mechanism in PHP, as well as my own understanding of the plug-in mechanism. When you first come into contact with this thing, it may be a bit unfamiliar and difficult to understand. But when you combine it with real examples and think about the running process of the program, the idea may become clearer. Rendering:

The above is the detailed content of How to set a file as a plug-in in php. For more information, please follow other related articles on the PHP Chinese website!