如何设计插件式结构的程序，兼谈Python语言

为了扩充软件的功能，通常我们会把软件设计成插件式结构。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子目录里面放入两个文件：

#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语言实现起来更加的简洁。

或许听起来还有点玄奥。详细地说一下__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文件读取数据总是比较麻烦。推荐不包含没有数据文件的时候使用。

阅读全文

本文介绍的是，对于插件式应用程序的讲解，也很详细，我们废话不多说，先看内容。动态链接库技术使软件工程师们兽血沸腾，它使得应用系统（程序）可以以二进制模块的形式灵活地组建起来。比起源码级别的模块化，二进制级别的模块划分使得各模块更加独立，各模块可以分别编译和链接，模块的升级不会引起其它模块和主程序的重新编译，这点对于大系统的构建来说更加实用。另一方面，对于商业目的明显的企业，各模块可以独立设置访问权限，开发成员只能访问自己负责的模块，其它模块是不能也不给看到的，这样减少了整个系统泄漏技术的风险。一、动态链接库技术概况动态链接库技术用得很多。事实上，整个Windows就是由一个个动态链接库（DLL）构建起来的，不管是系统内核，或是系统调用的API封装，还是通用工具（如控制面板、ActiveX插件等），都是一个个动态链接库文件。动态链接库并不是微软独有的技术，它是软件工程发展到一定阶段的必然产物。在类Unix系统中，这种二进制可执行模块技术不叫动态链接库，而被称为共享对象或共享库，后缀名一般为.so（即Share Object的简写）。为简便，下文将统称这种动态链接的技术为DLL或共享库。其实，DLL文件跟普通的可执行文件差别不大，都是可执行文件嘛，装载到进程空间后，都是一些机器指令（函数代码）、内存分配（变量）等。在Windows中，这些可执行文件被称作PE/COFF格式文件，在Linux则称为ELF文件。从CPU的角度看来，程序中的各个要素，不管是函数还是变量，它们都是一个个地址，函数是入口地址，变量是访问地址；而C++的所谓类或对象，最后也被编译器肢解成了一个个变量和函数代码（这里是形象的说法，严谨技术解说请搜索C++对象模型）。DLL的装载（指导入进程空间，然后执行）方式比可执行文件的装载稍微复杂，因为它把模块链接过程推迟到了运行时。在动态链接库的装载过程中，首要任务就是解决地址重定向问题。我们知道，DLL装载到进程空间的位置（基址）是不确定的（动态装载嘛），即使DLL内部使用的函数调用和全局变量引用，在装载时都要重新计算其地址。Windows采用基址重定向（Rebasing）技术解决这一问题，而Linux采用地址无关代码（PIC，通过GOT和PLT表实现）技术。这两种技术各有优缺点。二、Qt中的动态链接库编程使用C++面向对象的类编写DLL是要注意很多细节的，主要是二进制（ABI）兼容问题。COM是一个很成功的例子，只要符合COM的规范，我们就能编写出很好的DLL来，然而COM是微软私生的，要想跨平台，我们还得另找它路。Qt的跨平台特性同样令人（至少是我）兽血沸腾。如果你认为QT仅仅是一个跨平台界面库，那就小看它了。我要说的是，它不但是一个通用的跨平台的面向对象的应用程序接口库（包括GUI、数据库、网络、多线程、XML、数据容器和算法等，常用的编辑资源都有封装，就是说，这些都可以跨平台，而不仅仅是界面），更是一种C++语言的扩展，一种编程平台和应用程序框架。信号和槽的机制简化了对象之间的通信，比MFC的消息映射直观多了；界面的布局管理机制使开发人员可以很轻松地编出优雅的窗体；界面语言翻译机制也很方便实用；QObject容器管理可以看到Qt在内存管理方面的努力；扩展的foreach循环结构也向现代语言靠拢……Qt的跨平台特性很好，对于本文的主题——动态链接库的支持也很好。QT对各种平台的动态链接库编程技术都有包装，QT把这种技术统一命名为共享库（Shared Libraries）。通过使用Qt包装过的类和宏，可以编写跨平台的共享库和插件——当然，这只是源代码级别的跨平台，你不要指望用MSVC编译出来的DLL，能集成到ARM平台的Linux程序上面——这是一个很美很美的理想哦。QT使用以下两个宏来实现符号（函数或全局变量/对象）的导出和导入（跨平台不能用def文件了）：Q_DECL_EXPORT // 必须添加到符号声明中（共享库项目） Q_DECL_IMPORT // 必须添加到符号声明中（使用共享库的客户项目） Q_DECL_EXPORT // 必须添加到符号声明中（共享库项目）Q_DECL_IMPORT // 必须添加到符号声明中（使用共享库的客户项目）QT使用 QLibrary 类实现共享库的动态加载，即在运行时决定加载那个DLL程序，插件机制使用。三、QT共享库和插件范例本节通过例子，实现一个共享库和一个插件。在Windows平台上开发，使用VS2005编译，QT库版本为4.6.2。本例了将编写以下三类项目：Bil 项目：共享库项目，输出Bil.dll和Bil.lib，基础接口类库，定义一个公共的接口IAnimal（抽象类），供客户项目和插件项目使用；Plugin 类项目：插件类项目，现编写BilDog和BilPanda两插件项目，实现IAnimal的功能，供客户项目加载和测试。两项目输出BilDog.dll和BilPanda.dll；Test 项目：客户应用程序项目，输出Test.exe，界面中可以选择要加载的Animal插件，然后调用Animal的功能函数，完成测试；1. 编写共享库——Bil 项目的实现该项目定义一个抽象的 IAnimal 类作为导出接口，供客户项目和插件项目使用。项目类型为共享库，将生成Bil.lib和Bil.dll两个文件，Bil.lib供Plugin项目和Test 项目引用，而Bil.dll将给Test.exe运行时动态加载。新建一个头文件Bil.h，输入如下代码：view plaincopy to clipboardprint? #ifndef BIL_H #define BIL_H #include <Qt/qglobal.h>// 定义BIL_SHARE，使用者可以不用再处理符号的导入和导出细节 #ifdef BIL_LIB # define BIL_SHARE Q_DECL_EXPORT #else # define BIL_SHARE Q_DECL_IMPORT #endif #endif // BIL_H #ifndef BIL_H #define BIL_H #include <Qt/qglobal.h>// 定义BIL_SHARE，使用者可以不用再处理符号的导入和导出细节 #ifdef BIL_LIB # define BIL_SHARE Q_DECL_EXPORT #else # define BIL_SHARE Q_DECL_IMPORT #endif #endif // BIL_H 你现在可能不知道BIL_SHARE宏有何用处。没关系，请继续看下面的IAnimal接口定义代码：view plaincopy to clipboardprint? #ifndef IANIMAL_H #define IANIMAL_H #include "Bil.h" class BIL_SHARE IAnimal { public: IAnimal()virtual ~IAnimal()public: virtual void Eat() = 0virtual void Run() = 0virtual void Sleep() = 0}#endif // IANIMAL_H #ifndef IANIMAL_H #define IANIMAL_H #include "Bil.h" class BIL_SHARE IAnimal { public: IAnimal()virtual ~IAnimal()public: virtual void Eat() = 0virtual void Run() = 0virtual void Sleep() = 0}#endif 现在知道BIL_SHARE宏的妙用了吧。BIL_SHARE宏会根据项目编译选项BIL_LIB有没有定义，自动声明IAnimal是导出类，还是导入类。所以，使用BIL_SHARE宏，我们只需要向IAnimal插件的开发者提供同一份IAnimal定义文件（IAnimal.h）即可。当然，我们得先在Bil项目的编译选项中定义BIL_LIB宏，使得在Bil项目内，BIL_SHARE就是导出符号的声明。插件项目就不要定义BIL_LIB了，因为在Animal插件项目中，IAnimal是导入符号。编译选项如何定义宏？如果使用Visual Studio工程文件，依次展开：项目属性->配置属性->C/C++->预处理器，在预处理器定义中添加宏BIL_LIB即可；如果是QT工程文件，请在QT工程文件Bil.pro中加入如下定义：DEFINES += BIL_LIB DEFINES += BIL_LIB 在IAnimal接口中，我们定义了三个纯虚函数Eat()、Run()和Sleep()，表示吃、跑和睡眠的动作，这是抽象的，因为不同的动物有不同的吃相和睡眠姿态，而世间的动物何止千千万——无所谓，让这些具体动物的不同表现交给IAnimal插件的编写者发挥吧——这就是接口的魅力，加上插件的思想，整个应用程序就变成开放的，可扩展的了！继续编写Anima类的实现文件Anima.cpp：view plaincopy to clipboardprint? #include "IAnimal.h" IAnimal::IAnimal() { } IAnimal::~IAnimal() { } #include "IAnimal.h" IAnimal::IAnimal() { } IAnimal::~IAnimal() { } 虽然只实现了构造和析构函数，并且什么工作也不做，但这是必要的，我们暂时不要使用内联的构造和析构函数，否则在插件项目实现IAnimal时可能会出现链接错误。好了，我们开始编译吧，生成整个Bil项目。最终我们得到两个输出文件：Bil.lib 和 Bil.dll。我们向Animal插件开发者提供：两个头文件：Bil.h 和 IAnimal.h两个库文件：Bil.lib 和 Bil.dll下面的插件类项目和客户项目就是依赖这些文件实现的，也许你更愿意把Bil看作是一个通用的DLL类库，就像QT或MFC一样——事实上也是如此，Bil就是这样一个动态的共享类库。2. 编写Animal插件——BilDog和BilPanda项目的实现现在，让我们来实现两个小插件。BilDog插件很简单，只是汇报下“我是Dog，我正在啃骨头”；BilPanda也是如此——这里仅仅是测试而已，实现的项目中，你可以尽情的发挥——没错，是在遵循IAnimal接口的前提下。创建BilDog项目，把Bil项目输出的Bil.h、IAnimal.h和Bil.lib加入到工程。创建Dog类的头文件Dog.h： view plaincopy to clipboardprint? #ifndef CLASS_DOG_H #define CLASS_DOG_H #include "IAnimal.h" class Dog : public IAnimal { public: Dog(void)virtual ~Dog(void)public: virtual void Eat()virtual void Run()virtual void Sleep()}#endif // CLASS_DOG_H #ifndef CLASS_DOG_H #define CLASS_DOG_H #include "IAnimal.h" class Dog : public IAnimal { public: Dog(void)virtual ~Dog(void)public: virtual void Eat()virtual void Run()virtual void Sleep()}#endif 创建Dog类的实现文件Dog.cpp：view plaincopy to clipboardprint? #include <QtGui/QMessageBox>#include "Dog.h" Dog::Dog(void) { } Dog::~Dog(void) { } void Dog::Eat() { QMessageBox::information(NULL, "Hello", "Dog eating ...")} void Dog::Run() { QMessageBox::information(NULL, "Hello", "Dog running ...")} void Dog::Sleep() { QMessageBox::information(NULL, "Hello", "Dog sleeping ...")} #include <QtGui/QMessageBox>#include "Dog.h" Dog::Dog(void) { } Dog::~Dog(void) { } void Dog::Eat() { QMessageBox::information(NULL, "Hello", "Dog eating ...")} void Dog::Run() { QMessageBox::information(NULL, "Hello", "Dog running ...")} void Dog::Sleep() { QMessageBox::information(NULL, "Hello", "Dog sleeping ...")} 调用QT的QMessageBox::information()函数d出一个信息提示框。还有一个非常重要的工作，我们得提供一个能够创建（释放）Animal具体对象（这里是Dog）的接口，并且把这些函数导出，让主程序（Test.exe）能够解析这个接口函数，动态创建Animal对象，并访问其功能。新建BilDog.h文件，输入下面的代码：view plaincopy to clipboardprint? #ifndef BILDOG_H #define BILDOG_H #include "Dog.h" // extern "C" 生成的导出符号没有任何修饰，方便主程序找到它 extern "C" { Q_DECL_EXPORT IAnimal * CreateAnimal()Q_DECL_EXPORT void ReleaseAnimal(IAnimal * animal)} #endif // BILDOG_H #ifndef BILDOG_H #define BILDOG_H #include "Dog.h" // extern "C" 生成的导出符号没有任何修饰，方便主程序找到它 extern "C" { Q_DECL_EXPORT IAnimal * CreateAnimal()Q_DECL_EXPORT void ReleaseAnimal(IAnimal * animal)} #endif 这两个函数的工作很简单，直接创建和释放对象即可。

我自己测试了一下，在Winform项目里面新建一个类库，添加资源文件，粘贴图片进去，访问修饰符改成public，然后在启动项目里面引用，然后下面的代码成功显示了图片。不知道这与你的有多少差别？

pictureBox1.Image = ClassLibrary1.Resource1.a

---