#自定义类加载器

// 自定义类加载器：从指定目录加载类
class DirectoryClassLoader extends ClassLoader {

    private final File classDir;

    public DirectoryClassLoader(String path) {
        this.classDir = new File(path);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 将类名转换为文件路径
        // com.example.Foo -> com/example/Foo.class
        String classFileName = name.replace('.', File.separatorChar) + ".class";
        File classFile = new File(classDir, classFileName);

        if (!classFile.exists()) {
            throw new ClassNotFoundException(name);
        }

        // 读取字节码文件
        byte[] bytecode;
        try {
            bytecode = Files.readAllBytes(classFile.toPath());
        } catch (IOException e) {
            throw new ClassNotFoundException(name, e);
        }

        // 调用 defineClass 将字节码转换为 Class 对象
        return defineClass(name, bytecode, 0, bytecode.length);
    }
}

// ClassLoader.loadClass() 的完整逻辑（JDK 8 源码简化）
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    // 1. 检查是否已加载
    Class<?> c = findLoadedClass(name);
    if (c != null) return c;

    // 2. 委派给父加载器（递归）
    ClassLoader parent = this.parent;
    if (parent != null) {
        c = parent.loadClass(name, false);
    } else {
        c = findBootstrapClassOrNull(name);
    }
    if (c != null) return c;

    // 3. 调用 findClass 由子类实现
    c = findClass(name);

    // 4. 如果 resolve 为 true，执行 resolveClass
    if (resolve) {
        resolveClass(c);
    }
    return c;
}

// defineClass 是 final 方法，不能重写
// 它的作用是将字节码数组转化为 Class 对象

// ✅ 正确用法：在 findClass 中调用
@Override
protected Class<?> findClass(String name) {
    byte[] bytecode = loadBytecode(name);
    return defineClass(name, bytecode, 0, bytecode.length);
}

// ❌ 错误用法：直接 new ClassLoader 并调用 defineClass
// 这样做违反了类的安全原则

// ✅ 正确用法：处理包名的情况
@Override
protected Class<?> findClass(String name) {
    // 如果类在某个包下，需要先设置包
    int lastDot = name.lastIndexOf('.');
    if (lastDot > 0) {
        String packageName = name.substring(0, lastDot);
        Package pkg = getPackage(packageName);
        if (pkg == null) {
            definePackage(packageName, null, null, null, null, null, null, null);
        }
    }

    byte[] bytecode = loadBytecode(name);
    return defineClass(name, bytecode, 0, bytecode.length);
}

// 加密工具类：运行时加密字节码
class EncryptUtil {
    public static byte[] encrypt(byte[] data, byte key) {
        for (int i = 0; i < data.length; i++) {
            data[i] ^= key;  // XOR 加密
        }
        return data;
    }
}

// 加密类加载器
class EncryptedClassLoader extends ClassLoader {

    private final byte secretKey;

    public EncryptedClassLoader(byte key) {
        this.secretKey = key;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String fileName = name.replace('.', '/') + ".class.enc";  // 加密后的文件
        URL url = getResource(fileName);
        if (url == null) throw new ClassNotFoundException(name);

        try (InputStream is = url.openStream()) {
            byte[] encrypted = is.readAllBytes();
            byte[] decrypted = EncryptUtil.encrypt(encrypted, secretKey);
            return defineClass(name, decrypted, 0, decrypted.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name, e);
        }
    }
}

// 网络类加载器：从远程服务器加载类字节码
class NetworkClassLoader extends ClassLoader {

    private final String remoteHost;
    private final int port;

    public NetworkClassLoader(String host, int port) {
        this.remoteHost = host;
        this.port = port;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String urlStr = "http://" + remoteHost + ":" + port + "/classes/" +
                        name.replace('.', '/') + ".class";

        try (InputStream is = new URL(urlStr).openStream()) {
            byte[] bytecode = is.readAllBytes();
            return defineClass(name, bytecode, 0, bytecode.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name, e);
        }
    }
}

// 热部署类加载器：同一个类的不同版本可以同时存在
class HotSwapClassLoader extends ClassLoader {

    // 存储已加载的类信息，用于判断是否需要重新加载
    private final Map<String, Long> classTimestamps = new HashMap<>();

    public HotSwapClassLoader() {
        super(HotSwapClassLoader.class.getClassLoader());  // 父加载器为 AppClassLoader
    }

    public Class<?> loadClass(String name, byte[] bytecode)
            throws ClassNotFoundException {
        // 1. 检查是否已加载
        Class<?> existing = findLoadedClass(name);
        if (existing != null) {
            // 2. 检查字节码是否更新
            Long cachedTimestamp = classTimestamps.get(name);
            long newTimestamp = getClassTimestamp(bytecode);

            if (cachedTimestamp != null && newTimestamp > cachedTimestamp) {
                // 3. 重新加载（创建新的类加载器实例）
                // 注意：不能复用同一个 ClassLoader 实例重新加载同一个类
                // 因为 ClassLoader 加载的类会进入缓存，无法清除
                throw new NeedNewClassLoaderException(name);
            }
        }

        // 4. 加载类
        classTimestamps.put(name, getClassTimestamp(bytecode));
        return defineClass(name, bytecode, 0, bytecode.length);
    }
}

// 方法一：打印类加载器信息
Class<?> clazz = Class.forName("com.example.Foo");
ClassLoader loader = clazz.getClassLoader();
System.out.println(loader);  // AppClassLoader 或自定义加载器名

// 方法二：获取类加载器链路
ClassLoader cl = clazz.getClassLoader();
while (cl != null) {
    System.out.println(cl);
    cl = cl.getParent();
}
System.out.println("Bootstrap");  // null 表示 Bootstrap

// 方法三：使用 jcmd 查看
jcmd <pid> VM.classloader_info