如何在Java中通过自定义类加载器合理解决多模块SDK依赖冲突？

核心逻辑 #

要让agent依赖的OkHttp 4.10.0和用户应用的OkHttp 3.14.9共存，同时保证ByteBuddy能正常拦截用户的OkHttp类，核心是类加载隔离：

• 用自定义的Child-First类加载器加载agent侧的OkHttp 4.10.0及拦截器类，优先加载自身资源，避免与用户版本冲突
• ByteBuddy增强用户OkHttp类时，指定拦截器由该自定义加载器加载，确保拦截逻辑使用高版本OkHttp API，不干扰用户的低版本类

1. 实现兼容Java9+的Child-First类加载器 #

不要直接继承URLClassLoader（Java9+应用类加载器已不再是其子类），直接基于ClassLoader实现，优先从自身资源加载类，仅系统类（java.*等）委托父类加载：

public class ChildFirstClassLoader extends ClassLoader {
    private final Set<String> selfLoadedClasses = new HashSet<>();
    private final List<URL> classpathUrls;
    private final Map<String, Class<?>> cachedClasses = new ConcurrentHashMap<>();

    public ChildFirstClassLoader(List<URL> classpathUrls, ClassLoader parent) {
        super(parent);
        this.classpathUrls = classpathUrls;
    }

    @Override
    protected Class<?> findClass(String className) throws ClassNotFoundException {
        // 检查缓存
        Class<?> cachedClass = cachedClasses.get(className);
        if (cachedClass != null) {
            return cachedClass;
        }

        // 系统类委托父加载器
        if (className.startsWith("java.") || className.startsWith("javax.") || className.startsWith("com.sun.")) {
            return super.findClass(className);
        }

        // 尝试从自身classpath加载
        try {
            byte[] classBytes = loadClassBytes(className);
            cachedClass = defineClass(className, classBytes, 0, classBytes.length);
            cachedClasses.put(className, cachedClass);
            selfLoadedClasses.add(className);
            return cachedClass;
        } catch (IOException e) {
            // 加载失败则委托父加载器
            return super.findClass(className);
        }
    }

    @Override
    protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(className)) {
            Class<?> loadedClass = findLoadedClass(className);
            if (loadedClass == null) {
                try {
                    loadedClass = findClass(className);
                } catch (ClassNotFoundException e) {
                    loadedClass = super.loadClass(className, resolve);
                }
            }
            if (resolve) {
                resolveClass(loadedClass);
            }
            return loadedClass;
        }
    }

    private byte[] loadClassBytes(String className) throws IOException {
        String classFilePath = className.replace('.', '/') + ".class";
        for (URL url : classpathUrls) {
            try (InputStream inputStream = new URL(url, classFilePath).openStream()) {
                return inputStream.readAllBytes();
            } catch (IOException ignored) {
                // 尝试下一个URL
            }
        }
        throw new FileNotFoundException("Class " + className + " not found in child classpath");
    }

    // 标记类是否由当前加载器加载
    public boolean isSelfLoaded(String className) {
        return selfLoadedClasses.contains(className);
    }
}

2. Premain中初始化加载器并配置ByteBuddy #

在agent的premain方法中，完成类加载器初始化，并让ByteBuddy使用自定义加载器加载拦截器：

public class KAgent {
    public static void premain(String agentArgs, Instrumentation instrumentation) {
        try {
            // 1. 收集自定义加载器的classpath：包含agent jar（已打包OkHttp 4.10.0和拦截器）
            List<URL> childClasspath = new ArrayList<>();
            URL agentJarUrl = KAgent.class.getProtectionDomain().getCodeSource().getLocation();
            childClasspath.add(agentJarUrl);

            // 2. 选择父加载器：Java8用bootstrap，Java9+用PlatformClassLoader
            ClassLoader parentLoader;
            if (System.getProperty("java.version").startsWith("1.")) {
                parentLoader = ClassLoader.getSystemClassLoader().getParent();
            } else {
                parentLoader = ClassLoader.getPlatformClassLoader();
            }
            ChildFirstClassLoader agentClassLoader = new ChildFirstClassLoader(childClasspath, parentLoader);

            // 3. ByteBuddy增强用户的OkHttp类，指定拦截器由自定义加载器加载
            new ByteBuddy()
                    .type(ElementMatchers.named("okhttp3.OkHttpClient"))
                    .transform((builder, typeDesc, appLoader, module) ->
                            builder.method(ElementMatchers.named("newCall")
                                            .and(ElementMatchers.takesArgument(0, ElementMatchers.named("okhttp3.Request"))))
                                    .intercept(MethodDelegation.to(agentClassLoader.loadClass("com.ksdk.integration.OkHttpInterceptor")))
                    )
                    .installOn(instrumentation);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 关键配置与注意事项 #

• agent打包：用maven-assembly-plugin将OkHttp 4.10.0和integration模块的拦截器类打包进agent jar，不要修改包名，保持原okhttp3包结构。
• 类加载隔离：自定义加载器仅加载自身需要的OkHttp和拦截器类，系统类必须委托父加载器，否则会触发LinkageError。
• 模块化兼容：如果用户应用是Java9+模块化项目，需添加JVM参数开放OkHttp包给agent：--add-opens okhttp3/com.ksdk.integration=ALL-UNNAMED（根据实际包名调整）。

备选简化方案 #

如果自定义类加载器过于复杂，可采用版本适配+反射方案：

• 针对OkHttp 3.x和4.x分别编写兼容的拦截器逻辑
• 在premain中检测用户应用的OkHttp版本，动态选择对应的拦截器
• 用反射调用OkHttp API，避免编译时依赖高版本方法，示例：

@Advice.OnMethodEnter
public static void interceptRequest(@Advice.Argument(0) Object request) {
    try {
        Method getUrlMethod = request.getClass().getMethod("url");
        Object urlObj = getUrlMethod.invoke(request);
        String requestUrl = urlObj.toString();
        // 自定义处理逻辑
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
        // 兼容低版本的降级处理
    }
}

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