自定义类加载器包扫描触发NoClassDefFoundError问题求助

Let's break down what's causing that wrong name error and fix your class loader step by step.

The Root Cause #

The error java.lang.NoClassDefFoundError: b\Fibonacci (wrong name: b/Fibonacci) tells us exactly what's broken:

• Java expects fully qualified class names to use dots (.) to separate package components (e.g., b.Fibonacci), but your code is using the system's file separator (backslash \ on Windows) when building the class name.
• When you pass b\Fibonacci to defineClass, the JVM rejects it because it doesn't match the actual class name stored in the .class file (which is b.Fibonacci).

Key Fixes Needed #

1. Build Class Names with Dots, Not File Separators #

In your getPlugins method, you're constructing the class name using File.separator—this is incorrect. We need to use dots for package hierarchy instead.

2. Recursively Build Full Qualified Class Names Correctly #

When descending into subdirectories (like the b folder), we need to append the directory name to the package path using dots, not file separators.

3. Clean Up File Path Resolution #

Ensure the path to the .class file is correctly derived from the valid fully qualified class name.

Modified Working Code #

Here's the fixed version of your PluginDemo class, with critical changes highlighted:

package testpack;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.util.*;

public class PluginDemo extends ClassLoader {
    static String pluginsDir = "ext";
    static File basePluginDir = null;
    static List<PluginFunction> plugins; // Add generic type for type safety

    public static void main(String args[]) {
        PluginDemo demo = new PluginDemo();
        basePluginDir = new File(System.getProperty("user.dir") + File.separator + pluginsDir);
        demo.getPlugins(pluginsDir, "");
        
        // Optional: Test loaded plugins to confirm functionality
        System.out.println("\nLoaded plugins:");
        for (PluginFunction pf : plugins) {
            System.out.println("- " + pf.getPluginName());
            pf.setParameter(10);
            System.out.println("  Result for input 10: " + pf.getResult());
        }
    }

    PluginDemo() {
        plugins = new ArrayList<>();
    }

    protected void getPlugins(String directoryPath, String currentPackage) {
        File dir = new File(System.getProperty("user.dir") + File.separator + directoryPath);
        if (!dir.exists() || !dir.isDirectory()) {
            return;
        }

        String[] files = dir.list();
        if (files == null) {
            return;
        }

        for (String file : files) {
            try {
                String fullFilePath = directoryPath + File.separator + file;
                File currentFile = new File(System.getProperty("user.dir"), fullFilePath);
                
                if (currentFile.isDirectory()) {
                    // Build new package name: append subdirectory with dot
                    String newPackage = currentPackage.isEmpty() 
                        ? file 
                        : currentPackage + "." + file;
                    getPlugins(fullFilePath, newPackage);
                    continue; // Skip to next file, since this is a directory
                }

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

                // Build valid fully qualified class name
                String className = file.substring(0, file.lastIndexOf("."));
                String fullClassName = currentPackage.isEmpty() 
                    ? className 
                    : currentPackage + "." + className;

                // Load and validate the class
                Class<?> c = loadClass(fullClassName);
                for (Class<?> intf : c.getInterfaces()) {
                    if (intf.equals(PluginFunction.class)) { // Use equals instead of string comparison
                        PluginFunction pf = (PluginFunction) c.getDeclaredConstructor().newInstance(); // Use modern instantiation
                        plugins.add(pf);
                        break;
                    }
                }

            } catch (Exception ex) {
                System.err.println("Failed to load plugin from file: " + file);
                ex.printStackTrace();
            }
        }
    }

    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            // Check if class is already loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                try {
                    // Delegate to parent class loader first (proper parent delegation model)
                    c = getParent().loadClass(name);
                } catch (ClassNotFoundException e) {
                    // If parent can't find it, load from our plugin directory
                    String classFilePath = name.replace('.', File.separatorChar) + ".class";
                    File classFile = new File(System.getProperty("user.dir"), pluginsDir + File.separator + classFilePath);
                    
                    if (!classFile.exists()) {
                        throw new ClassNotFoundException("Class not found in plugin directory: " + name);
                    }

                    int length = (int) classFile.length();
                    byte[] classBytes = new byte[length];
                    try (DataInputStream in = new DataInputStream(new FileInputStream(classFile))) {
                        in.readFully(classBytes);
                    }

                    c = defineClass(name, classBytes, 0, length);
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
}

What Changed? #

1. Class Name Construction:

   • Replaced File.separator with dots (.) when building the fully qualified class name.
   • Handled empty package roots correctly for classes in the top-level of ext.

2. Recursive Package Handling:

   • Updated the recursive getPlugins call to build package names with dots instead of file separators.

3. ClassLoader Best Practices:

   • Used getParent().loadClass() instead of findSystemClass() to follow the standard parent delegation model.
   • Added synchronization with getClassLoadingLock() to comply with modern class loader standards.
   • Used try-with-resources for input streams to ensure proper resource cleanup.
   • Replaced deprecated newInstance() with getDeclaredConstructor().newInstance().

4. Type Safety:

   • Added generic type List<PluginFunction> to avoid unchecked casts.

Testing the Fix #

After applying these changes:

1. Verify your ext directory structure:

   ext/
     b/
       Fibonacci.class
   

2. Compile all classes (including Fibonacci.java) and place the compiled .class files in the correct paths.
3. Run PluginDemo—it should load the Fibonacci plugin successfully and print its name and test result.

Additional Notes #

• Ensure the PluginFunction interface is accessible to both the main application and plugins (it should be in the same package and available on the classpath).
• For more complex plugin systems, consider using URLClassLoader instead of rolling your own, but this fix works perfectly for your use case.

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