Java ClassLoaders — Deep Dive for Interviews

public class ClassLoaderDemo {
    public static void main(String[] args) {
        // Bootstrap ClassLoader (returns null -- implemented in native code)
        System.out.println(String.class.getClassLoader());        // null

        // Platform ClassLoader (Java 9+) / Extension ClassLoader (Java 8)
        System.out.println(java.sql.Driver.class.getClassLoader()); 
        // jdk.internal.loader.ClassLoaders$PlatformClassLoader

        // Application ClassLoader
        System.out.println(ClassLoaderDemo.class.getClassLoader());
        // jdk.internal.loader.ClassLoaders$AppClassLoader
    }
}

// Simplified view of how ClassLoader.loadClass() works
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    // 1. Check if already loaded
    Class<?> c = findLoadedClass(name);

    if (c == null) {
        try {
            // 2. Delegate to parent
            if (parent != null) {
                c = parent.loadClass(name, false);
            } else {
                // 3. Bootstrap ClassLoader (no Java parent)
                c = findBootstrapClassOrNull(name);
            }
        } catch (ClassNotFoundException e) {
            // Parent could not find it -- expected
        }

        if (c == null) {
            // 4. Try to find it ourselves
            c = findClass(name);
        }
    }

    if (resolve) {
        resolveClass(c);
    }
    return c;
}

public class InitOrder {
    static int a = 10;                  // Step 1: a = 10
    static int b;                       // Step 2: b remains 0 (from Prepare)

    static {
        b = a * 2;                      // Step 3: b = 20
        System.out.println("Static block: a=" + a + ", b=" + b);
    }

    static int c = b + 5;              // Step 4: c = 25
}

// Triggers static initialization -- essential for JDBC driver registration
Class.forName("com.mysql.cj.jdbc.Driver");
// The Driver class has: static { DriverManager.registerDriver(new Driver()); }

// Does NOT trigger initialization -- just loads the bytecode
ClassLoader cl = Thread.currentThread().getContextClassLoader();
Class<?> clazz = cl.loadClass("com.mysql.cj.jdbc.Driver");
// Driver is NOT registered yet!

// Explicit control: load but don't initialize
Class.forName("com.mysql.cj.jdbc.Driver", false, cl);

public class PluginClassLoader extends ClassLoader {

    private final Path pluginDir;

    public PluginClassLoader(Path pluginDir, ClassLoader parent) {
        super(parent);  // set parent for delegation
        this.pluginDir = pluginDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // Convert com.example.MyPlugin -> com/example/MyPlugin.class
        String fileName = name.replace('.', File.separatorChar) + ".class";
        Path classFile = pluginDir.resolve(fileName);

        try {
            byte[] bytes = Files.readAllBytes(classFile);

            // defineClass: converts raw bytes into a Class object
            // This is the critical method -- only ClassLoader can call it
            return defineClass(name, bytes, 0, bytes.length);
        } catch (IOException e) {
            throw new ClassNotFoundException("Could not load " + name, e);
        }
    }
}

// Usage
Path pluginDir = Path.of("/opt/app/plugins");
PluginClassLoader loader = new PluginClassLoader(pluginDir, 
    ClassLoader.getSystemClassLoader());

Class<?> pluginClass = loader.loadClass("com.vendor.AnalyticsPlugin");
Object plugin = pluginClass.getDeclaredConstructor().newInstance();

// Cast to a shared interface (loaded by the parent classloader)
Plugin p = (Plugin) plugin;
p.execute();

// How ServiceLoader uses the context classloader internally
public static <S> ServiceLoader<S> load(Class<S> service) {
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    return new ServiceLoader<>(service, cl);
}

// Setting a custom context classloader (common in app servers)
Thread.currentThread().setContextClassLoader(myCustomLoader);
try {
    // Code here will use myCustomLoader for SPI lookups
    ServiceLoader<Plugin> plugins = ServiceLoader.load(Plugin.class);
} finally {
    // Always restore the original
    Thread.currentThread().setContextClassLoader(originalLoader);
}

// Common leak pattern: ThreadLocal holding a reference to a webapp class
public class LeakyService {
    // This ThreadLocal holds a reference to a class loaded by the WebAppClassLoader
    private static final ThreadLocal<ExpensiveObject> cache = 
        ThreadLocal.withInitial(ExpensiveObject::new);
    // If this thread is a server thread that outlives the webapp,
    // the WebAppClassLoader can never be GC'd
}

// ClassNotFoundException -- the class is simply not on the classpath
try {
    Class<?> clazz = Class.forName("com.nonexistent.MyClass");
} catch (ClassNotFoundException e) {
    System.out.println("Class not found: " + e.getMessage());
}

// NoClassDefFoundError -- class existed at compile time but fails at runtime
// Scenario: PaymentProcessor depends on StripeSDK, which is missing from the runtime JAR
public class OrderService {
    public void processPayment() {
        // Compiles fine, but if stripe-sdk.jar is missing at runtime:
        // java.lang.NoClassDefFoundError: com/stripe/StripeClient
        StripeClient client = new StripeClient();
    }
}

public class BrokenConfig {
    static {
        // This throws an exception during class initialization
        String value = System.getProperty("missing.property");
        int parsed = Integer.parseInt(value); // NullPointerException!
    }
}

// First access:  ExceptionInInitializerError (wraps NullPointerException)
// Second access: NoClassDefFoundError (class permanently marked as failed)

// Load classes from external JARs at runtime
URL[] urls = {
    new File("/opt/plugins/analytics.jar").toURI().toURL(),
    new File("/opt/plugins/reporting.jar").toURI().toURL()
};

// Parent = system classloader for delegation
try (URLClassLoader loader = new URLClassLoader(urls, 
        ClassLoader.getSystemClassLoader())) {

    Class<?> reportClass = loader.loadClass("com.vendor.ReportGenerator");
    Object generator = reportClass.getDeclaredConstructor().newInstance();

    // Use reflection or a shared interface to invoke methods
    Method generate = reportClass.getMethod("generate", String.class);
    generate.invoke(generator, "Q4-2025");
}
// URLClassLoader implements Closeable -- always close to release JAR file handles

// Pre-Java 9: Any class could access any public class
// Java 9+: Modules must explicitly export packages

module com.myapp {
    requires java.sql;           // dependency on java.sql module
    requires java.logging;       // dependency on java.logging module
    exports com.myapp.api;       // only this package is visible to other modules
    opens com.myapp.internal to spring.core;  // allow reflection from Spring
}

// Accessing module info at runtime
Module mod = String.class.getModule();
System.out.println(mod.getName());        // java.base
System.out.println(mod.getDescriptor());  // module descriptor

ModuleLayer layer = ModuleLayer.boot();
layer.modules().forEach(m -> System.out.println(m.getName()));

public class HotReloader {
    private PluginClassLoader currentLoader;
    private Plugin activePlugin;

    public void reload() throws Exception {
        // 1. Discard old classloader (allows GC of old classes)
        if (currentLoader != null) {
            currentLoader = null;  // eligible for GC
        }

        // 2. Create a fresh classloader
        currentLoader = new PluginClassLoader(
            Path.of("/opt/app/plugins"),
            ClassLoader.getSystemClassLoader()
        );

        // 3. Load the updated class
        Class<?> pluginClass = currentLoader.loadClass("com.vendor.AnalyticsPlugin");
        activePlugin = (Plugin) pluginClass.getDeclaredConstructor().newInstance();

        System.out.println("Plugin reloaded successfully");
    }
}

// Fix: Deregister JDBC drivers on shutdown
@WebListener
public class CleanupListener implements ServletContextListener {
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        Enumeration<Driver> drivers = DriverManager.getDrivers();
        while (drivers.hasMoreElements()) {
            Driver driver = drivers.nextElement();
            if (driver.getClass().getClassLoader() == getClass().getClassLoader()) {
                try {
                    DriverManager.deregisterDriver(driver);
                } catch (SQLException e) {
                    // log warning
                }
            }
        }
    }
}

// Debugging classloader identity
System.out.println("Class: " + obj.getClass().getName());
System.out.println("ClassLoader: " + obj.getClass().getClassLoader());
System.out.println("Target ClassLoader: " + User.class.getClassLoader());
System.out.println("Same class? " + (obj.getClass() == User.class));

// Wrong: looks relative to the ClassLoader root
InputStream is = MyClass.class.getResourceAsStream("config.properties");

// Right: absolute path from classpath root
InputStream is = MyClass.class.getResourceAsStream("/config.properties");

// Alternative: use the classloader directly (always absolute)
InputStream is = MyClass.class.getClassLoader()
    .getResourceAsStream("config.properties");