基于Python的插件式系统结构试验

时间 2019-11-06

原文原文链接

因为Python支持运行时动态载入，设计一个插件式结构是比较简单的。若是使用PyQt的话，能够轻松地建立出一个插件式的UI结构。不过，在不少时候，主程序使用C++/STL编写，经过Python来实现插件扩展。这里主要探讨“纯Python”实现的插件结构。C++Python的模式后面再说（可参考，C++嵌入Python: http://my.oschina.net/u/2306127/blog/370001）。javascript

若是要经过C++编写一个Python模块进行加载，能够参考：http://my.oschina.net/u/2306127/blog/369997。java

为了扩充软件的功能，一般咱们会把软件设计成插件式结构。Python这样的动态语言天生就支持插件式编程。与C++相比，Python已经定义好模块的接口，想要载入一个插件，一个__import__()就能很轻松地搞定。不须要特定的底层知识。并且与C++等静态语言相比，Python的插件式结构更显灵活。由于插件载入后，能够利用Python语言的动态性，充分地修改核心的逻辑。程序员

简单地说一个__import__()可能不大清楚。如今就来看一个最简单的插件式结构程序。它会扫描plugins文件夹下的全部.py文件。而后把它们载入。编程

#-*- encoding: utf-8 -*-#main1.pyimport osclass Platform:
    def __init__(self):
        self.loadPlugins()

    def sayHello(self, from_):
        print "hello from %s." % from_

    def loadPlugins(self):
        for filename in os.listdir("plugins"):
            if not filename.endswith(".py") or filename.startswith("_"):
                continue
            self.runPlugin(filename)

    def runPlugin(self, filename):
        pluginName=os.path.splitext(filename)[0]
        plugin=__import__("plugins."+pluginName, fromlist=[pluginName])
        #Errors may be occured. Handle it yourself.
        plugin.run(self)if __name__=="__main__":
    platform=Platform()

而后在plugins子目录里面放入两个文件：app

#plugins1.pydef run(platform):
    platform.sayHello("plugin1")#plugins2.pydef run(platform):
    platform.sayHello("plugin2")

再建立一个空的__init__.py在plugins文件夹里面。从package里面导入模块的时候，Python要求一个__init__.py。函数

运行main1.py，看一下运行的结果。首先是打印一下文件夹结构方便你们理解：网站

h:\projects\workon\testplugins>tree /f /a
卷 Data 的文件夹 PATH 列表
卷序列号为 ****-****
H:.
|   main1.py
|
\---plugins
        plugin1.py
        plugin2.py
        __init__.py

h:\projects\workon\testplugins>main1.py
hello from plugin1.
hello from plugin2.

通常地，载入插件前要首先扫描插件，而后依次载入并运行插件。咱们上面的示例程序main1.py也是如此，分为两个函数。第一个loadPlugins()扫描插件。它把plugins目录下面全部.py的文件除了__init__.py都当成插件。runPlugin()载入并运行插件。其中两个关键：使用__import__()函数把插件当成模块导入，它要求全部的插件都定义一个run()函数。各类语言实现的插件式结构其实也基本上分为这两个步骤。所不一样的是，Python语言实现起来更加的简洁。.net

或许听起来还有点玄奥。详细地说一下__import__()。它和常见的import语句很类似，只不过换成函数形式而且返回模块以供调用。import module至关于__import__("module")，from module import func至关于__import__("module", fromlist=["func"])，不过与想象有点不一样，import package.module至关于__import__("package.module", fromlist=["module"])。插件

如何调用插件通常有个约定。像咱们这里就约定每一个插件都实现一个run()。有时候还能够约定实现一个类，而且要求这个类实现某个管理接口，以方便核心随时启动、中止插件。要求全部的插件都有这几个接口方法：设计

#interfaces.pyclass Plugin:
    def setPlatform(self, platform):
        self.platform=platform

    def start(self):
        pass

    def stop(self):
        pass

想要运行这个插件，咱们的runPlugin()要改一改，另外增长一个shutdown()来中止插件:

class Platform:
    def __init__(self):
        self.plugins=[]
        self.loadPlugins()

    def sayHello(self, from_):
        print "hello from %s." % from_

    def loadPlugins(self):
        for filename in os.listdir("plugins"):
            if not filename.endswith(".py") or filename.startswith("_"):
                continue
            self.runPlugin(filename)

    def runPlugin(self, filename):
        pluginName=os.path.splitext(filename)[0]
        plugin=__import__("plugins."+pluginName, fromlist=[pluginName])
        clazz=plugin.getPluginClass()
        o=clazz()
        o.setPlatform(self)
        o.start()
        self.plugins.append(o)

    def shutdown(self):
        for o in self.plugins:
            o.stop()
            o.setPlatform(None)
        self.plugins=[]if __name__=="__main__":
    platform=Platform()
    platform.shutdown()

插件改为这样：

#plugins1.pyclass Plugin1:
    def setPlatform(self, platform):
        self.platform=platform

    def start(self):
        self.platform.sayHello("plugin1")

    def stop(self):
        self.platform.sayGoodbye("plugin1")def getPluginClass():
    return Plugin1#plugins2.pydef sayGoodbye(self, from_):
    print "goodbye from %s." % from_class Plugin2:
    def setPlatform(self, platform):
        self.platform=platform
        if platform is not None:
            platform.__class__.sayGoodbye=sayGoodbye

    def start(self):
        self.platform.sayHello("plugin2")

    def stop(self):
        self.platform.sayGoodbye("plugin2")def getPluginClass():
    return Plugin2

运行结果：

h:\projects\workon\testplugins>main.py
hello from plugin1.
hello from plugin2.
goodbye from plugin1.
goodbye from plugin2.

详细观察的朋友们可能会发现，上面的main.py,plugin1.py, plugin2.py干了好几件使人惊奇的事。

首先，plugin1.py和plugin2.py里面的插件类并无继承自interfaces.Plugin，而platform仍然能够直接调用它们的start()和stop()方法。这件事在Java、C++里面多是件麻烦的事情，可是在Python里面倒是件稀疏日常的事，仿佛吃饭喝水通常正常。事实上，这正是Python鼓励的约定编程。Python的文件接口协议就只规定了read(), write(), close()少数几个方法。多数以文件做为参数的函数均可以传入自定义的文件对象，只要实现其中一两个方法就好了，而没必要实现一个什么FileInterface。若是那样的话，须要实现的函数就多了，可能要有十几个。

再仔细看下来，getPluginClass()能够把类型当成值返回。其实不止是类型，Python的函数、模块均可以被当成普通的对象使用。从类型生成一个实例也很简单，直接调用clazz()就建立一个对象。不只如此，Python还可以修改类型。上面的例子咱们就演示了如何给Platform增长一个方法。在两个插件的stop()里面咱们都调用了sayGoodbye()，可是仔细观察Platform的定义，里面并无定义。原理就在这里：

#plugins2.pydef sayGoodbye(self, from_):
    print "goodbye from %s." % from_class Plugin2:
    def setPlatform(self, platform):
        self.platform=platform
        if platform is not None:
            platform.__class__.sayGoodbye=sayGoodbye

这里首先经过platform.__class__获得Platform类型，而后Platform.sayGoodbye=sayGoodbye新增了一个方法。使用这种方法，咱们可让插件任意修改核心的逻辑。这正在文首所说的Python实现插件式结构的灵活性，是静态语言如C++、Java等没法比拟的。固然，这只是演示，我不大建议使用这种方式，它改变了核心的API，可能会给其它程序员形成困惑。可是能够采用这种方式替换原来的方法，还可以利用“面向切面编程”，加强系统的功能。

接下来咱们还要再改进一下载入插件的方法，或者说插件的布署方法。前面咱们实现的插件体系主要的缺点是每一个插件只能有一个源代码。若是想附带一些图片、声音数据，又怕它们会和其它的插件冲突。即便不冲突，下载时分红单独的文件也不方便。最好是把一个插件压缩成一个文件供下载安装。

Firefox是一个支持插件的著名软件。它的插件以.xpi做为扩展名，其实是一个.zip文件，里面包含了javascript代码、数据文件等不少内容。它会把插件包下载复制并解压到%APPDATA%\Mozilla\Firefox\Profiles\XXXX.default\extensions里面，而后调用其中的install.js安装。与此相似，实用的Python程序也不大可能只有一个源代码，也要像Firefox那样支持.zip包格式。

实现一个相似于Firefox那样的插件布署体系并不会很难，由于Python支持读写.zip文件，只要写几行代码来作压缩与解压缩就好了。首先要看一下zipfile这个模块。用它解压缩的代码以下：

import zipfile, osdef installPlugin(filename):
    with zipfile.ZipFile(filename) as pluginzip:
        subdir=os.path.splitext(filename)[0]
        topath=os.path.join("plugins", subdir)
        pluginzip.extractall(topath)

ZipFile.extractall()是Python 2.6后新增的函数。它直接解压全部压缩包内的文件。不过这个函数只能用于受信任的压缩包。若是压缩包内包含了以/或者盘符开始的绝对路径，颇有可能会损坏系统。推荐看一下zipfile模块的说明文档，事先过滤非法的路径名。

这里只有解压缩的一小段代码，安装过程的界面交互相关的代码不少，不可能在这里举例说明。我以为UI是很是考验软件设计师的部分。常见的软件会要求用户到网站上查找并下载插件。而Firefox和KDE提供了一个“组件(部件)管理界面”，用户能够直接在界面内查找插件，查看它的描述，而后直接点击安装。安装后，咱们的程序遍历插件目录，载入全部的插件。通常地，软件还须要向用户提供插件的启用、禁用、依赖等功能，甚至可让用户直接在软件界面上给插件评分，这里就再也不详述了。

有个小技巧，安装到plugins/subdir下的插件能够经过__file__获得它本身的绝对路径。若是这个插件带有图片、声音等数据的时候，能够利用这个功能载入它们。好比上面的plugin1.py这个插件，若是它想在启动的时候播放同目录的message.wav，能够这样子：

#plugins1.pyimport osdef alert():
    soundFile=os.path.join(os.path.dirname(__file__), "message.wav")
    try:
        import winsound
        winsound.PlaySound(soundFile, winsound.SND_FILENAME)
    except (ImportError, RuntimeError):
        passclass Plugin1:
    def setPlatform(self, platform):
        self.platform=platform

    def start(self):
        self.platform.sayHello("plugin1")
        alert()

    def stop(self):
        self.platform.sayGoodbye("plugin1")def getPluginClass():
    return Plugin1

接下来咱们再介绍一种Python/Java语言经常使用的插件管理方式。它不须要事先有一个插件解压过程，由于Python支持从.zp文件导入模块，很相似于Java直接从.jar文件载入代码。所谓安装，只要简单地把插件复制到特定的目录便可，Python代码自动扫描并从.zip文件内载入代码。下面是一个最简单的例子，它和上面的几个例子同样，包含一个main.py，这是主程序，一个plugins子目录，用于存放插件。咱们这里只有一个插件，名为plugin1.zip。plugin1.zip有如下两个文件，其中description.txt保存了插件内的入口函数和插件的名字等信息，而plugin1.py是插件的主要代码:

description.txt
plugin1.py

其中description.txt的内容是:

[general]name=plugin1description=Just a test code=plugin1.Plugin1

plugin1.py与前面的例子相似，为了省事，咱们去掉了stop()方法，它的内容是:

class Plugin1:
    def setPlatform(self, platform):
        self.platform=platform

    def start(self):
        self.platform.sayHello("plugin1")

重写的main.py的内容是:

# -*- coding: utf-8 -*-import os, zipfile, sys, ConfigParserclass Platform:
    def __init__(self):
        self.loadPlugins()

    def sayHello(self, from_):
        print "hello from %s." % from_

    def loadPlugins(self):
        for filename in os.listdir("plugins"):
            if not filename.endswith(".zip"):
                continue
            self.runPlugin(filename)

    def runPlugin(self, filename):
        pluginPath=os.path.join("plugins", filename)
        pluginInfo, plugin = self.getPlugin(pluginPath)
        print "loading plugin: %s, description: %s" % \                (pluginInfo["name"], pluginInfo["description"])
        plugin.setPlatform(self)
        plugin.start()

    def getPlugin(self, pluginPath):
        pluginzip=zipfile.ZipFile(pluginPath, "r")
        description_txt=pluginzip.open("description.txt")
        parser=ConfigParser.ConfigParser()
        parser.readfp(description_txt)
        pluginInfo={}
        pluginInfo["name"]=parser.get("general", "name")
        pluginInfo["description"]=parser.get("general", "description")
        pluginInfo["code"]=parser.get("general", "code")

        sys.path.append(pluginPath)
        moduleName, pluginClassName=pluginInfo["code"].rsplit(".", 1)
        module=__import__(moduleName, fromlist=[pluginClassName, ])
        pluginClass=getattr(module, pluginClassName)
        plugin=pluginClass()
        return pluginInfo, pluginif __name__=="__main__":
    platform=Platform()

与前一个例子的主要不一样之处是getPlugin()。它首先从.zip文件内读取描述信息，而后把这个.zip文件添加到sys.path里面。最后与前面相似地导入模块并执行。

解压仍是不解压，两种方案各有优劣。通常地，把.zip文件解压到独立的文件夹内须要一个解压缩过程，或者是人工解压，或者是由软件解压。解压后的运行效率会高一些。而直接使用.zip包的话，只须要让用户把插件复制到特定的位置便可，可是每次运行的时候都须要在内存里面解压缩，效率下降。另外，从.zip文件读取数据老是比较麻烦。推荐不包含没有数据文件的时候使用。