类加载机制

// 案例:一个看似简单的类冲突问题
public class OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
    
    public void createOrder(Order order) {
        logger.info("Creating order: {}", order.getId());
        // 业务逻辑...
    }
}

// 问题现象:
// - 本地运行正常
// - 线上环境报错: java.lang.NoSuchMethodError: org.slf4j.Logger.info(Ljava/lang/String;Ljava/lang/Object;)V

// 排查过程:
// 1. 使用 jcmd <pid> VM.system_properties | grep class.path 查看类路径
// 2. 使用 jcmd <pid> VM.classloader_stats 查看类加载器统计
// 3. 使用 arthas 的 sc -d org.slf4j.Logger 查看类来源
// 4. 发现问题: classpath 中存在两个版本的 slf4j-api.jar

// 根本原因:
// - 应用依赖 slf4j-api-1.7.30.jar (支持 info(String, Object) 方法)
// - 某个依赖传递引入 slf4j-api-1.7.25.jar (不支持该方法)
// - 类加载器加载了错误版本的 Logger 类

// 解决方案:
// 1. 使用 mvn dependency:tree 排查依赖树
// 2. 使用 <exclusion> 排除冲突依赖
// 3. 使用 maven-enforcer-plugin 强制统一版本

┌─────────────┐
│   加载      │ ──→ 读取 .class 文件,生成 Class 对象
└──────┬──────┘
       │
       ↓
┌─────────────┐
│   验证      │ ──→ 确保字节码符合规范,安全可靠
└──────┬──────┘
       │
       ↓
┌─────────────┐
│   准备      │ ──→ 为类变量分配内存,设置初始值
└──────┬──────┘
       │
       ↓
┌─────────────┐
│   解析      │ ──→ 符号引用替换为直接引用
└──────┬──────┘
       │
       ↓
┌─────────────┐
│   初始化    │ ──→ 执行类初始化代码 <clinit>()
└──────┬──────┘
       │
       ↓
┌─────────────┐
│   使用      │ ──→ 类被程序使用
└──────┬──────┘
       │
       ↓
┌─────────────┐
│   卸载      │ ──→ 类被垃圾回收
└─────────────┘

// 动态代理示例:运行时生成类
public class DynamicProxyDemo {
    public static void main(String[] args) {
        // 动态代理会在运行时生成 $Proxy0 类
        // 这个类的字节码是在运行时计算生成的,不会保存到文件中
        Runnable proxy = (Runnable) Proxy.newProxyInstance(
            DynamicProxyDemo.class.getClassLoader(),
            new Class<?>[] { Runnable.class },
            (proxyObj, method, args1) -> {
                System.out.println("Before method: " + method.getName());
                Object result = method.invoke(proxyObj, args1);
                System.out.println("After method: " + method.getName());
                return result;
            }
        );
        
        proxy.run();
    }
}

┌────────────────────────────────────────┐
│            方法区存储结构               │
├────────────────────────────────────────┤
│  类信息                                │
│  ├─ 类名、父类名、接口列表             │
│  ├─ 访问标志(public/final/abstract等) │
│  └─ 类索引、父类索引、接口索引         │
├────────────────────────────────────────┤
│  字段信息                              │
│  ├─ 字段名、类型、访问标志             │
│  └─ 属性表(常量值、注解等)            │
├────────────────────────────────────────┤
│  方法信息                              │
│  ├─ 方法名、返回类型、参数列表         │
│  ├─ 访问标志、异常表                   │
│  └─ Code 属性(字节码指令)             │
├────────────────────────────────────────┤
│  运行时常量池                          │
│  ├─ 字面量(字符串、数值)              │
│  └─ 符号引用(类、字段、方法引用)      │
└────────────────────────────────────────┘

public class ClassObjectDemo {
    public static void main(String[] args) throws Exception {
        // 三种获取 Class 对象的方式
        
        // 1. 类名.class (最常用)
        Class<?> clazz1 = String.class;
        
        // 2. 对象.getClass()
        String str = "hello";
        Class<?> clazz2 = str.getClass();
        
        // 3. Class.forName() (动态加载)
        Class<?> clazz3 = Class.forName("java.lang.String");
        
        // 验证:同一个类只有一个 Class 对象
        System.out.println(clazz1 == clazz2);  // true
        System.out.println(clazz2 == clazz3);  // true
    }
}

public class ArrayClassDemo {
    public static void main(String[] args) {
        // 引用类型数组:加载器与元素类型一致
        String[] stringArray = new String[10];
        System.out.println("String[] 的类加载器: " + 
            stringArray.getClass().getClassLoader()); 
        // 输出: null (与 String 类的加载器一致,即 Bootstrap ClassLoader)
        
        // 基本类型数组:标记为与引导类加载器关联
        int[] intArray = new int[10];
        System.out.println("int[] 的类加载器: " + 
            intArray.getClass().getClassLoader()); 
        // 输出: null
        
        // 自定义类数组:加载器与自定义类一致
        MyClass[] myClassArray = new MyClass[10];
        System.out.println("MyClass[] 的类加载器: " + 
            myClassArray.getClass().getClassLoader()); 
        // 输出: sun.misc.Launcher$AppClassLoader@xxx
    }
}

// 恶意 Class 文件示例(概念演示)
// 一个正常编译的类不应该有以下行为:
public class MaliciousClass {
    static {
        try {
            // 尝试绕过安全检查
            System.setSecurityManager(null);
            
            // 执行系统命令(危险!)
            Runtime.getRuntime().exec("rm -rf /");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 查看魔数和版本号
public class MagicNumberDemo {
    public static void main(String[] args) throws Exception {
        String classFile = "target/classes/com/example/MyClass.class";
        
        try (FileInputStream fis = new FileInputStream(classFile)) {
            byte[] magic = new byte[4];
            fis.read(magic);
            
            // 转换为十六进制字符串
            System.out.printf("魔数: %02X %02X %02X %02X%n",
                magic[0] & 0xFF, magic[1] & 0xFF,
                magic[2] & 0xFF, magic[3] & 0xFF);
            // 输出: 魔数: CA FE BA BE
            
            // 读取版本号
            byte[] version = new byte[4];
            fis.read(version);
            int minorVersion = ((version[0] & 0xFF) << 8) | (version[1] & 0xFF);
            int majorVersion = ((version[2] & 0xFF) << 8) | (version[3] & 0xFF);
            System.out.printf("版本: %d.%d (JDK %d)%n", 
                minorVersion, majorVersion, majorVersion - 44);
        }
    }
}

// 编译时检查的示例
// 错误示例 1: 继承 final 类
// 编译错误: Cannot inherit from final 'java.lang.String'
// public class MyString extends String { }  

// 错误示例 2: 未实现抽象方法
abstract class AbstractParent {
    public abstract void doSomething();
}

// 编译错误: MyChild is not abstract and does not override abstract method
// class MyChild extends AbstractParent { }

// 正常代码
public void validMethod() {
    int a = 1;
    int b = 2;
    int c = a + b;
    System.out.println(c);
}

// 对应的字节码(简化)
// 0: iconst_1        // 将常量 1 压入操作数栈
// 1: istore_1        // 将栈顶 int 值存入局部变量表索引 1
// 2: iconst_2        // 将常量 2 压入操作数栈
// 3: istore_2        // 将栈顶 int 值存入局部变量表索引 2
// 4: iload_1         // 从局部变量表索引 1 加载 int 值
// 5: iload_2         // 从局部变量表索引 2 加载 int 值
// 6: iadd            // 执行 int 加法
// 7: istore_3        // 将结果存入局部变量表索引 3

// 引用不存在的类
public class InvalidReference {
    public static void main(String[] args) {
        // 编译时存在,运行时不存在
        NonExistentClass obj = new NonExistentClass();
        // NoClassDefFoundError: NonExistentClass
    }
}

## 启动时关闭验证(仅用于受信任的代码)
java -Xverify:none -jar app.jar

## 注意:
## - 仅在生产环境使用,开发环境建议保留验证
## - 确保代码来源可信
## - 可能影响安全性

public class PreparationDemo {
    // 准备阶段分配内存并设置零值
    public static int intValue;           // 0
    public static long longValue;         // 0L
    public static float floatValue;       // 0.0f
    public static double doubleValue;     // 0.0d
    public static boolean booleanValue;   // false
    public static char charValue;         // '\u0000'
    public static String referenceValue;  // null
    
    public static void main(String[] args) {
        System.out.println("int: " + intValue);           // 0
        System.out.println("long: " + longValue);         // 0
        System.out.println("float: " + floatValue);       // 0.0
        System.out.println("double: " + doubleValue);     // 0.0
        System.out.println("boolean: " + booleanValue);   // false
        System.out.println("char: [" + charValue + "]");  // []
        System.out.println("reference: " + referenceValue); // null
    }
}

public class ConstantValueDemo {
    // 普通 static 变量
    public static int normalStatic = 100;
    
    // static final 常量(基本类型或 String)
    public static final int FINAL_INT = 200;
    public static final String FINAL_STRING = "Hello";
    
    // static final 但不是编译时常量
    public static final int NOT_CONSTANT = new Random().nextInt();
    
    public static void main(String[] args) {
        // 准备阶段:
        // - normalStatic = 0 (零值)
        // - FINAL_INT = 200 (ConstantValue 属性)
        // - FINAL_STRING = "Hello" (ConstantValue 属性)
        // - NOT_CONSTANT = 0 (零值)
        
        // 初始化阶段:
        // - normalStatic = 100
        // - NOT_CONSTANT = 随机值
        
        System.out.println("normalStatic: " + normalStatic);  // 100
        System.out.println("FINAL_INT: " + FINAL_INT);        // 200
        System.out.println("FINAL_STRING: " + FINAL_STRING);  // Hello
        System.out.println("NOT_CONSTANT: " + NOT_CONSTANT);  // 随机值
    }
}

┌─────────────────────────────────────────────┐
│            直接引用的实现方式               │
├─────────────────────────────────────────────┤
│                                             │
│  1. 直接指针(HotSpot 使用)                 │
│     ┌───────┐                              │
│     │引用   │ ─────────────→ [对象内存地址] │
│     └───────┘                              │
│                                             │
│  2. 句柄                                   │
│     ┌───────┐    ┌──────────┐              │
│     │引用   │ →  │ 句柄池   │ → [对象]     │
│     └───────┘    └──────────┘              │
│                       ↓                    │
│                   [类型数据]               │
│                                             │
│  3. 偏移量                                 │
│     ┌───────┐                              │
│     │引用   │ → [基地址 + 偏移量]          │
│     └───────┘                              │
│                                             │
└─────────────────────────────────────────────┘

public class ResolutionTimingDemo {
    public static void main(String[] args) {
        // 静态解析:编译期可知,运行期不变
        // private、static、final 方法
        StaticClass.staticMethod();
        
        // 动态解析:运行期才能确定
        // 虚方法(override 方法)
        Parent obj = new Child();
        obj.virtualMethod();  // 运行时解析
    }
}

class StaticClass {
    public static void staticMethod() { }
}

class Parent {
    public void virtualMethod() { }
}

class Child extends Parent {
    @Override
    public void virtualMethod() { }
}

public class ClinitDemo {
    static int a = 1;
    static {
        a = 2;
        b = 3; // 可以赋值,但不能访问
    }
    static int b = 4;
    
    public static void main(String[] args) {
        System.out.println(a); // 输出: 2
        System.out.println(b); // 输出: 4
    }
}

// 编译器生成的 <clinit>() 方法(伪代码):
// void <clinit>() {
//     a = 1;        // 第一个赋值
//     a = 2;        // 静态块中的赋值
//     b = 3;        // 静态块中的赋值
//     b = 4;        // 最后的赋值
// }

public class IllegalForwardRef {
    static {
        // i = 1;  // 合法:可以赋值
        // System.out.println(i);  // 非法:不能访问
        // 编译错误:Illegal forward reference
    }
    static int i;
}

public class Parent {
    public static int A = 1;
    static {
        A = 2;
    }
}

public class Child extends Parent {
    public static int B = A;
}

public class Test {
    public static void main(String[] args) {
        System.out.println(Child.B); // 输出: 2
    }
}

// 利用 <clinit>() 实现线程安全的单例
public class Singleton {
    // 方式1: 静态常量(简单)
    private static final Singleton INSTANCE = new Singleton();
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

// 或方式2: 静态内部类(延迟加载)
public class Singleton {
    private Singleton() {}
    
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

线程1 调用 getInstance():
  ↓
访问 Holder.INSTANCE
  ↓
触发 Holder 类的初始化
  ↓
JVM 加锁执行 Holder 的 <clinit>()
  ↓
创建 Singleton 实例
  ↓
其他线程访问时,Holder 已初始化,直接返回实例

public class InitDemo {
    public static void main(String[] args) {
        new MyClass();           // new 指令
        int value = MyClass.a;   // getstatic 指令
        MyClass.a = 2;           // putstatic 指令
        MyClass.method();        // invokestatic 指令
    }
}

class MyClass {
    static int a = 1;
    static {
        System.out.println("MyClass 初始化");
    }
    public static void method() {}
}

// Class.forName() 会触发初始化
Class<?> clazz = Class.forName("com.example.MyClass");

// ClassLoader.loadClass() 不会触发初始化
ClassLoader loader = ClassLoader.getSystemClassLoader();
Class<?> clazz2 = loader.loadClass("com.example.MyClass");
// 此时不会触发初始化,只有真正使用时才会初始化

// 示例1: 通过子类引用父类的静态字段,不会导致子类初始化
public class PassiveReference1 {
    public static void main(String[] args) {
        System.out.println(ChildClass.value);
        // 输出:
        // ParentClass 初始化
        // 123
        // 注意:ChildClass 不会初始化
    }
}

class ParentClass {
    static int value = 123;
    static {
        System.out.println("ParentClass 初始化");
    }
}

class ChildClass extends ParentClass {
    static {
        System.out.println("ChildClass 初始化");
    }
}

// 示例2: 通过数组定义引用类,不会触发此类的初始化
ParentClass[] array = new ParentClass[10];
// 不会初始化 ParentClass

// 示例3: 常量在编译阶段会存入调用类的常量池
public class PassiveReference3 {
    public static void main(String[] args) {
        System.out.println(ConstClass.HELLO);
        // 输出: Hello World
        // 不会输出 "ConstClass 初始化"
    }
}

class ConstClass {
    static final String HELLO = "Hello World";
    static {
        System.out.println("ConstClass 初始化");
    }
}

public class ClassUniquenessDemo {
    public static void main(String[] args) throws Exception {
        // 同一个 Class 文件,不同的类加载器
        CustomClassLoader loader1 = new CustomClassLoader("/tmp/classes");
        CustomClassLoader loader2 = new CustomClassLoader("/tmp/classes");
        
        Class<?> class1 = loader1.loadClass("com.example.Test");
        Class<?> class2 = loader2.loadClass("com.example.Test");
        
        System.out.println(class1 == class2);  // false
        
        // 即使类名相同,但加载器不同,它们就是不同的类
        System.out.println(class1.getClassLoader());  // CustomClassLoader@xxx1
        System.out.println(class2.getClassLoader());  // CustomClassLoader@xxx2
    }
}

Bootstrap ClassLoader (启动类加载器)
        ↑ parent
    Extension/Platform ClassLoader (扩展/平台类加载器)
        ↑ parent
    Application ClassLoader (应用程序类加载器)
        ↑ parent
    Custom ClassLoader (自定义类加载器)

// 启动类加载器加载的类
String.class.getClassLoader();  // 返回 null

// 查看启动类加载器加载的类库路径
String bootClassPath = System.getProperty("sun.boot.class.path");
System.out.println("启动类加载器路径:");
for (String path : bootClassPath.split(";")) {
    System.out.println("  " + path);
}

// JDK 9+ 获取平台类加载器
ClassLoader platformLoader = ClassLoader.getPlatformClassLoader();
System.out.println("平台类加载器: " + platformLoader);

// 获取应用程序类加载器
ClassLoader appLoader = ClassLoader.getSystemClassLoader();
System.out.println("应用程序类加载器: " + appLoader);
// 输出: sun.misc.Launcher$AppClassLoader@18b4aac2

// 用户类由应用程序类加载器加载
System.out.println("当前类的加载器: " + 
    ClassUniquenessDemo.class.getClassLoader());
// 输出: sun.misc.Launcher$AppClassLoader@18b4aac2

import java.io.*;

public class CustomClassLoader extends ClassLoader {
    private String classPath;
    
    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] data = loadClassData(name);
            return defineClass(name, data, 0, data.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name, e);
        }
    }
    
    private byte[] loadClassData(String className) throws IOException {
        String fileName = classPath + File.separatorChar 
            + className.replace('.', File.separatorChar) + ".class";
        
        try (InputStream is = new FileInputStream(fileName);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            
            int bytesRead;
            byte[] buffer = new byte[4096];
            while ((bytesRead = is.read(buffer)) != -1) {
                baos.write(buffer, 0, bytesRead);
            }
            
            return baos.toByteArray();
        }
    }
}

public abstract class ClassLoader {
    
    // 加载类(双亲委派入口)
    public Class<?> loadClass(String name) throws ClassNotFoundException { }
    
    // 加载类(可控制是否解析)
    protected Class<?> loadClass(String name, boolean resolve) 
        throws ClassNotFoundException { }
    
    // 查找类(子类实现)
    protected Class<?> findClass(String name) throws ClassNotFoundException { }
    
    // 定义类(将字节码转为 Class 对象)
    protected final Class<?> defineClass(String name, byte[] b, int off, int len) { }
    
    // 解析类
    protected final void resolveClass(Class<?> c) { }
    
    // 查找已加载的类
    protected final Class<?> findLoadedClass(String name) { }
    
    // 获取系统类加载器
    public static ClassLoader getSystemClassLoader() { }
    
    // 获取父加载器
    public final ClassLoader getParent() { }
}

1. 收到类加载请求
2. 判断是否已加载过该类
   - 如果已加载,直接返回
   - 如果未加载,委托父加载器加载
3. 父加载器无法加载,子加载器尝试加载
4. 如果子加载器也无法加载,抛出 ClassNotFoundException

                    加载请求
                       ↓
┌──────────────────────────────────────────────┐
│         Application ClassLoader              │
│                                              │
│  1. 检查是否已加载 → 否                       │
│  2. 委托父加载器                              │
└──────────────────────────────────────────────┘
                       ↓
┌──────────────────────────────────────────────┐
│         Extension ClassLoader                │
│                                              │
│  1. 检查是否已加载 → 否                       │
│  2. 委托父加载器                              │
└──────────────────────────────────────────────┘
                       ↓
┌──────────────────────────────────────────────┐
│         Bootstrap ClassLoader                │
│                                              │
│  1. 检查是否已加载 → 否                       │
│  2. 尝试加载 → 成功/失败                      │
└──────────────────────────────────────────────┘
                       ↓
               成功: 返回 Class
               失败: 返回子加载器继续

protected Class<?> loadClass(String name, boolean resolve) {
    synchronized (getClassLoadingLock(name)) {
        // 1. 检查该类是否已经加载过
        Class<?> c = findLoadedClass(name);
        
        if (c == null) {
            try {
                if (parent != null) {
                    // 2. 有父加载器,委托给父加载器
                    c = parent.loadClass(name, false);
                } else {
                    // 3. 无父加载器,委托给启动类加载器
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 父类加载器无法完成加载请求
            }
            
            if (c == null) {
                // 4. 父加载器无法加载,调用自身的 findClass 方法
                c = findClass(name);
            }
        }
        
        if (resolve) {
            resolveClass(c);
        }
        
        return c;
    }
}

// 尝试定义 java.lang 包下的类
package java.lang;

public class Evil {
    static {
        System.out.println("恶意代码执行");
    }
}

// 结果: 编译成功,但运行时无法加载
// SecurityException: Prohibited package name: java.lang

public class AvoidDuplicateDemo {
    public static void main(String[] args) throws Exception {
        // 多次加载同一个类
        Class<?> clazz1 = ArrayList.class;
        Class<?> clazz2 = ArrayList.class;
        Class<?> clazz3 = ClassLoader.getSystemClassLoader().loadClass("java.util.ArrayList");
        
        System.out.println(clazz1 == clazz2);  // true
        System.out.println(clazz2 == clazz3);  // true
    }
}

public class CustomClassLoader extends ClassLoader {
    private String classPath;
    
    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }
    
    @Override
    protected Class<?> loadClass(String name, boolean resolve) 
            throws ClassNotFoundException {
        // 1. 检查是否已加载
        Class<?> c = findLoadedClass(name);
        
        if (c == null) {
            // 2. 核心类还是委托给父加载器
            if (name.startsWith("java.")) {
                c = super.loadClass(name, resolve);
            } else {
                // 3. 非核心类自己加载
                c = findClass(name);
            }
        }
        
        if (resolve) {
            resolveClass(c);
        }
        
        return c;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] data = loadClassData(name);
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            throw new ClassNotFoundException(name);
        }
    }
    
    private byte[] loadClassData(String className) throws IOException {
        String fileName = classPath + File.separatorChar 
            + className.replace('.', File.separatorChar) + ".class";
        
        try (InputStream is = new FileInputStream(fileName);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            
            int bytesRead;
            byte[] buffer = new byte[4096];
            while ((bytesRead = is.read(buffer)) != -1) {
                baos.write(buffer, 0, bytesRead);
            }
            
            return baos.toByteArray();
        }
    }
}

// JDK 中 DriverManager 的实现
public class DriverManager {
    static {
        // 使用线程上下文类加载器加载驱动
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                // 关键:使用线程上下文类加载器
                ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
                Iterator<Driver> driversIterator = loadedDrivers.iterator();
                try {
                    while (driversIterator.hasNext()) {
                        driversIterator.next();
                    }
                } catch (Throwable t) {
                    // Do nothing
                }
                return null;
            }
        });
    }
}

// ServiceLoader 使用线程上下文类加载器
public static <S> ServiceLoader<S> load(Class<S> service) {
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    return ServiceLoader.load(service, cl);
}

┌─────────────────────────────────────────────────┐
│ DriverManager (Bootstrap ClassLoader 加载)     │
│                                                 │
│   static {                                      │
│     ServiceLoader.load(Driver.class)           │
│   }                                             │
│         ↓                                       │
│   Thread.currentThread().getContextClassLoader()│
│         ↓                                       │
│   Application ClassLoader                       │
│         ↓                                       │
│   加载 META-INF/services/java.sql.Driver       │
│         ↓                                       │
│   加载 com.mysql.cj.jdbc.Driver                │
│                                                 │
└─────────────────────────────────────────────────┘

// 1. 定义服务接口
package com.example.spi;

public interface DataService {
    void execute();
}

// 2. 实现服务接口
package com.example.spi.impl;

public class DataServiceImpl implements DataService {
    @Override
    public void execute() {
        System.out.println("DataServiceImpl execute");
    }
}

// 3. 配置 SPI
// 在 META-INF/services/com.example.spi.DataService 文件中:
// com.example.spi.impl.DataServiceImpl

// 4. 使用 ServiceLoader 加载服务
public class SpiDemo {
    public static void main(String[] args) {
        ServiceLoader<DataService> services = ServiceLoader.load(DataService.class);
        
        for (DataService service : services) {
            System.out.println("实现类: " + service.getClass().getName());
            service.execute();
        }
    }
}

        Bootstrap ClassLoader
                ↑
        Extension ClassLoader
                ↑
        Application ClassLoader
                ↑
        Common ClassLoader (加载 Tomcat 和 WebApp 共享的类)
         ↙          ↘
Catalina ClassLoader   Shared ClassLoader
(加载 Tomcat 内部类)    (加载 WebApp 共享的类)
                              ↑
                        WebApp ClassLoader
                        (每个 WebApp 独立的类加载器)
                              ↑
                        JspClassLoader
                        (每个 JSP 文件的类加载器)

1. Cache 缓存
2. JVM Bootstrap 类(防止覆盖核心类)
3. Web 应用类路径(/WEB-INF/classes)
4. Web 应用类库(/WEB-INF/lib/*.jar)
5. Common 类加载器
6. Shared 类加载器

双亲委派:  子 → 父 → 爷爷 (向上委托)
Tomcat:   自己 → 本地 → 父 (先自己加载)

Bundle A ClassLoader ←→ Bundle B ClassLoader ←→ Bundle C ClassLoader
        ↓                      ↓                       ↓
    Bundle A                 Bundle B               Bundle C
    (v1.0)                   (v2.0)                 (v3.0)

每个 Bundle 可以定义自己的导入导出策略,形成网状的类加载结构。

import java.io.*;

public class EncryptedClassLoader extends ClassLoader {
    private String rootDir;
    private static final int KEY = 0xFF;
    
    public EncryptedClassLoader(String rootDir) {
        this.rootDir = rootDir;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        }
        return defineClass(name, classData, 0, classData.length);
    }
    
    private byte[] loadClassData(String className) {
        String fileName = rootDir + File.separatorChar 
            + className.replace('.', File.separatorChar) + ".class";
        
        try (InputStream is = new FileInputStream(fileName);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            
            int bytesRead;
            byte[] buffer = new byte[4096];
            while ((bytesRead = is.read(buffer)) != -1) {
                // 解密
                for (int i = 0; i < bytesRead; i++) {
                    buffer[i] = (byte) (buffer[i] ^ KEY);
                }
                baos.write(buffer, 0, bytesRead);
            }
            
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    // 加密工具方法
    public static void encryptClass(String inputFile, String outputFile) 
            throws IOException {
        try (FileInputStream fis = new FileInputStream(inputFile);
             FileOutputStream fos = new FileOutputStream(outputFile)) {
            
            int bytesRead;
            byte[] buffer = new byte[4096];
            while ((bytesRead = fis.read(buffer)) != -1) {
                // 加密
                for (int i = 0; i < bytesRead; i++) {
                    buffer[i] = (byte) (buffer[i] ^ KEY);
                }
                fos.write(buffer, 0, bytesRead);
            }
        }
    }
}

import java.io.*;
import java.util.*;

public class HotDeployClassLoader extends ClassLoader {
    private String classDir;
    private Map<String, Long> classLoadTime = new HashMap<>();
    
    public HotDeployClassLoader(String classDir) {
        this.classDir = classDir;
    }
    
    @Override
    protected Class<?> loadClass(String name, boolean resolve) 
            throws ClassNotFoundException {
        // 核心类走双亲委派
        if (name.startsWith("java.") || name.startsWith("javax.")) {
            return super.loadClass(name, resolve);
        }
        
        // 检查是否需要重新加载
        File classFile = getClassFile(name);
        if (classFile != null && needReload(name, classFile)) {
            // 重新加载
            byte[] data = loadClassData(classFile);
            Class<?> clazz = defineClass(name, data, 0, data.length);
            classLoadTime.put(name, classFile.lastModified());
            
            if (resolve) {
                resolveClass(clazz);
            }
            
            return clazz;
        }
        
        return super.loadClass(name, resolve);
    }
    
    private boolean needReload(String name, File classFile) {
        Long lastLoadTime = classLoadTime.get(name);
        return lastLoadTime == null 
            || classFile.lastModified() > lastLoadTime;
    }
    
    private File getClassFile(String name) {
        String fileName = classDir + File.separatorChar 
            + name.replace('.', File.separatorChar) + ".class";
        File file = new File(fileName);
        return file.exists() ? file : null;
    }
    
    private byte[] loadClassData(File file) throws IOException {
        try (InputStream is = new FileInputStream(file);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            
            int bytesRead;
            byte[] buffer = new byte[4096];
            while ((bytesRead = is.read(buffer)) != -1) {
                baos.write(buffer, 0, bytesRead);
            }
            
            return baos.toByteArray();
        }
    }
}

## 检查类路径
java -verbose:class -jar app.jar

## 查看类加载情况
-XX:+TraceClassLoading
-XX:+TraceClassUnloading

## 使用 jcmd 查看类加载统计
jcmd <pid> VM.classloader_stats

// 查看类由哪个加载器加载
public class ClassLoaderUtil {
    public static void printClassLoader(Class<?> clazz) {
        ClassLoader loader = clazz.getClassLoader();
        if (loader == null) {
            System.out.println(clazz.getName() + " 由 Bootstrap ClassLoader 加载");
        } else {
            System.out.println(clazz.getName() + " 由 " + loader + " 加载");
        }
    }
    
    public static void printClassLoaderHierarchy(Class<?> clazz) {
        ClassLoader loader = clazz.getClassLoader();
        System.out.println("类加载器层次:");
        while (loader != null) {
            System.out.println("  " + loader);
            loader = loader.getParent();
        }
        System.out.println("  Bootstrap ClassLoader");
    }
}

## 1. 找到类所在的位置
find . -name "*.jar" -exec jar -tf {} \; | grep "TargetClass.class"

## 2. 查看类加载信息
java -verbose:class -jar app.jar 2>&1 | grep "TargetClass"

## 3. 使用 arthas 查看类信息
sc -d com.example.TargetClass

`code-snippet 1：
     public class A {
         static int a ;
         public static void main(String[] args) {
             System.out.println(a);
         }
     }
 code-snippet 2：
 public class A {
     public static void main(String[] args) {
         int a ;
         System.out.println(a);
     }
 }
`

`public class A {
     static int a = 0 ;
     static {
         a = 1;
         b = 1;
     }
     static int b = 0;

     public static void main(String[] args) {
         System.out.println(a);
         System.out.println(b);
     }
 }
`

`static {
         b = b + 1;
 }
 static int b = 0;
`

`public class A {
     static {
         System.out.println("1");
     }
     public A(){
         System.out.println("2");
         }
     }

public class B extends A {
         static{
         System.out.println("a");
     }
     public B(){
         System.out.println("b");
     }

     public static void main(String[] args){
         A ab = new B();
         ab = new B();
     }
 }
`

`1
a
2
b
2
b
`

`Class.forName("com.mysql.jdbc.Driver")
`

`mysql-connector-java-8.0.15.jar!/META-INF/services/java.sql.Driver
`

`com.mysql.cj.jdbc.Driver
`

`//part1:DriverManager::loadInitialDrivers
  //jdk1.8 之后，变成了lazy的ensureDriversInitialized
  ...
  ServiceLoader <Driver> loadedDrivers = ServiceLoader.load(Driver.class);
  Iterator<Driver> driversIterator = loadedDrivers.iterator();
  ...

  //part2:ServiceLoader::load
  public static <T> ServiceLoader<T> load(Class<T> service) {
      ClassLoader cl = Thread.currentThread().getContextClassLoader();
      return ServiceLoader.load(service, cl);
  }
`

`public Launcher() {
 Launcher.ExtClassLoader var1;
 try {
     var1 = Launcher.ExtClassLoader.getExtClassLoader();
 } catch (IOException var10) {
     throw new InternalError("Could not create extension class loader", var10);
 }

 try {
     this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
 } catch (IOException var9) {
     throw new InternalError("Could not create application class loader", var9);
 }
 Thread.currentThread().setContextClassLoader(this.loader);
 ...
 }
`

# 将补丁 jar 打入 java.base 模块，可替换/增强核心类（须保留签名与包结构）
java --patch-module java.base=/path/to/patch.jar -jar app.jar