背景

在異構數據源同步需求中，需要支持多種數據庫連接器，每種數據源對應的 Reader 或 Writer 插件往往依賴不同的第三方庫（如不同版本的 JDBC 驅動、HBase 客户端等）。如果將所有插件及其依賴統一加載到同一個 ClassLoader 中，極易引發 依賴衝突（例如：兩個插件依賴不同版本的 commons-lang）。

傳統的類加載機制會遇到類衝突問題，需要實現驅動依賴的隔離加載。

技術主線

1. 自定義 ClassLoader

   • 為每個數據源創建獨立的 URLClassLoader，隔離命名空間；
   • 通過反射調用驅動，避免類泄漏到系統 ClassLoader。

2. 模塊化框架（OSGi / JPMS）

   • 將每個驅動打包為獨立 Bundle/Module，聲明依賴版本範圍；
   • 利用模塊系統的版本隔離能力（如 OSGi 的 Import-Package: version=[8.0,9.0)）。

3. 進程級隔離（終極方案）

   • 為每個數據源啓動獨立子進程（如 Java Agent），通過 IPC 通信；
   • 完全避免依賴衝突，但性能開銷大。

方案對比與選型建議

自定義 ClassLoader方案的DataMover實現分享

自定義：ConnectorClassLoader

1. 自定義類加載器

關鍵特點：

• 繼承自 URLClassLoader，支持從指定路徑加載資源
• 每個連接器擁有獨立的類加載器實例

    public class ConnectorClassLoader extends URLClassLoader {
    private static final Logger LOGGER = LoggerFactory.getLogger(ConnectorClassLoader.class);
    private static final int DEFAULT_BUFFER_SIZE = 4096;
    private String connectorName;

    public ConnectorClassLoader(File connectorHome) {
        super(loadResources(connectorHome));
        this.connectorName = connectorHome.getName();
    }
}

2. 類加載策略

加載策略説明：

• Child-First：優先從當前連接器加載類，避免版本衝突
• Parent-First：日誌類等基礎類庫委託父類加載器，避免重複加載

@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    // 1. 檢查是否已經加載過
    Class<?> loadedClass = findLoadedClass(name);
    if (loadedClass != null) {
        return loadedClass;
    }

    // 2. 定義需要 parent-first 的包前綴（日誌相關）
    String[] parentFirstPackages = {
            "org.slf4j.",
            "org.apache.logging.log4j.",
            "org.apache.log4j.",
            "ch.qos.logback."
    };

    // 3. 判斷是否屬於 parent-first 包
    boolean isParentFirst = false;
    for (String pkg : parentFirstPackages) {
        if (name.startsWith(pkg)) {
            isParentFirst = true;
            break;
        }
    }

    if (isParentFirst) {
        // 3a. 日誌類：先委託父類加載器
        try {
            return super.loadClass(name, resolve);
        } catch (ClassNotFoundException e) {
            // 父類找不到，再嘗試自己加載（可選，通常不需要）
            return findClass(name);
        }
    } else {
        // 3b. 非日誌類：保持 child-first
        try {
            return findClass(name);
        } catch (ClassNotFoundException e) {
            return super.loadClass(name, resolve);
        }
    }
}

3. 資源路徑加載

資源加載邏輯：

• 加載 lib 目錄下的所有 JAR 包
• 解壓嵌套 JAR 包並添加到類路徑
• 加載 resources 和 conf 目錄資源

private static URL[] loadResources(File connectorHome) {
    if (connectorHome == null || !connectorHome.isDirectory()) {
        throw new IllegalArgumentException("ConnectorHome 無效");
    }

    List<URL> resourceUrls = new ArrayList<>();

    // 加載 lib 目錄下的 JAR 文件及其內部嵌套 JAR
    File libDirectory = new File(connectorHome, "lib");
    if (libDirectory.isDirectory()) {
        File[] jarFiles = libDirectory.listFiles((dir, name) -> 
            StringUtils.endsWithIgnoreCase(name, ".jar")
        );

        if (jarFiles != null) {
            for (File jarFile : jarFiles) {
                addFileUrl(jarFile, resourceUrls);

                try (JarFile jar = new JarFile(jarFile)) {
                    if (hasJarEntry(jar)) {
                        List<File> extractedFiles = unzipJar(jar, connectorHome);
                        for (File extractedFile : extractedFiles) {
                            addFileUrl(extractedFile, resourceUrls);
                        }
                    }
                } catch (IOException e) {
                    LOGGER.error("掃描 {} 內部 JAR 時發生異常: {}", jarFile.getName(), e.getMessage(), e);
                }
            }
        }
    }

    // 加載 resources 目錄
    File resourcesDirectory = new File(connectorHome, "resources");
    if (resourcesDirectory.isDirectory()) {
        addFileUrl(resourcesDirectory, resourceUrls);
    }

    // 加載 conf 目錄
    File confDirectory = new File(connectorHome, "conf");
    if (confDirectory.isDirectory()) {
        addFileUrl(confDirectory, resourceUrls);
    }

    return resourceUrls.toArray(new URL[0]);
}

連接器管理：ConnectorManager

1. 連接器加載

public static Connector loadConnector(File connectorHome) throws Exception {
    LOGGER.info("load Connector {}", connectorHome.getPath());
    Connector connector = new Connector();
    connector.setConnectorHome(connectorHome);
    File libDir = new File(connectorHome, "lib");
    File[] jars = libDir.listFiles((dir, name) -> {
        return name.startsWith("datamover-connector-");
    });
    if (jars != null && jars.length != 0) {
        String interfaceClass = findInterfaceClass(jars[0]);
        ConnectorClassLoader classLoader = new ConnectorClassLoader(connectorHome);
        connector.setClassLoader(classLoader);
        Class<ConnectorDef> aClass = (Class<ConnectorDef>)        classLoader.loadClass(interfaceClass);
        ConnectorDef connectorDef = (ConnectorDef)aClass.newInstance();
        // ... 其他初始化邏輯
    } else {
        throw new IllegalStateException("沒有找到連接器jar包");
    }
}

2. 接口類查找

private static String findInterfaceClass(File jarFile) throws IOException {
    try (ZipFile zipFile = new ZipFile(jarFile)) {
        Enumeration<? extends ZipEntry> entries = zipFile.entries();

        while (entries.hasMoreElements()) {
            ZipEntry entry = entries.nextElement();
            String entryName = entry.getName();

            if (!entryName.endsWith(".class")) {
                continue;
            }

            try (InputStream inputStream = zipFile.getInputStream(entry)) {
                ClassReader classReader = new ClassReader(inputStream);
                ClassNode classNode = new ClassNode();
                classReader.accept(classNode, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);

                if (classNode.interfaces.contains(CONNECTOR_INTERFACE)) {
                    return classNode.name.replace('/', '.');
                }
            }
        }

        throw new IllegalStateException("未在 JAR 中找到實現指定插件接口的類");
    }
}

3.註冊連接器

public static void initLoad() {
      // ... 其他初始化邏輯
      Connector connector = loadConnector(connectorHome);
      registerConnector(connector);
      // ... 其他初始化邏輯
   }

技術優勢

1. 依賴隔離

• 每個連接器使用獨立的類加載器
• 避免不同版本驅動包的衝突

2. 靈活的加載策略

• Child-First 策略確保連接器使用自己的依賴
• Parent-First 策略複用基礎類庫

3. 資源完整性

• 支持嵌套 JAR 包的解壓和加載
• 包含配置文件和資源文件

踩坑指南

• 線程上下文：反射調用時需設置 Thread.currentThread().setContextClassLoader()；

總結

通過自定義 ConnectorClassLoader，異構數據源同步工具實現了驅動依賴的完全隔離。這種設計不僅解決了類衝突問題，還提供了靈活的類加載策略，確保系統能夠穩定運行多種不同版本的數據庫連接器。

DataMover的單進程內完成多源同步方案，目前仍待解決的技術問題，類加載隔離實現可以保證不同插件認證不同Kerberos集羣時的認證隔離，但同一個連接器插件需要連接不同開啓Kerberos認證的集羣時會存在認證衝突問題。