这是一个非常典型的类加载性能优化+版本隔离场景，刚好可以通过自定义类加载器的分层设计来完美解决。下面我会一步步拆解实现方案，附带代码示例和关键注意事项：

我们的目标是让同版本SDK的类定义被多个App共享，不同版本SDK完全隔离，同时保持每个App的类加载独立性。核心逻辑是：

• 为每个SDK版本创建专属的SDKCacheClassLoader，负责加载该版本的所有SDK类，并用全局缓存管理这些ClassLoader实例。
• 自定义App的类加载器（继承URLClassLoader），重写类加载逻辑：当遇到SDK包下的类时，优先委托给对应版本的SDKCacheClassLoader加载；非SDK类则保持原有隔离逻辑，由App自己的ClassLoader加载。

1. 构建SDKClassLoader全局缓存管理器 #

首先需要一个线程安全的管理器，用来根据SDK版本号获取或创建对应的SDKCacheClassLoader，避免重复创建同一版本的ClassLoader。

2. 实现SDKCacheClassLoader #

这个ClassLoader专门负责加载指定版本的SDK类，父类加载器使用系统类加载器，确保系统类和第三方依赖类的加载不受影响。

3. 自定义AppClassLoader #

继承URLClassLoader，重写loadClass方法，对SDK类做特殊处理：优先委托给对应版本的SDKCacheClassLoader，非SDK类则遵循双亲委派流程加载App自身的类。

1. SDKClassLoaderManager（全局缓存管理器） #

import java.net.URL;
import java.net.URLClassLoader;
import java.util.concurrent.ConcurrentHashMap;

public class SDKClassLoaderManager {
    // 线程安全的缓存：SDK版本 -> 对应ClassLoader
    private static final ConcurrentHashMap<String, ClassLoader> SDK_CLASS_LOADER_CACHE = new ConcurrentHashMap<>();
    // 预定义的SDK包前缀，用来识别需要共享的类
    private static final String SDK_PACKAGE_PREFIX = "com.mycompany.sdk.";

    /**
     * 根据SDK版本获取或创建对应的ClassLoader
     * @param sdkVersion SDK版本号
     * @param sdkJarUrls 该版本SDK的Jar文件URL数组
     * @return 对应版本的SDKCacheClassLoader
     */
    public static ClassLoader getSDKClassLoader(String sdkVersion, URL[] sdkJarUrls) {
        return SDK_CLASS_LOADER_CACHE.computeIfAbsent(sdkVersion, version -> {
            // 父类加载器使用系统类加载器，保证系统类正常加载
            return new URLClassLoader(sdkJarUrls, ClassLoader.getSystemClassLoader());
        });
    }

    /**
     * 判断类是否属于SDK包
     * @param className 类全名
     * @return true如果是SDK类，否则false
     */
    public static boolean isSDKClass(String className) {
        return className.startsWith(SDK_PACKAGE_PREFIX);
    }
}

2. 自定义AppClassLoader #

import java.net.URL;
import java.net.URLClassLoader;

public class AppClassLoader extends URLClassLoader {
    private final String sdkVersion;

    public AppClassLoader(URL[] appJarUrls, String sdkVersion) {
        // 父类加载器设为系统类加载器，保证非App/非SDK类的正常加载
        super(appJarUrls, ClassLoader.getSystemClassLoader());
        this.sdkVersion = sdkVersion;
    }

    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        // 先检查是否已加载过该类
        Class<?> loadedClass = findLoadedClass(name);
        if (loadedClass != null) {
            return loadedClass;
        }

        // 如果是SDK类，优先委托给对应版本的SDKCacheClassLoader加载
        if (SDKClassLoaderManager.isSDKClass(name)) {
            ClassLoader sdkClassLoader = SDKClassLoaderManager.getSDKClassLoader(
                sdkVersion, getSDKJarUrlsByVersion(sdkVersion)
            );
            try {
                loadedClass = sdkClassLoader.loadClass(name);
                if (loadedClass != null) {
                    if (resolve) {
                        resolveClass(loadedClass);
                    }
                    return loadedClass;
                }
            } catch (ClassNotFoundException e) {
                // 理论上SDKJar中应该包含所有SDK类，这里仅做容错处理
                // 如果没找到，再走后续流程尝试加载
            }
        }

        // 非SDK类，遵循双亲委派流程加载
        return super.loadClass(name, resolve);
    }

    /**
     * 根据版本号获取对应SDK Jar的URLs
     * 实际场景中可以从固定目录读取，或者从配置中心获取
     */
    private URL[] getSDKJarUrlsByVersion(String sdkVersion) {
        // 示例：假设SDK Jar存储在./sdk-repo/目录下，命名为sdk-{version}.jar
        try {
            return new URL[]{
                new URL("file:./sdk-repo/sdk-" + sdkVersion + ".jar")
            };
        } catch (Exception e) {
            throw new RuntimeException("Failed to load SDK Jar for version: " + sdkVersion, e);
        }
    }
}

3. 加载App的示例代码 #

import java.net.URL;

public class ApplicationLoader {
    public static void main(String[] args) throws Exception {
        // 加载依赖SDK 1.0的App1
        URL[] app1Jars = new URL[]{new URL("file:./apps/app1.jar")};
        AppClassLoader app1ClassLoader = new AppClassLoader(app1Jars, "1.0");
        Class<?> app1Main = app1ClassLoader.loadClass("com.mycompany.app1.Main");
        app1Main.getMethod("main", String[].class).invoke(null, (Object) args);

        // 加载同样依赖SDK 1.0的App2，会复用已创建的SDKCacheClassLoader
        URL[] app2Jars = new URL[]{new URL("file:./apps/app2.jar")};
        AppClassLoader app2ClassLoader = new AppClassLoader(app2Jars, "1.0");
        Class<?> app2Main = app2ClassLoader.loadClass("com.mycompany.app2.Main");
        app2Main.getMethod("main", String[].class).invoke(null, (Object) args);

        // 加载依赖SDK 2.0的App3，会创建新的SDKCacheClassLoader
        URL[] app3Jars = new URL[]{new URL("file:./apps/app3.jar")};
        AppClassLoader app3ClassLoader = new AppClassLoader(app3Jars, "2.0");
        Class<?> app3Main = app3ClassLoader.loadClass("com.mycompany.app3.Main");
        app3Main.getMethod("main", String[].class).invoke(null, (Object) args);
    }
}

• 版本隔离保证：每个SDK版本对应独立的ClassLoader，JVM会将不同ClassLoader加载的同一类视为完全独立的类，完美解决版本冲突问题。
• Jar路径优化：建议将各版本SDK Jar统一存储到固定目录，而非从每个App Jar中提取，避免重复读取相同内容，进一步提升加载性能。如果必须从App Jar提取，可在第一次加载时将SDK Jar解压到临时目录，后续复用。
• 线程安全：使用ConcurrentHashMap管理ClassLoader缓存，确保多线程环境下不会重复创建同一版本的ClassLoader。
• 双亲委派兼容性：自定义AppClassLoader仅对SDK类调整加载顺序，非SDK类依然遵循双亲委派，保证系统类和第三方依赖的加载逻辑不受影响。
• 类卸载（可选）：如果需要动态卸载某个版本的SDK，需清理SDK_CLASS_LOADER_CACHE中的对应条目，并确保没有任何对象引用指向该ClassLoader，否则JVM无法完成类卸载。
• 包前缀准确性：务必保证SDK_PACKAGE_PREFIX的正确性，避免将非SDK类误委托给SDKCacheClassLoader，导致类加载异常。

• 性能提升：同版本SDK类仅加载一次，避免重复扫描Jar文件，大幅降低类加载开销。
• 隔离性保障：每个App拥有独立的ClassLoader，自身代码和依赖完全隔离；不同版本SDK也互相隔离，无版本冲突。
• 动态适配：支持任意SDK版本的动态加载，扩展性强，新增版本无需修改核心逻辑。

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