当同一类存在两个版本时，如何确保自定义版本被优先选用？

Great to hear your modified adapter is fixing that annoying double-parsing issue! Let's walk through several solid ways to make sure your custom version always takes precedence over the default Gson one, ranked from most maintainable to more low-level:

1. Register Your Custom Adapter Explicitly (Most Recommended) #

Instead of relying on classpath tricks to override the default adapter, you can explicitly register your modified ObjectTypeAdapter (or a wrapper for it) with GsonBuilder. This is the cleanest approach because it bypasses classloader ambiguity entirely.

Here's how to implement it:

• Keep your modified adapter in your project (feel free to rename it something like CustomObjectTypeAdapter to avoid confusion with the original).
• Register it directly when building your Gson instance:

  Gson gson = new GsonBuilder()
      // Register your custom adapter for Object types
      .registerTypeAdapter(Object.class, new CustomObjectTypeAdapter())
      // Or use a factory for more granular control over type matching
      .registerTypeAdapterFactory(new TypeAdapterFactory() {
          @Override
          public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
              if (type.getRawType() == Object.class) {
                  return (TypeAdapter<T>) new CustomObjectTypeAdapter();
              }
              return null; // Let Gson handle all other types normally
          }
      })
      .create();
  

• Use this Gson instance everywhere in your app. This guarantees your custom parsing logic is used, no classpath conflicts involved.

2. Control Classpath Order #

Java's classloader loads classes in the order they appear in the classpath. To make sure your my.jar's version is picked first:

• Maven: Adjust your pom.xml dependency order — place your project's artifact (or my.jar) before the gson dependency. Maven uses the listed order to build the runtime classpath.

• Gradle: Tweak your build.gradle to prioritize my.jar over gson-2.8.1.jar in the compileClasspath or runtimeClasspath. You can reorder dependencies or use dependencyManagement to enforce priority.

• Command Line: When launching your app, list my.jar first in the -cp argument:

  java -cp my.jar:gson-2.8.1.jar com.yourcompany.YourMainClass
  

  Note: On Windows, use semicolons (;) instead of colons (:) to separate classpath entries.

  Heads up: Some application servers (like Tomcat) or modular environments (JPMS) have their own classloading rules that might override standard classpath order. Test thoroughly if you're working in such a setup.

3. Use a Custom ClassLoader #

For more granular control (if you can't modify classpath order), implement a custom classloader that prioritizes loading com.google.gson.internal.bind.ObjectTypeAdapter from my.jar before checking other classpath entries.

Here's a simplified example:

public class PriorityClassLoader extends ClassLoader {
    private final File myJarFile;

    public PriorityClassLoader(File myJarFile, ClassLoader parent) {
        super(parent);
        this.myJarFile = myJarFile;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // Only prioritize our custom adapter class
        if (name.equals("com.google.gson.internal.bind.ObjectTypeAdapter")) {
            try {
                JarFile jar = new JarFile(myJarFile);
                JarEntry entry = jar.getJarEntry(name.replace('.', '/') + ".class");
                InputStream is = jar.getInputStream(entry);
                byte[] classBytes = new byte[(int) entry.getSize()];
                is.read(classBytes);
                is.close();
                return defineClass(name, classBytes, 0, classBytes.length);
            } catch (IOException e) {
                throw new ClassNotFoundException("Failed to load custom adapter", e);
            }
        }
        // Let the parent classloader handle all other classes
        return super.findClass(name);
    }
}

Then use this loader to launch your app:

public static void main(String[] args) throws Exception {
    File myJar = new File("path/to/your/my.jar");
    ClassLoader customLoader = new PriorityClassLoader(myJar, ClassLoader.getSystemClassLoader());
    Class<?> mainClass = customLoader.loadClass("com.yourcompany.YourMainClass");
    Method mainMethod = mainClass.getMethod("main", String[].class);
    mainMethod.invoke(null, (Object) args);
}

4. Shade the Class (Build-Time Override) #

If you're using Maven or Gradle, use a shading plugin to embed your custom ObjectTypeAdapter directly into your application jar, ensuring it overrides the one from Gson:

• Maven Shade Plugin: Configure the plugin to include your modified class and exclude the original Gson version of the class, or let your class overwrite it during the shading process.
• Gradle Shadow Plugin: Similar to Maven, use the plugin to package your custom class into the shadow jar — this jar will take precedence over the standalone Gson jar at runtime.

This approach locks in your custom class as part of your app's core artifacts, eliminating classpath order concerns entirely.

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