如何重定向Class.forName返回对象？实现旧版插件兼容

Great question! Since you're dealing with package structure changes and need to keep old plugins compatible (sharing the same classloader), here are three robust approaches to redirect Class.forName calls from the old class path to the new one:

Approach 1: Pre-Register Old Class Names to Map to New Classes (Simplest) #

If you can run initialization code early in your app startup (before any plugins load), this is the most straightforward solution. We'll explicitly register the old class name with the shared classloader, binding it to the new class's bytecode.

public class ClassRedirector {
    public static void setupClassRedirect() throws Exception {
        // 1. Load the target new class we want to redirect to
        Class<?> newTargetClass = Class.forName("test.here.found.class");
        
        // 2. Grab the shared classloader used by your app and plugins
        ClassLoader sharedClassLoader = newTargetClass.getClassLoader();
        
        // 3. Read the bytecode of the new class (required for defineClass)
        String newClassResourcePath = newTargetClass.getName().replace('.', '/') + ".class";
        try (InputStream classByteStream = sharedClassLoader.getResourceAsStream(newClassResourcePath)) {
            byte[] newClassBytes = classByteStream.readAllBytes();
            
            // 4. Use reflection to call the protected defineClass method
            Method defineClassMethod = ClassLoader.class.getDeclaredMethod(
                "defineClass", String.class, byte[].class, int.class, int.class
            );
            defineClassMethod.setAccessible(true);
            
            // Register the old class name with the new class's bytecode
            defineClassMethod.invoke(
                sharedClassLoader,
                "test.nothere.found.class", // Old class name plugins will request
                newClassBytes,
                0,
                newClassBytes.length
            );
        }
    }
}

How to Use: #

Call ClassRedirector.setupClassRedirect() as early as possible in your application lifecycle (e.g., in your main method before loading plugins). Now when plugins call Class.forName("test.nothere.found.class"), the shared classloader will return the test.here.found.class instance directly.

Approach 2: Custom ClassLoader with Redirection (Scalable) #

If you have multiple classes to redirect or need dynamic mappings, create a custom classloader that wraps your shared classloader and intercepts class name requests. This maintains Java's parent delegation model to avoid breaking normal class loading.

public class RedirectingClassLoader extends ClassLoader {
    private final Map<String, String> classPathMappings;

    public RedirectingClassLoader(ClassLoader parentClassLoader, Map<String, String> mappings) {
        super(parentClassLoader); // Delegate all non-redirected classes to the original loader
        this.classPathMappings = mappings;
    }

    @Override
    protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
        // Check if we need to redirect this class request
        String redirectedClassName = classPathMappings.getOrDefault(className, className);
        
        // Delegate to the parent classloader to load the (possibly redirected) class
        return super.loadClass(redirectedClassName, resolve);
    }
}

How to Use: #

// Define your old -> new class mappings
Map<String, String> classMappings = new HashMap<>();
classMappings.put("test.nothere.found.class", "test.here.found.class");
// Add more mappings for other moved classes as needed

// Wrap your shared classloader with the redirecting loader
ClassLoader originalSharedLoader = Thread.currentThread().getContextClassLoader();
RedirectingClassLoader redirectingLoader = new RedirectingClassLoader(originalSharedLoader, classMappings);

// Set the redirecting loader as the context classloader for all plugin threads
Thread.currentThread().setContextClassLoader(redirectingLoader);

Approach 3: Java Instrumentation API (Advanced, No Startup Code Changes) #

If you can't modify your app's startup code, use the JVM's Instrumentation API to intercept class loading requests at the lowest level. This requires packaging a Java agent JAR.

public class ClassRedirectionAgent implements ClassFileTransformer {
    private final Map<String, String> classMappings;

    public ClassRedirectionAgent(Map<String, String> mappings) {
        this.classMappings = mappings;
    }

    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
                            ProtectionDomain protectionDomain, byte[] classfileBuffer)
            throws IllegalClassFormatException {
        // Convert JVM-style class name ("/" separated) to canonical name ("." separated)
        String canonicalClassName = className.replace('/', '.');
        String redirectedClassName = classMappings.get(canonicalClassName);
        
        if (redirectedClassName != null) {
            // Load the bytecode of the target new class instead
            String redirectedResourcePath = redirectedClassName.replace('.', '/') + ".class";
            try (InputStream redirectedByteStream = loader.getResourceAsStream(redirectedResourcePath)) {
                return redirectedByteStream.readAllBytes();
            } catch (IOException e) {
                throw new IllegalClassFormatException("Failed to load redirected class: " + redirectedClassName);
            }
        }
        // No redirection needed, return original class bytecode
        return classfileBuffer;
    }

    // Agent entry point called by the JVM on startup
    public static void premain(String agentArgs, Instrumentation inst) {
        // Define your class mappings here (or parse agentArgs for dynamic values)
        Map<String, String> mappings = new HashMap<>();
        mappings.put("test.nothere.found.class", "test.here.found.class");
        
        inst.addTransformer(new ClassRedirectionAgent(mappings));
    }
}

How to Use: #

1. Package this agent into a JAR with a manifest file containing:

   Premain-Class: your.package.ClassRedirectionAgent
   Can-Redefine-Classes: true
   

2. Start your application with the agent flag:

   java -javaagent:your-redirection-agent.jar -jar your-application.jar
   

Which Approach to Choose? #

• Pre-registration: Best for simple, one-off redirects when you control app startup.
• Custom ClassLoader: Ideal for multiple redirects or dynamic mapping updates.
• Instrumentation API: Use when you can't modify app startup code or need JVM-wide redirection.

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