JVM类加载机制剖析

public class Test {
    private int count = 100;
    public void say() {
        System.out.println("Hello");
    }
}

public int add(int a, int b) {
    return a + b;
}

// 非法示例
int a = 1;
Object obj = a;  // 编译期就会报错，但如果通过篡改字节码绕过编译检查，验证阶段会拦截

public class Test {
    public static int value = 123;      // 准备阶段: value = 0
    public static final int CONST = 45; // 准备阶段: CONST = 45
}

public class A {
    public void test() {
        B b = new B();  // 编译后常量池存储符号引用 "com/example/B"
        b.method();     // 符号引用 "com/example/B.method:()V"
    }
}

public class Test {
    static {
        i = 10;             // 可以赋值
        System.out.println(i);  // 编译错误：非法前向引用
    }
    public static int i = 5;

    static {
        System.out.println(i);  // 输出5
    }
}

// 生成的<clinit>方法：
static <clinit>() {
    i = 10;
    i = 5;
    System.out.println(i);
}

// 1. 通过子类引用父类的静态字段，不会触发子类初始化
System.out.println(Child.parentValue);

// 2. 通过数组定义来引用类，不会触发初始化
Parent[] arr = new Parent[10];

// 3. 引用常量不会触发初始化（常量在编译期已放入常量池）
System.out.println(Parent.CONST);

public class DeadLoopClass {
    static {
        if (true) {
            System.out.println(Thread.currentThread() + " init");
            while (true) {}  // 模拟耗时操作
        }
    }
}

// 线程1: 执行<clinit>，陷入死循环
// 线程2: 等待线程1完成，永远阻塞

public class ClassLoaderTest {
    public static void main(String[] args) {
        ClassLoader loader = ClassLoaderTest.class.getClassLoader();
        System.out.println(loader);  // sun.misc.Launcher$AppClassLoader

        System.out.println(loader.getParent());  // sun.misc.Launcher$ExtClassLoader

        System.out.println(loader.getParent().getParent());  // null (Bootstrap)
    }
}

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // 1. 检查类是否已加载
        Class<?> c = findLoadedClass(name);

        if (c == null) {
            try {
                // 2. 委派给父类加载器
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    // 3. 父类为null，说明是ExtClassLoader，委派给Bootstrap
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 父类加载器无法加载
            }

            if (c == null) {
                // 4. 父类加载失败，自己加载
                c = findClass(name);
            }
        }

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

// 假设没有双亲委派，你写了一个恶意的java.lang.String
package java.lang;

public class String {
    // 恶意代码
}

// 这个类会被你的类加载器加载，可能导致安全问题
// 有了双亲委派，启动类加载器会先加载JDK自带的String，你的类永远不会被加载

// DriverManager.java (JDK代码)
static {
    loadInitialDrivers();
}

private static void loadInitialDrivers() {
    // 使用ServiceLoader加载驱动
    ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);

    // ServiceLoader内部使用线程上下文类加载器
    Iterator<Driver> driversIterator = loadedDrivers.iterator();
    while (driversIterator.hasNext()) {
        driversIterator.next();
    }
}

// ServiceLoader.java
public static <S> ServiceLoader<S> load(Class<S> service) {
    // 获取线程上下文类加载器（默认是AppClassLoader）
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    return ServiceLoader.load(service, cl);
}

// WebappClassLoaderBase.java (Tomcat源码)
public Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException {

    Class<?> clazz = null;

    // 1. 查缓存
    clazz = findLoadedClass0(name);
    if (clazz != null) return clazz;

    clazz = findLoadedClass(name);
    if (clazz != null) return clazz;

    // 2. 对于系统类，委派给父加载器
    if (name.startsWith("java.")) {
        return Class.forName(name, false, parent);
    }

    // 3. 先尝试自己加载（打破双亲委派！）
    try {
        clazz = findClass(name);
        if (clazz != null) return clazz;
    } catch (ClassNotFoundException e) {}

    // 4. 自己加载失败，再委派给父加载器
    if (!delegateLoad) {
        clazz = parent.loadClass(name);
    }

    return clazz;
}

public class CustomClassLoader extends ClassLoader {
    private String classPath;

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

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            // 1. 读取.class文件的字节数组
            byte[] data = loadClassData(name);

            // 2. 调用defineClass方法将字节数组转换为Class对象
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            throw new ClassNotFoundException(name, e);
        }
    }

    private byte[] loadClassData(String name) throws IOException {
        // 将类名转换为文件路径: com.example.Test -> com/example/Test.class
        String fileName = name.replace('.', '/') + ".class";
        Path path = Paths.get(classPath, fileName);

        return Files.readAllBytes(path);
    }
}

// 使用
CustomClassLoader loader = new CustomClassLoader("/path/to/classes");
Class<?> clazz = loader.loadClass("com.example.Test");
Object instance = clazz.newInstance();

CustomClassLoader loader1 = new CustomClassLoader("/path");
CustomClassLoader loader2 = new CustomClassLoader("/path");

Class<?> class1 = loader1.loadClass("com.example.Test");
Class<?> class2 = loader2.loadClass("com.example.Test");

System.out.println(class1 == class2);  // false !

Object obj1 = class1.newInstance();
Object obj2 = class2.newInstance();

System.out.println(obj1 instanceof obj2.getClass());  // false !

public class HotSwapClassLoader extends ClassLoader {
    private String classPath;

    public HotSwapClassLoader(String classPath) {
        super(HotSwapClassLoader.class.getClassLoader());  // 指定父类加载器
        this.classPath = classPath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] data = loadClassData(name);
        return defineClass(name, data, 0, data.length);
    }

    private byte[] loadClassData(String name) throws IOException {
        String fileName = name.replace('.', '/') + ".class";
        Path path = Paths.get(classPath, fileName);
        return Files.readAllBytes(path);
    }
}

// 热部署管理器
public class HotDeployManager {
    private HotSwapClassLoader currentLoader;
    private String classPath;

    public HotDeployManager(String classPath) {
        this.classPath = classPath;
        reload();
    }

    public void reload() {
        // 创建新的类加载器实例
        currentLoader = new HotSwapClassLoader(classPath);
        System.out.println("重新加载完成");
    }

    public Object getInstance(String className) throws Exception {
        Class<?> clazz = currentLoader.loadClass(className);
        return clazz.newInstance();
    }

    public static void main(String[] args) throws Exception {
        HotDeployManager manager = new HotDeployManager("/tmp/classes");

        while (true) {
            Object obj = manager.getInstance("com.example.HotClass");
            Method method = obj.getClass().getMethod("doSomething");
            method.invoke(obj);

            Thread.sleep(3000);

            System.out.println("按Enter键重新加载类...");
            System.in.read();
            manager.reload();
        }
    }
}

module com.example.myapp {
    requires java.sql;                     // 依赖java.sql模块
    requires transitive java.logging;      // 传递依赖
    exports com.example.myapp.api;         // 导出包
    opens com.example.myapp.internal to    // 反射访问
        com.example.framework;
}