Spring Boot Pf4j模块化能力设计方案小结_Java

前言

上一篇文章我们浅尝辄止模块化整体概览，所谓模块化基础设施则是基于pf4j二次封装，我们具体到底要实现哪些，本篇我们从pf4j开始讲解，我们深挖细节。

模块化基础设施

pf4j官方有基本介绍以及对整个框架的架构等等，我们不再浪费口舌。如下是通过ai总结pf4j的能力所导出的时序图，基本上算是那么回事，给不了解pf4j能力的童鞋留个基本印象

基于上述pf4j的基本能力概括（启动、停止、热加载/卸载、销毁、扩展点），我们先抛开封装涉及web应用的基础能力，我们再来思考一个问题：模块化框架还应具备哪些能力？以此再对照深入p4fj实现细节确认是否能扩展增强或者对底层复杂实现进行简化等等，如下我们一一抽丝剥茧且化繁为简以及直接给出若不支持如何扩展实现（注：pf4j既支持jar包也支持将jar打包成zip，我们仅以原始jar包为例讲解，zip的jar包无非多了一步将jar包解压等等，逻辑大同小异）

插件目录自定义

public static final string plugins_dir_property_name = "pf4j.pluginsdir";
public static final string mode_property_name = "pf4j.mode";
public static final string default_plugins_dir = "plugins";
public static final string development_plugins_dir = "../plugins";
 protected void initialize() {
        if (pluginsroots.isempty()) {
            pluginsroots.addall(createpluginsroot());
        }
}
protected final list<path> pluginsroots = new arraylist<>();
protected list<path> createpluginsroot() {
        string pluginsdir = system.getproperty(plugins_dir_property_name);
        if (pluginsdir != null && !pluginsdir.isempty()) {
            return arrays.stream(pluginsdir.split(","))
                .map(string::trim)
                .map(paths::get)
                .collect(collectors.tolist());
        }
        pluginsdir = isdevelopment() ? development_plugins_dir : default_plugins_dir;
        return collections.singletonlist(paths.get(pluginsdir));
    }

当我们实现自定义继承pluginmanager时，若我们已指定插件目录路径则按照手动指定的插件目录解析并加载插件，否则从jvm系统属性获取pf4j.pluginsdir，若已指定则按照指定路径解析并加载插件，否则默认的插件目录则为plugins或者../plugins（pf4j区分测试和生产模式，也是从jvm系统属性获取mode_property_name）。

插件与插件之间的目录自定义

我们设计的具体插件有2个层级，将插件jar包去除版本号的名称作为插件目录，其目录下放插件jar包，同时还有个lib目录，该lib目录用于存放插件的依赖，此依赖既可来源于插件引入独立依赖的mvn仓库包，也可来源于与外部对接时的私有包（不存在于mvn仓库）。很显然，pf4j不支持（一句话概括：pf4j没有插件目录层级之分，所有插件jar包统一放到插件目录下以及依赖也统一放到插件目录下的lib目录下，在此不再做进一步的源码讲解），我们重写其方法实现

如上basepluginrepository为pf4j提供的基本实现，同时pf4j进一步提供jarpluginrepository继承basepluginrepository，仅仅只是作为构造函数传递插件目录路径，所以我们可以自定义继jarpluginrepository，重写上述streamfiles方法即可，该方法有2个参数，第一个则是插件目录路径，第二个则是文件类型过滤（jar）

上述我们已重写最终得到的将是具体插件jar包路径，这里我们可考虑做两方面处理，一是强校验插件目录的名称和jar包忽略版本号的名称是否完全一致，二是版本冲突处理即存在不同版本的jar包时，例如可以根据版本约定俗成的alpha、rc、release版本等规则取最新的jar包，其他各凭实际情况自由发挥。

插件独立依赖包解析

上述仅仅只是取到了具体插件jar包路径，接下来通过类加载器加载jar包以及加载依赖，首先需要讨论类加载器的事情，个人认为pf4j的类加载器考虑的很周到，设计的比较灵活，但我们实际可以稍微简化下，核心思路总结起来主要也就4点：遵循“双亲委派” 基础规则，先检查类是否已加载，避免重复加载→遵循双亲委派核心思想，优先从主应用（父类加载器）加载→插件专属类优先从插件加载（可选）→类从插件加载→自定义额外类路径兜底（可选）→最终加载失败抛异常。当然实际情况下我们可能也有其他考虑，可看看pf4j类加载器源码自行做取舍，如下自定义继承

public class gjpluginclassloader extends pluginclassloader {
    private static final logger log = loggerfactory.getlogger(gjpluginclassloader.class);
    // 插件专属资源
    private static final set<string> plugin_first_resources = set.of(
            "meta-inf/extensions.idx"
    );
  @override
    protected class<?> loadclass(string name, boolean resolve) throws classnotfoundexception {
        // 1. 检查是否已加载
        class<?> loadedclass = findloadedclass(name);
        if (loadedclass != null) {
            return loadedclass;
        }
        // 2. 优先从主应用（父类加载器）加载
        try {
            return parentclassloader.loadclass(name);
        } catch (classnotfoundexception e) {
            log.debug("class {} not found in parent classloader, trying plugin", name);
        }
        // 3. 检查是否是插件专用资源（优先从插件加载）
        if (ispluginonlyresource(name)) {
            try {
                class<?> pluginclass = super.loadclass(name, resolve);
                if (pluginclass != null) {
                    return pluginclass;
                }
            } catch (classnotfoundexception ignored) {
            }
        }
        // 4. 尝试从插件中加载
        try {
            class<?> pluginclass = super.loadclass(name, resolve);
            if (pluginclass != null) {
                return pluginclass;
            }
        } catch (classnotfoundexception e) {
            log.warn("class {} not found in plugin, trying additional paths", name);
        }
        // 5. 最后从额外类路径中查找
        class<?> additionalclass = findclassinadditionalpaths(name);
        if (additionalclass != null) {
            return additionalclass;
        }
        throw new classnotfoundexception("class " + name + " not found in parent, plugin or additional paths");
    }

既然我们已自定义类加载器，那么何时实例化类加载器呢，就在我们继承底层defaultpluginmanager自定义的pluginmanager里面重写createpluginloader方法

    @override
    protected pluginloader createpluginloader() {
        return new gjjarpluginloader(this);
    }

上述我们提供继承自底层的pluginclassloader自定义类加载器，我们开始加载jar包及其依赖，此时又得需要自定义jar包加载类继承自底层的jarpluginloader，全部代码一贴如下：

public class gjjarpluginloader extends jarpluginloader {
    private static final logger log = loggerfactory.getlogger(gjjarpluginloader.class);
    private static final string lib_dir = "lib";
    public gjjarpluginloader(pluginmanager pluginmanager) {
        super(pluginmanager);
    }
    @override
    public boolean isapplicable(path pluginpath) {
        return files.exists(pluginpath) && fileutils.isjarfile(pluginpath);
    }
    @override
    public classloader loadplugin(path pluginpath, plugindescriptor plugindescriptor) {
        gjpluginclassloader pluginclassloader = new gjpluginclassloader(this.pluginmanager, plugindescriptor, this.getclass().getclassloader());
        pluginclassloader.addfile(pluginpath.tofile());
        loaddependencyjars(pluginpath, pluginclassloader);
        return pluginclassloader;
    }
    void loaddependencyjars(path pluginpath, gjpluginclassloader pluginclassloader) {
        // 插件 jar 所在目录
        path plugindir = pluginpath.getparent();
        if (plugindir == null) {
            log.warn("plugin path has no parent directory: {}", pluginpath);
            return;
        }
        path libdir = plugindir.resolve(lib_dir);
        // 1. lib_dir不存在，说明无依赖，忽略加载独立依赖
        if (!files.exists(libdir)) {
            return;
        }
        // 2. 从 manifest.mf 读取 class-path 声明的依赖
        list<path> declaredpaths = getdeclaredclasspathjars(pluginpath);
        if (declaredpaths.isempty()) {
            log.debug("no class-path found in manifest.mf");
            return;
        }
        // 3. 提取 class-path 中所有指向 lib/ 下的 jar 文件名（标准化为文件名）
        set<string> declaredjarnames = getdeclaredjarnames(declaredpaths);
        if (declaredjarnames.isempty()) {
            return;
        }
        set<string> loadedjarnames = new hashset<>();
        try (stream<path> stream = files.list(libdir)) {
            list<path> libjars = stream
                    .filter(files::isregularfile)
                    .filter(path -> path.getfilename().tostring().endswith(".jar"))
                    .tolist();
            for (path jarpath : libjars) {
                string jarname = jarpath.getfilename().tostring();
                // 只加载 class-path 中声明的 jar
                if (!declaredjarnames.contains(jarname)) {
                    log.warn("ignored undeclared jar in lib/: {}", jarname);
                    continue;
                }
                // 避免重复加载
                if (!loadedjarnames.add(jarname)) {
                    log.warn("duplicate jar in lib/: {}", jarname);
                    continue;
                }
                // 使用 pf4j 标准方法添加
                pluginclassloader.addfile(jarpath.tofile());
                log.debug("loaded dependency jar: {}", jarname);
            }
        } catch (ioexception e) {
            log.error("failed to scan lib directory: {}", libdir, e);
        }
    }
    private set<string> getdeclaredjarnames(list<path> declaredpaths) {
        set<string> declaredjarnames = declaredpaths.stream()
                .filter(path -> {
                    try {
                        return path.startswith(lib_dir) ||
                                path.getfilename().tostring().equals(path.tostring());
                    } catch (exception e) {
                        return false;
                    }
                })
                .map(path -> {
                    // 处理相对路径（如 "lib/xxx.jar"）
                    return path.getfilename().tostring();
                })
                .collect(collectors.toset());
        if (declaredjarnames.isempty()) {
            log.debug("no lib jars declared in class-path");
        }
        return declaredjarnames;
    }
    private list<path> getdeclaredclasspathjars(path pluginjarpath) {
        try (jarfile jarfile = new jarfile(pluginjarpath.tofile())) {
            manifest manifest = jarfile.getmanifest();
            if (manifest == null) {
                return collections.emptylist();
            }
            attributes mainattrs = manifest.getmainattributes();
            string classpath = mainattrs.getvalue(attributes.name.class_path);
            if (classpath == null || classpath.trim().isempty()) {
                return collections.emptylist();
            }
            // 按空格分割（支持多个空格）
            return arrays.stream(classpath.trim().split("\\s+"))
                    .filter(s -> !s.isempty())
                    .map(paths::get)
                    .collect(collectors.tolist());
        } catch (exception e) {
            throw new runtimeexception("failed to read class-path from plugin manifest: " + pluginjarpath, e);
        }
    }
}

上述总结起来一句话：插件包先投入类加载器，再将插件lib目录独立依赖投入类加载器，但尤其需要注意2点涉及安全方面的考虑，一是防止路径穿越，二是在利用mvn自动化构建时将lib下所有依赖写入到jar清单文件manifest.mf（并不是随随便便放个jar包到lib目录下我们就任意去加载，当然更重要的前置条件是当插件放到平台插件目录下时肯定要做sha256等等一致性校验）

插件与插件相互依赖解析

pf4j以逆拓扑排序解析插件依赖，插件依赖由约定的plugin.properties中的plugin.dependencies属性定义插件依赖，若依赖插件gj.plugin.demo2和gj.plugin.demo3（可选是否带上版本号），那么：plugin.dependencies=gj.plugin.demo2@1.0.0-snapshot,gj.plugin.demo2@1.0.0-snapshot。注意多个依赖用英文半角符号隔开，同时若出现循环依赖则会抛出异常，不用担心死循环问题

插件加载异常自定义策略

多个插件加载，若某个插件出现加载异常我们可能并不希望影响其他插件的正常加载，pf4j提供了插件加载异常策略，默认是会抛出异常。

若需调整插件加载异常策略，我们在继承底层defaultpluginmanager自定义的pluginmanager里面重写initialize方法，在调用父类初始化方法后重写其策略即可

   @override
    protected void initialize() {
        super.initialize();
        // 覆盖默认设置解析依赖异常不影响其他插件正常加载
        this.resolverecoverystrategy = resolverecoverystrategy.ignore_plugin_and_continue;
        this.configurationrepository = createconfigurationrepository();
    }