自定义类加载器：热部署与模块化隔离

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {

    // 1. 检查是否已加载
    Class<?> c = findLoadedClass(name);
    if (c == null) {
        // 2. 委托给父加载器
        if (parent != null)
            c = parent.loadClass(name, false);
        else
            c = findBootstrapClassOrNull(name);
    }
    if (c == null) {
        // 3. 父加载器都找不到 → 自己找
        c = findClass(name);
    }
    if (resolve) resolveClass(c);
    return c;
}

public class MyClassLoader extends ClassLoader {

    private final String classPath; // class 文件根目录

    public MyClassLoader(String classPath) {
        this.classPath = classPath;
    }

    protected Class<?> findClass(String name)
            throws ClassNotFoundException {

        // 1. 将类名转为文件路径：com.example.Foo → com/example/Foo.class
        String fileName = name.replace('.', '/') + ".class";
        File file = new File(classPath, fileName);

        if (!file.exists())
            throw new ClassNotFoundException(name);

        try {
            // 2. 读取字节数组
            byte[] bytes = readBytes(file);

            // 3. 可选：解密（商业软件常见）
            // bytes = decrypt(bytes);

            // 4. 调用 defineClass 将字节转为 Class 对象
            return defineClass(name, bytes, 0, bytes.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name, e);
        }
    }

    private byte[] readBytes(File file) throws IOException {
        return Files.readAllBytes(file.toPath());
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        MyClassLoader loader = new MyClassLoader("/opt/myapp/classes");
        Class<?> clazz = loader.loadClass("com.example.HelloService");
        Object obj = clazz.getDeclaredConstructor().newInstance();
        Method say = clazz.getMethod("say", String.class);
        say.invoke(obj, "World");
    }
}

public class HotDeployer {
    private volatile MyClassLoader currentLoader; // volatile 保证工作线程读到最新加载器

    public HotDeployer(String classPath) {
        this.currentLoader = new MyClassLoader(classPath);
    }
    // 部署新版本：创建新 ClassLoader，替换引用
    public void deploy() {
        MyClassLoader old = this.currentLoader;
        this.currentLoader = new MyClassLoader(old.classPath);
        // old 不再被引用 → GC 可回收旧类和旧加载器
    }
    // 执行业务方法
    public void execute(String className, String input) throws Exception {
        Class<?> clazz = currentLoader.loadClass(className);
        Object svc = clazz.getDeclaredConstructor().newInstance();
        clazz.getMethod("handle", String.class).invoke(svc, input);
    }
}

MyClassLoader loader1 = new MyClassLoader("/app/plugin-a/classes");
MyClassLoader loader2 = new MyClassLoader("/app/plugin-b/classes");

Class<?> classA = loader1.loadClass("com.example.Service");
Class<?> classB = loader2.loadClass("com.example.Service");

System.out.println(classA == classB);       // false！
System.out.println(classA.getName());       // com.example.Service
System.out.println(classB.getName());       // com.example.Service（同名，不同类）

// 下面这行会抛 ClassCastException！
Object objA = classA.getDeclaredConstructor().newInstance();
classB.cast(objA);  // ClassCastException: com.example.Service cannot be cast to com.example.Service

# Bundle A
Bundle-SymbolicName: com.example.service-a
Export-Package: com.example.api;version="1.0"
Import-Package: org.slf4j;version="[1.7,2.0)"
# Bundle B
Bundle-SymbolicName: com.example.service-b
Export-Package: com.example.api;version="2.0"
Import-Package: org.slf4j;version="[2.0,3.0)"
# 两个 Bundle 各自有独立 ClassLoader，com.example.api 是两个不同的 Class
# slf4j 1.7 和 2.0 也可以在不同 Bundle 中共存

// 陷阱 1：忘记设置父加载器 → 系统类都加载不到
MyClassLoader loader = new MyClassLoader("/path");
// 如果 loadClass 里没委派给 parent，连 java.lang.String 都找不到

// 陷阱 2：热部署后旧类无法 GC → Metaspace OOM
// 原因：旧类的实例被 static 变量 / ThreadLocal / 全局缓存持有
// 排查：-verbose:class 或 -XX:+TraceClassUnloading 观察类卸载日志

// 陷阱 3：不同 ClassLoader 加载的类无法直接 cast
Object obj = loaderA.loadClass("com.example.Foo").newInstance();
Foo foo = (Foo) obj; // ClassCastException！因为 Foo 是当前类加载器加载的
// 解决：通过公共接口 + 父加载器加载接口类来实现跨加载器通信

// 接口放在公共 classpath，由父加载器加载
public interface Plugin { String execute(String input); }
// 实现类放在插件目录，由子加载器加载
public class MyPlugin implements Plugin {
    public String execute(String input) { return "Hello " + input; }
}
// 主程序通过接口类型操作插件实例
Class<?> clazz = pluginLoader.loadClass("com.example.MyPlugin");
Plugin plugin = (Plugin) clazz.getDeclaredConstructor().newInstance();
// 转型成功！Plugin 接口是父加载器加载的，双方看到的是同一个 Class

"自定义类加载器主要用于三个场景：热部署、模块隔离、加密加载。

 重写 findClass 保留双亲委派，适合大多数场景——从自定义路径读字节、
 调用 defineClass 即可。

 重写 loadClass 打破双亲委派，用于需要类隔离的场景——Tomcat 的
 WebappClassLoader 和 OSGi 的 BundleClassLoader 都是这么做的。

 热部署的原理是：每次部署创建新的 ClassLoader 实例加载新版本 class，
 旧 ClassLoader 不再被引用后，旧类和实例可被 GC 从 Metaspace 卸载。

 类隔离的本质：JVM 用 (类名, ClassLoader) 二元组标识一个类，
 不同加载器的同名类是不同的 Class 对象，无法互相转型。"