如何封装第三方SPI实现解耦？求对应设计模式与技术术语

我正在编写包装器封装第三方库，仅按需调用其API，包装器作为独立项目包含第三方库的所有依赖，目的是实现高度解耦，未来可替换第三方库。

但第三方库通过Java ServiceLoader加载SPI（IDataCollector），而SPI需要在META-INF/services/{SPIName}中配置，这会导致第三方库信息泄露到用户项目中。我希望包装器的用户完全感知不到底层第三方库，即用户项目无需引入任何第三方依赖。

我尝试过两种方案但都失败了：

• 编写继承第三方IDataCollector的IWrapDataCollector接口并注册到META-INF/services，但ServiceLoader仅加载具体类，此方案不可行。
• 编写实现IDataCollector的具体类IWrapDataCollector，让用户扩展该类，但只有这个基类被ServiceLoader加载，调用时引发NullPointerException。

第三方代码示例 #

第三方SPI接口 #

package com.thirdParty.library;

public interface IDataCollector {
    String getStudentName();
    Integer getMarks();
}

第三方SPI加载类RankCalculator #

package com.thirdParty.library;

import java.util.Map;
import java.util.ServiceLoader;
import java.util.TreeMap;

public class RankCalculator {
    private static final Map<Integer, String> ranks = new TreeMap<>();

    public RankCalculator () {
        ServiceLoader<IDataCollector> dataCollectorLoader = ServiceLoader.load(IDataCollector.class);
        for (IDataCollector dataCollector: dataCollectorLoader) {
            ranks.put(dataCollector.getMarks(), dataCollector.getStudentName());
        }
    }

    public Integer getRank (String name) {
        Integer position = ranks.size();
        for (Map.Entry<Integer, String> entry: ranks.entrySet()) {
            if (entry.getValue().equals(name)) {
                return position;
            }
            position --;
        }
        return -1;
    }
}

我的尝试代码 #

第一种尝试：包装器接口 #

package com.myWrapper.test;

import com.thirdParty.library.IDataCollector;

public interface IWrapDataCollector extends IDataCollector {

    default Integer getMarksWrapper() {
        return null;
    }

    default String getStudentsNameWrapper() {
        return null;
    }

    @Override
    default String getStudentName() {
        return getStudentsNameWrapper();
    }

    @Override
    default Integer getMarks() {
        return getMarksWrapper();
    }
}

第二种尝试：包装器具体类 #

package com.myWrapper.test;

import com.thirdParty.library.IDataCollector;

public class IWrapDataCollector implements IDataCollector {

    public Integer getMarksWrapper() {
        return null;
    }

    public String getStudentsNameWrapper() {
        return null;
    }

    @Override
    public final String getStudentName() {
        return getStudentsNameWrapper();
    }

    @Override
    public final Integer getMarks() {
        return getMarksWrapper();
    }
}

我需要一种能让用户项目完全移除第三方依赖的解决方案，同时想知道这类场景对应的技术术语或现有设计模式。

核心思路：SPI桥接 + 适配器模式 #

这类场景属于SPI封装与桥接，本质是用适配器模式将用户实现的自定义接口，转换为第三方库所需的SPI实现，同时把第三方SPI的加载逻辑完全封装在包装器内部，对用户透明。

具体实现步骤 #

1. 定义用户侧的独立接口 #

完全脱离第三方库，定义用户需要实现的接口，这是用户唯一需要依赖的部分：

package com.myWrapper.api;

public interface IUserDataCollector {
    String getStudentName();
    Integer getMarks();
}

2. 实现第三方SPI的桥接类 #

在包装器内部编写一个实现第三方IDataCollector的具体类，该类持有用户实现的IUserDataCollector实例，负责将调用转发给用户的实现：

package com.myWrapper.internal;

import com.thirdParty.library.IDataCollector;
import com.myWrapper.api.IUserDataCollector;

public class DataCollectorBridge implements IDataCollector {
    private final IUserDataCollector userCollector;

    public DataCollectorBridge(IUserDataCollector userCollector) {
        this.userCollector = userCollector;
    }

    @Override
    public String getStudentName() {
        return userCollector.getStudentName();
    }

    @Override
    public Integer getMarks() {
        return userCollector.getMarks();
    }
}

3. 封装第三方RankCalculator的调用逻辑 #

不再依赖第三方的ServiceLoader自动加载，而是由包装器主动收集用户实现的IUserDataCollector，通过桥接类转换后注入到第三方逻辑中：

package com.myWrapper.api;

import com.thirdParty.library.RankCalculator;
import com.myWrapper.internal.DataCollectorBridge;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

public class WrappedRankCalculator {
    private final RankCalculator delegate;

    // 接收用户实现的IUserDataCollector列表
    public WrappedRankCalculator(List<IUserDataCollector> userCollectors) {
        // 先初始化第三方RankCalculator
        this.delegate = new RankCalculator();
        
        // 重新构建ranks数据，避免依赖第三方的SPI加载逻辑
        Map<Integer, String> ranks = new TreeMap<>();
        userCollectors.forEach(collector -> 
            ranks.put(collector.getMarks(), collector.getStudentName())
        );
        
        // 用反射替换第三方的私有ranks（如果允许的话）
        try {
            java.lang.reflect.Field field = RankCalculator.class.getDeclaredField("ranks");
            field.setAccessible(true);
            field.set(delegate, ranks);
        } catch (Exception e) {
            // 反射失败则直接在包装器内实现RankCalculator逻辑，彻底绕过第三方类
            throw new RuntimeException("Failed to initialize rank calculator", e);
        }
    }

    // 暴露给用户的方法，完全封装第三方逻辑
    public Integer getRank(String name) {
        return delegate.getRank(name);
    }
}

如果反射不可行，更彻底的方式是在包装器中重新实现RankCalculator的核心逻辑，这样未来替换第三方库时只需修改包装器内部，用户代码完全不用动。

4. 用户侧的使用方式 #

用户只需要依赖包装器的com.myWrapper.api包，实现IUserDataCollector后传入包装器即可：

package com.user.project;

import com.myWrapper.api.IUserDataCollector;
import com.myWrapper.api.WrappedRankCalculator;
import java.util.List;

public class UserDataCollectorImpl implements IUserDataCollector {
    @Override
    public String getStudentName() {
        return "Alice";
    }

    @Override
    public Integer getMarks() {
        return 95;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        WrappedRankCalculator calculator = new WrappedRankCalculator(List.of(new UserDataCollectorImpl()));
        System.out.println(calculator.getRank("Alice"));
    }
}

对应的技术术语 #

• 适配器模式（Adapter Pattern）：将用户接口适配为第三方所需的接口，完成接口转换。
• SPI桥接（SPI Bridging）：在封装层内部处理第三方SPI的加载与适配，对上层用户隐藏底层细节。
• 依赖倒置原则（Dependency Inversion Principle）：用户依赖包装器的抽象接口，而非具体的第三方实现，实现解耦。

内容的提问来源于stack exchange，提问作者booyaakaashaa