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

// ① loadClass：模板方法（委派的载体），继承自 ClassLoader，一般不要重写
protected Class<?> loadClass(String name, boolean resolve) {
    Class<?> c = findLoadedClass(name);   // ① 查缓存
    if (c == null) { c = parent.loadClass(name, resolve); }  // ② 委派父
    if (c == null) { c = findClass(name); }          // ③ 自己找
    return c;
}

// ② findClass：真正的"查找逻辑"——你按自己的路径去把字节码读回来
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
    byte[] b = readFromMySource(name);        // 网络 / 磁盘 / 内存 / 加密文件，随你
    return defineClass(name, b, 0, b.length);   // ③ 交给 defineClass
}

// ③ defineClass：protected，把 byte[] 变成真正的 Class 对象——唯一能"制造"类的入口
//    只能在 ClassLoader 内部调用，防止外部代码随意定义类、破坏封装

import java.nio.file.*;

public class MyClassLoader extends ClassLoader {
    private final Path root;   // 类文件的根目录

    public MyClassLoader(String dir) {
        super();                 // parent 默认 = 系统加载器（App）
        this.root = Paths.get(dir);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            // com.foo.Bar → root/com/foo/Bar.class（全限定名里的点换成路径分隔符）
            Path p = root.resolve(name.replace('.', '/') + ".class");
            byte[] bytes = Files.readAllBytes(p);   // 读字节码
            return defineClass(name, bytes, 0, bytes.length);  // 铸成 Class
        } catch (Exception e) {
            throw new ClassNotFoundException(name, e);
        }
    }
}

// 演示：两个加载器实例加载"同一个类"，得到两个不同的 Class
MyClassLoader l1 = new MyClassLoader("/data/plugins/v1");
MyClassLoader l2 = new MyClassLoader("/data/plugins/v1");  // 同一个目录也没用
Class<?> c1 = l1.loadClass("com.foo.Bar");
Class<?> c2 = l2.loadClass("com.foo.Bar");
System.out.println(c1 == c2);                       // false！两个不同的 Class
System.out.println(c1.getClassLoader() == c2.getClassLoader());  // false

// 保守写法：仍遵守双亲委派，父先找，找不到才轮到自己
class ConservativeLoader extends ClassLoader {
    @Override protected Class<?> findClass(String n) { /* 只在这里找字节码 */ }
    // loadClass 不重写 → 默认顺序：findLoadedClass → parent → findClass
}

// 激进写法：先自己找，找不到才委派（破坏双亲委派）
class ChildFirstLoader extends ClassLoader {
    public ChildFirstLoader(ClassLoader parent) { super(parent); }

    @Override
    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        // ⚠️ 第①步必须先查缓存！漏掉会触发重复 define → LinkageError
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            try { c = findClass(name); }             // ① 先自己找
            catch (ClassNotFoundException e) {}
        }
        if (c == null) { c = super.loadClass(name, resolve); }  // ② 找不到才向上委派
        return c;
    }
}

// 骨架：每次检测到 class 文件变化，就用全新 ClassLoader 重新加载并执行
MyClassLoader currentLoader = null;   // 持有"当前"加载器的引用

while (true) {
    if (dirChanged()) {                       // 目录里 class 文件变了
        MyClassLoader newLoader = new MyClassLoader("/data/app");  // 全新加载器
        Class<?> c = newLoader.loadClass("com.foo.Worker");   // 加载新版本
        Object worker = c.getDeclaredConstructor().newInstance();  // 反射实例化
        c.getMethod("run").invoke(worker);             // 反射执行
        currentLoader = null;               // 丢弃旧加载器引用 → 旧类整批可回收
        currentLoader = newLoader;           // 换上新加载器
        // （真实框架会用版本号/守护线程池管理，这里只展示核心思想）
    }
    Thread.sleep(3000);
}