结论先行:双亲委派的本质是「加载请求逐层上交,父加载器搞不定才自己来」,目的是保证核心类库的唯一和安全。但有三类场景天生需要破坏它:容器隔离(Tomcat)、核心库反向加载实现类(SPI)、热部署。理解「为什么必须破坏」,比背加载器层次有用得多。

加载一个类到底做了什么

类生命周期是加载 → 验证 → 准备 → 解析 → 初始化。两个常考点:准备阶段给静态变量赋的是零值(static int a = 1 此时 a 等于 0),真正赋 1 发生在初始化阶段;初始化由首次「主动使用」触发(new、读写静态字段、反射调用等),所以类是懒加载的。这里有一个衍生结论值得记住:类的初始化是线程安全的,JVM 保证 <clinit> 只执行一次——静态内部类单例写法不需要加锁,靠的正是类初始化锁。另一个衍生点是类没有显式「卸载」API,回收的唯一途径是回收它的加载器,这个限制决定了热部署的实现方式。

加载过程的产物可以自己验证:Class.forName("X") 会触发初始化,ClassLoader.loadClass("X") 只加载不初始化——JDBC 驱动历史上要求 forName 正是为了执行驱动类静态块里的注册逻辑,现代容器走 SPI 机制后这个显式调用就不再必要。两个 API 的差别是高频面试点,也是排查「静态块没执行」类问题的钥匙。

双亲委派:三层结构

三层加载器各管一段:Bootstrap 加载核心类(Object、String),Platform(JDK 9 前的 Ext)加载扩展类,Application 加载 classpath。工作方式在 ClassLoader.loadClass 里:

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        Class<?> c = findLoadedClass(name);      // 1. 已经加载过?
        if (c == null) {
            try {
                if (parent != null) {
                    c = parent.loadClass(name);  // 2. 先委托父加载器
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // 父加载器管辖范围内没有这个类
            }
            if (c == null) {
                c = findClass(name);             // 3. 父加载器管不了,自己找
            }
        }
        return c;
    }
}

两个收益:同一个类只会被加载一次(类的唯一性由「加载器 + 类名」共同保证);你写一个 java.lang.String 也无法欺骗 JVM,因为请求会先到 Bootstrap,核心类早就加载过了。注意唯一性的准确表述:同一个类文件被两个不同的加载器加载,得到的是两个互不相干的 Class 对象,instanceof 不成立、互相赋值抛 ClassCastException——「加载器也是类型的一部分」这句话,是后面所有破坏场景与线上诡异问题的钥匙。

层次关系可以自己验证:String.class.getClassLoader() 返回 null(Bootstrap 由虚拟机自身实现,Java 层不可见);ClassLoader.getSystemClassLoader() 拿到 Application 加载器;自定义加载器不传 parent 时默认父级就是它。把这几个值打印一遍,三层结构就不再抽象。

为什么要破坏它

场景一:SPI。 JDBC 的接口 DriverManager 由 Bootstrap 加载,实现类 mysql-connector 在 classpath 由 Application 加载,但 Bootstrap 根据委派模型看不见下层的类。解法是线程上下文类加载器:核心库通过 Thread.currentThread().getContextClassLoader() 拿到 Application 加载器去加载厂商实现,相当于开了一条「逆向通道」:

// JDBC 驱动加载的逆向通道(简化示意)
ClassLoader tccl = Thread.currentThread().getContextClassLoader();
Class<?> driverClass =
        Class.forName("com.mysql.cj.jdbc.Driver", true, tccl);

场景二:容器隔离。 Tomcat 需要两个 Web 应用各自使用不同版本的同一个类,双亲委派的「全局唯一」反而成了障碍。WebappClassLoader 的做法是反过来:先在自己管辖范围内找,找不到才委托父加载器,实现应用之间的类隔离。

场景三:热部署。 类一旦加载无法单独卸载(除非回收整个 ClassLoader),热替换的唯一途径是 new 一个新的 ClassLoader 重新加载改过的类,再用新 Class 生成新对象替换旧的。OSGi、脚本引擎热更新都是这个路数。

三类场景加上模块化,破坏方式集中对照:

场景必须破坏的原因破坏手段代表实现
SPI/JDBC核心接口要加载下层实现类线程上下文类加载器逆向加载DriverManager
Web 容器隔离每应用独立的类空间先自己找、再委托父级Tomcat WebappClassLoader
热部署类卸载以加载器为单位新建加载器重新加载脚本引擎、OSGi
模块化委派按模块而非层次模块间导入导出关系OSGi / JPMS

还有一个被忽略的历史细节:双亲委派在 JDK 1.2 才引入,更早的年代用户直接重写 loadClass 是常态,所以「破坏」从来不是禁忌,而是与历史兼容的设计延续。理解这一点,就不会把双亲委派当成不可触碰的铁律,而是「默认安全、按需破坏」的工程约定。

自定义加载器的正确姿势

实现自定义加载器时重写 findClass 而不是 loadClass——保留双亲委派骨架,只改变「自己怎么找字节码」这一步;除非你在写容器或热部署框架,否则不要轻易重写 loadClass 推翻委派逻辑:

// 错误写法:重写 loadClass 推翻委派,核心类唯一性被破坏
public class BadLoader extends ClassLoader {
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        return findClass(name);   // 自己先找:同名的 java.lang.String 会被
                                  // 再加载一份,与 Bootstrap 那份互不兼容
    }
}

// 正确写法:只重写 findClass,委派骨架原样保留
public class ReloadableLoader extends ClassLoader {
    private final String pluginDir;

    ReloadableLoader(String pluginDir, ClassLoader parent) {
        super(parent);            // 委派给父加载器的能力不变
        this.pluginDir = pluginDir;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] bytes = readPluginClass(name);   // 只自定义「字节码从哪来」
        if (bytes == null) {
            throw new ClassNotFoundException(name);
        }
        return defineClass(name, bytes, 0, bytes.length);
    }
}

类加载引发的经典线上问题

三类高频问题值得排在排查手册里。一是依赖冲突:classpath 里同一个类出现两个版本(不同 jar 的传递依赖),加载到哪个版本取决于 classpath 顺序与加载器策略,报错形态多为 NoSuchMethodError、NoClassDefFoundError。二是重复类导致类型不兼容:自定义加载器或容器隔离场景下同一个类加载两份,instanceof 失败、强转抛 ClassCastException,报错信息里两个类名一模一样,极具迷惑性。三是初始化异常掩盖:<clinit> 抛出后类被标记为初始化失败,后续使用统一抛 NoClassDefFoundError,真实根因在第一次异常里,要看日志最早的那条。排查工具:-verbose:class 或 arthas 的 sc/jad/sm 命令能直接回答「这个类是谁加载的、字节码从哪来」。

Web 容器里还有一类专属问题:应用把第三方 jar 放进 Tomcat 的 lib 目录(容器共享层),另一个应用想用不同版本就被迫冲突——正确位置是各应用的 WEB-INF/lib。共享层只放真正全局且版本收敛的库,这条纪律能避免大部分容器类冲突。

把这些问题串起来记:类冲突的三种形态——版本冲突(加载错版本)、重复类(同一类加载两份)、初始化失败(首异常被掩盖)——对应三种排查入口:依赖树、加载器身份、最早的异常日志。三个入口都记熟,类加载类问题的排查就不再靠猜。

生产案例

某服务升级依赖版本后间歇性抛 NoSuchMethodError,涉及一个工具类的某个重载方法。排查发现新旧两个版本的 jar 同时在 classpath 里:新 jar 是直接依赖,旧 jar 是另一个内部组件的传递依赖,依赖仲裁把旧版本留了下来,运行时加载到旧版本类,而编译时用的是新签名。之后团队把三条防线固化下来:CI 里接入 maven-enforcer-plugin 的重复类检测;升级依赖后强制核对依赖树,确认关键组件版本唯一;线上备好 -verbose:class 的排查套路,第一时间确认「加载到的类来自哪个 jar」。这个案例的教训是:双亲委派保证的是「一个加载器内类不重复」,不保证「classpath 里没有重复类」——后者是构建问题,要在构建期拦截,运行期发现就已经是线上故障了。