Question

我正在编写一个脚本，我需要让它可插入。现在我已经提到的语法应该对我有用，就是让它使用类。例如，为了创建一个在达到特定点（钩子）时运行的新插件，您将声明一个新类。我不确定如何在该语法中指定钩子，所以我正在寻找建议。

语法示例：

<?php
class ScriptPlugin
{
    function runPlugin() {} // would be run when the time has to come to execute this plugin
}
?>

另外，如果这种语法不起作用，那么如果你们能给我一个很好的语法示例那就太棒了。

Answer 1

我想到了 Observer Pattern 。插件将自行注册，并在调用挂钩时收到通知。

我想到的另一件事是PHP中的回调。我想到了一个similar question already an answer。它显示基于回调的钩子。

观察者模式运行有点短，因为有了钩子，你经常想要提供诸如参数和返回值之类的东西。使用回调的链接答案也没有这个，所以我写了一个小Hooks示例类，它为注册的回调提供了命名的钩子/事件，以及一种注册自己的类的方法，例如：一个插件。

这个想法很基本：

一个钩子有一个名字，附有零个或多个回调。
所有挂钩均在Hooks类中管理。
主代码通过调用Hooks对象上的函数来调用钩子。
插件（和其他类）可以注册自己的回调，这是在Registerable界面的帮助下完成的。

一些带有一个插件和两个钩子的示例代码：

<?php
Namespace Addon;

class Hooks
{
    private $hooks = array();
    private $arguments;
    private $name;
    private $return;
    public function __call($name, array $arguments)
    {
        $name = (string) $name;
        $this->name = $name;
        $this->arguments = $arguments;
        $this->return  = NULL;
        foreach($this->getHooks($name) as $hook)
        {
            $this->return = call_user_func($hook, $this);
        }
        return $this->return;
    }
    public function getHooks($name)
    {
        return isset($this->hooks[$name]) ? $this->hooks[$name] : array();
    }
    public function getArguments()
    {
        return $this->arguments;
    }
    public function getName()
    {
        return $this->name;
    }
    public function getReturn()
    {
        return $this->return;
    }
    public function setReturn($return)
    {
        $this->return = $return;
    }
    public function attach($name, $callback)
    {
        $this->hooks[(string) $name][] = $callback;
    }
    public function register(Registerable $plugin)
    {
        $plugin->register($this);
    }
}

interface Registerable
{
    public function register(Hooks $hooks);
}

class MyPlugin implements Registerable
{
    public function register(Hooks $hooks)
    {
        $hooks->attach('postPublished', array($this, 'postPublished'));
        $hooks->attach('postDisplayFilter', array($this, 'filterToUpper'));
    }
    public function postPublished()
    {
        echo "MyPlugin: postPublished.\n";
    }
    public function filterToUpper(Hooks $context)
    {
        list($post) = $context->getArguments();
        return strtoupper($post);
    }
}

$hooks = new Hooks();

$plugin = new MyPlugin();
$hooks->register($plugin);  

$hooks->postPublished();

echo $hooks->postDisplayFilter("Some post text\n");

我这样做是为了防止每个Plugin必须只有一个具体的基类，因为它想要使用钩子。此外，一切都可以注册钩子，唯一需要的是回调。例如匿名函数：

$hooks->attach('hookName', function() {echo "Hook was called\n";});

但是，您可以自己创建一个插件基类，例如实现register函数，并自动注册具有特定docblock标记或函数名称的函数

class MyNewPlugin extends PluginSuper
{
    /**
     * @hook postPublished
     */
    public function justAnotherFunction() {}

    public hookPostPublished() {}
}

超类可以使用Reflection在运行时添加钩子。但是，反射可能会减慢速度，并可能使调试变得更加困难。

Answer 2

我会创建一个基本抽象类，其中包含可能被调用的所有钩子的函数。

abstract class Plugin {
    abstract function yourHook();
}

所有插件类都应继承此基类，并将使用自己的。

覆盖这些基本函数

class SomePlugin extends Plugin {
    function yourHook() {
        echo 'yourHook() Called!';
    }
}

现在，当你的程序运行时，你需要找到所有要包含的插件文件，并以某种方式将它们放入一个数组中，例如$plugins。请参阅此文章：https://stackoverflow.com/a/599694/362536

foreach (glob("classes/*.php") as $filename)
{
    include $filename;
}

（来自Karsten）

定义可从所有内容访问的功能，例如registerPlugin()：

function registerPlugin($classname) {
    $plugins[] = new $classname();
}

使每个插件文件的顶行如此（在课前）：

registerPlugin('SomePlugin');

如果你这样做，你将在$plugins中有一个包含每个插件实例的数组。在适当的时候，你可以这样做：

foreach ($plugins as $plugin) {
    $plugin->yourHook();
}

作为替代方案，在您的情况下使用interfaces可能更合适。您应该决定哪种方法最适合您的应用。

Answer 3

让我们说一个插件就像：

class NewsPlugin extends Plugin
{
  function onCreate($title)
  {
    # Do some stuff
  }
}

然后，当您创建新闻时，您可以在已注册的所有插件上调用onCreate。

使脚本可插入

3 个答案: