第9章类加载及执行子系统的案例与实战 - 面试题总结

一、Tomcat类加载器架构

1. Tomcat为什么要打破双亲委派模型？

问题描述：Tomcat的类加载器架构为什么要打破双亲委派模型？

答案要点：

打破双亲委派的原因：

Web应用类库隔离需求
- 不同的Web应用可能使用不同版本的Spring、Hibernate等框架
- 如果遵循双亲委派，所有Web应用将共享同一个版本的类库
- 可能导致版本冲突
优先加载Web应用本地类库
- WebApp类加载器优先在本地（WEB-INF/classes和WEB-INF/lib）查找类
- 确保Web应用使用自己指定的类库版本
- 本地找不到才委托给父类加载器
JSP热替换支持
- 每个JSP文件有自己的类加载器
- JSP修改后，创建新的类加载器重新加载
- 实现JSP的热部署

Tomcat类加载器结构：

Bootstrap ClassLoader
      ↑
Extension ClassLoader
      ↑
System ClassLoader
      ↑
  Common ClassLoader
   /      \
Catalina  Shared
ClassLoader ClassLoader
              ↑
         WebApp ClassLoader (打破双亲委派)
              ↑
         JSP ClassLoader

2. Tomcat中WebApp类加载器的加载顺序是怎样的？

问题描述：请描述Tomcat中WebApp类加载器的类加载顺序。

答案要点：

WebApp类加载器的加载顺序（打破双亲委派）：

在本地缓存中查找 - findLoadedClass(name)
在Web应用本地加载 - findClass(name)
- 查找WEB-INF/classes目录
- 查找WEB-INF/lib目录下的JAR文件
委托给父类加载器 - super.loadClass(name)

代码示意：

java

public Class<?> loadClass(String name) throws ClassNotFoundException {
    // 1. 先在本地缓存中查找
    Class<?> clazz = findLoadedClass(name);
    if (clazz != null) return clazz;
    
    // 2. 先尝试在Web应用本地加载（打破双亲委派）
    clazz = findClass(name);
    if (clazz != null) return clazz;
    
    // 3. 本地找不到，再委托给父类加载器
    return super.loadClass(name);
}

与双亲委派的区别：

双亲委派：先委托父类加载器，父类加载器找不到再自己加载
Tomcat WebApp：先自己加载，自己加载不到再委托父类加载器

3. Tomcat如何实现多个Web应用的类库隔离？

问题描述：Tomcat如何实现多个Web应用之间的类库隔离？

答案要点：

隔离机制：

独立的WebApp类加载器
- 每个Web应用有独立的WebApp类加载器实例
- 不同Web应用的类加载器相互独立
- 加载的类在不同命名空间中
类加载器层级
- Bootstrap/Extension/System类加载器：加载JVM和系统类（共享）
- Common类加载器：加载Tomcat共享类库（共享）
- WebApp类加载器：加载Web应用私有类库（隔离）
隔离级别

隔离级别	类加载器	共享范围
JVM级别	Bootstrap/Extension/System	所有Web应用共享
Tomcat级别	Common/Shared	所有Web应用共享
Web应用级别	WebApp	仅当前Web应用
JSP级别	JSP ClassLoader	仅当前JSP

4. 什么是类加载器泄露？Tomcat中如何避免？

问题描述：什么是类加载器泄露？Tomcat中如何避免？

答案要点：

类加载器泄露定义：

Web应用停止后，其类加载器仍然被引用，无法被垃圾回收
导致类加载器加载的所有类也无法被回收
多次部署/卸载后，内存持续增长，最终OutOfMemoryError

泄露原因：

静态集合引用：类中定义的静态集合持有对象引用
线程未停止：Web应用启动的线程未正确停止
驱动未注销：JDBC驱动等未正确注销
外部缓存：外部缓存（如Ehcache）持有类引用

Tomcat避免措施：

检查类加载器引用：使用工具检查是否有外部引用
规范资源释放：
- 在ServletContextListener中正确关闭线程池
- 注销JDBC驱动
- 清空静态集合
使用弱引用：对于缓存等使用弱引用
定期重启：作为最后手段

二、OSGi类加载器架构

1. OSGi是什么？它解决了什么问题？

问题描述：请解释OSGi是什么，以及它解决了什么问题。

答案要点：

OSGi定义：

OSGi（Open Service Gateway Initiative）是面向Java的动态模块化系统规范
定义了模块化、生命周期管理、服务注册和发现的完整框架

OSGi的核心概念：

概念	说明
Bundle	OSGi的基本模块单元，是一个包含元数据信息的JAR文件
Module Layer	模块层，定义Bundle的元数据和依赖关系
Lifecycle Layer	生命周期层，管理Bundle的安装、启动、停止、更新、卸载
Service Layer	服务层，提供Bundle间的动态服务注册和发现机制

解决的问题：

模块依赖管理
- 明确声明导入和导出的包
- 版本化管理依赖
多版本共存
- 同一个类的不同版本可以在不同Bundle中共存
- 解决"Jar Hell"问题
动态性
- Bundle可以动态安装、启动、停止、更新、卸载
- 无需重启整个应用
服务动态性
- 服务可以动态注册和注销
- 支持服务的动态发现

2. OSGi类加载器与双亲委派模型有什么区别？

问题描述：请比较OSGi类加载器与双亲委派模型的区别。

答案要点：

主要区别：

特性	双亲委派模型	OSGi类加载器
加载顺序	自底向上委托，自顶向下加载	复杂的网状结构，按需加载
版本管理	不支持多版本共存	支持多版本共存
动态性	静态的类路径	支持Bundle动态安装、更新、卸载
隔离性	父子加载器隔离	Bundle间精确控制可见性
复杂度	简单	复杂

OSGi类加载器特点：

网状结构
- 每个Bundle有自己的类加载器
- 类加载器之间形成网状依赖关系

模块化的类加载

Bundle-SymbolicName: com.example.bundleA
Export-Package: com.example.service;version="1.0.0"
Import-Package: com.example.util;version="[1.0,2.0)"

复杂的加载规则
1. Boot委托（java.*包）
2. 父类委托（执行环境）
3. 本地加载
4. 导入包加载
5. 动态导入
6. 片段加载
7. 父类加载器

3. OSGi如何实现同一个类的多版本共存？

问题描述：OSGi如何实现同一个类的多版本共存？

答案要点：

实现原理：

独立的类加载器
- 每个Bundle有自己的类加载器
- 类加载器加载的类在各自的命名空间中

版本声明

Bundle A:
Import-Package: org.example.util;version="1.0"

Bundle B:
Import-Package: org.example.util;version="2.0"

运行时解析
- OSGi框架根据Import-Package声明解析依赖
- 为每个Bundle绑定对应版本的Export-Package

示例：

Bundle A ClassLoader
    ↓ 导入 org.example.util 版本 1.0
Bundle B ClassLoader ← 导出 org.example.util 版本 1.0

Bundle C ClassLoader
    ↓ 导入 org.example.util 版本 2.0
Bundle D ClassLoader ← 导出 org.example.util 版本 2.0

关键点：

不同Bundle可以加载同一个类的不同版本
类在各自的类加载器命名空间中
不会相互干扰

4. OSGi的服务层是如何工作的？

问题描述：请解释OSGi服务层的工作原理。

答案要点：

服务层核心概念：

概念	说明
服务（Service）	一个Java对象，实现了一个或多个接口
服务注册（Register）	Bundle将服务注册到服务注册表
服务查找（Lookup）	Bundle从服务注册表查找服务
服务监听（Listener）	监听服务的注册、修改、注销事件

工作流程：

服务注册

java

// Bundle A注册服务
ServiceRegistration registration = 
    bundleContext.registerService(MyService.class.getName(), 
                                  new MyServiceImpl(), 
                                  properties);

服务查找

java

// Bundle B查找服务
ServiceReference reference = 
    bundleContext.getServiceReference(MyService.class.getName());
MyService service = (MyService) bundleContext.getService(reference);

服务监听

java

// 监听服务变化
bundleContext.addServiceListener(new ServiceListener() {
    public void serviceChanged(ServiceEvent event) {
        if (event.getType() == ServiceEvent.REGISTERED) {
            // 服务注册
        } else if (event.getType() == ServiceEvent.UNREGISTERING) {
            // 服务注销
        }
    }
});

服务动态性：

服务可以随时注册和注销
支持服务的动态发现和绑定
实现服务的松耦合

三、字节码生成与动态代理

1. JDK动态代理和CGLIB动态代理有什么区别？

问题描述：请比较JDK动态代理和CGLIB动态代理的区别。

答案要点：

对比总结：

特性	JDK动态代理	CGLIB动态代理
实现方式	基于接口	基于继承
代理对象	实现目标接口	继承目标类
目标类要求	必须实现接口	不需要实现接口
final限制	无限制	不能代理final类和方法
性能	反射调用，较慢	使用MethodProxy，较快
依赖	JDK内置	需要CGLIB库
生成类名	`$Proxy` + 数字	`$$EnhancerByCGLIB$$` + 哈希

JDK动态代理示例：

java

// 必须实现接口
public interface HelloService {
    void sayHello();
}

// 代理生成
HelloService proxy = (HelloService) Proxy.newProxyInstance(
    HelloService.class.getClassLoader(),
    new Class<?>[] { HelloService.class },
    new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 增强逻辑
            return method.invoke(target, args);
        }
    }
);

CGLIB动态代理示例：

java

// 不需要实现接口
public class HelloService {
    public void sayHello() {
        System.out.println("Hello");
    }
}

// 代理生成
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloService.class);
enhancer.setCallback(new MethodInterceptor() {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 增强逻辑
        return proxy.invokeSuper(obj, args);
    }
});
HelloService proxy = (HelloService) enhancer.create();

2. 动态代理的实现原理是什么？

问题描述：请解释动态代理的实现原理。

答案要点：

JDK动态代理原理：

生成代理类字节码
- 在运行时动态生成代理类的字节码
- 代理类继承java.lang.reflect.Proxy
- 实现目标接口

代理类结构

java

public final class $Proxy0 extends Proxy implements HelloService {
    private static Method m1; // sayHello方法
    private InvocationHandler h; // 拦截器
    
    @Override
    public void sayHello() {
        h.invoke(this, m1, null);
    }
}

调用流程

调用proxy.sayHello()
  ↓
调用InvocationHandler.invoke()
  ↓
执行增强逻辑
  ↓
调用目标对象方法

CGLIB动态代理原理：

生成代理类字节码
- 使用ASM库生成代理类的字节码
- 代理类继承目标类

代理类结构

java

public class HelloService$$EnhancerByCGLIB$$xxx extends HelloService {
    private MethodInterceptor callback;
    private static final MethodProxy CGLIB$sayHello$0;
    
    @Override
    public void sayHello() {
        callback.intercept(this, sayHelloMethod, null, CGLIB$sayHello$0);
    }
    
    final void CGLIB$sayHello$0() {
        super.sayHello();
    }
}

MethodProxy优化
- 使用索引而不是反射调用方法
- 首次调用后生成FastClass
- 后续调用直接通过索引调用，性能更高

3. 常见的字节码生成技术有哪些？

问题描述：请列举常见的字节码生成技术，并比较它们的优缺点。

答案要点：

常见字节码生成技术：

技术	特点	适用场景
javac	Java编译器，将源码编译为字节码	正常编译
ASM	直接操作字节码，性能高，学习曲线陡峭	框架开发、高性能场景
Javassist	提供源码级别的API，易于使用	快速开发、简单字节码操作
CGLIB	基于ASM，专注于生成代理类	动态代理
Byte Buddy	声明式字节码生成，API友好	现代框架、简洁代码

详细对比：

ASM：

优点：性能最高，直接操作字节码
缺点：学习曲线陡峭，代码复杂
示例：需要手动计算栈帧和局部变量表

Javassist：

优点：可以使用Java源代码字符串，易于使用
缺点：性能略低于ASM

示例：

java

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("Hello");
cc.addMethod(CtNewMethod.make("public void say() {}", cc));

Byte Buddy：

优点：声明式API，代码简洁，现代设计
缺点：需要额外依赖

示例：

java

Class<?> dynamicType = new ByteBuddy()
    .subclass(Object.class)
    .method(named("toString"))
    .intercept(FixedValue.value("Hello"))
    .make()
    .load(getClass().getClassLoader())
    .getLoaded();

4. Spring AOP使用哪种动态代理？如何选择？

问题描述：Spring AOP使用哪种动态代理？如何选择使用哪种代理？

答案要点：

Spring AOP的代理选择：

条件	代理类型
目标类实现了接口	JDK动态代理
目标类没有实现接口	CGLIB代理
强制使用CGLIB（proxyTargetClass=true）	CGLIB代理

配置方式：

XML配置

xml

<aop:config proxy-target-class="true">
    <!-- 强制使用CGLIB -->
</aop:config>

注解配置

java

@EnableAspectJAutoProxy(proxyTargetClass = true)

Spring Boot配置
properties
```
spring.aop.proxy-target-class=true
```

选择建议：

默认行为：优先使用JDK动态代理（基于接口）
强制CGLIB：当需要代理类而不是接口时
注意事项：
- CGLIB不能代理final类和方法
- CGLIB创建的代理对象是目标类的子类

Spring Boot 2.x+的变化：

默认使用CGLIB代理
原因：避免代理类型转换问题
可以通过配置改回JDK动态代理

四、动态编译与热部署

1. JavaCompiler API是什么？如何使用？

问题描述：请解释JavaCompiler API，并说明如何使用它进行动态编译。

答案要点：

JavaCompiler API：

JDK 6引入的标准API
位于javax.tools包下
可以在运行时编译Java源代码

核心类：

类/接口	作用
JavaCompiler	编译器接口，通过`ToolProvider.getSystemJavaCompiler()`获取
JavaFileObject	表示Java源文件或类文件
FileManager	管理源文件和类文件的输入输出
CompilationTask	编译任务，可以异步执行
DiagnosticCollector	收集编译过程中的诊断信息

使用示例：

java

// 1. 获取编译器
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

// 2. 创建文件管理器
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);

// 3. 准备源文件
Iterable<? extends JavaFileObject> compilationUnits = 
    fileManager.getJavaFileObjectsFromStrings(Arrays.asList("Hello.java"));

// 4. 创建编译任务
JavaCompiler.CompilationTask task = compiler.getTask(
    null,           // 输出Writer
    fileManager,    // 文件管理器
    null,           // 诊断监听器
    null,           // 编译选项
    null,           // 需要编译的类名
    compilationUnits // 编译单元
);

// 5. 执行编译
boolean success = task.call();

内存编译：

可以实现从字符串编译，不生成文件
需要自定义JavaFileObject和FileManager

2. 如何实现Java代码的热部署？

问题描述：请说明如何实现Java代码的热部署。

答案要点：

热部署实现方案：

方案一：自定义类加载器

创建新的类加载器

java

public class HotSwapClassLoader extends ClassLoader {
    public HotSwapClassLoader(ClassLoader parent) {
        super(parent);
    }
    
    public Class<?> loadClass(String name, byte[] bytecode) {
        return defineClass(name, bytecode, 0, bytecode.length);
    }
}

重新加载类

java

// 创建新的类加载器
HotSwapClassLoader newLoader = new HotSwapClassLoader(parent);

// 加载新的字节码
Class<?> newClass = newLoader.loadClass(className, newBytecode);

// 创建新实例
Object newInstance = newClass.getDeclaredConstructor().newInstance();

方案二：使用Instrumentation API

java

// 定义Transformer
public class HotSwapTransformer implements ClassFileTransformer {
    @Override
    public byte[] transform(ClassLoader loader, String className,
            Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
            byte[] classfileBuffer) {
        // 返回新的字节码
        return newBytecode;
    }
}

// 使用Instrumentation重新转换类
instrumentation.retransformClasses(targetClass);

方案三：使用JRebel等商业工具

热部署的限制：

不能修改类的结构（添加/删除方法、字段）
只能修改方法体
静态变量的重新初始化需要特殊处理

3. 什么是热替换类加载器？如何实现？

问题描述：请解释热替换类加载器的概念，并说明如何实现。

答案要点：

热替换类加载器定义：

可以在运行时重新加载类的类加载器
通过创建新的类加载器实例来加载修改后的类
实现类的热部署

实现要点：

打破双亲委派
- 优先从本地加载类
- 确保加载新的类版本
隔离性
- 每个实例加载独立的类
- 旧的类加载器和类可以被垃圾回收

实现代码：

java

public class HotSwapClassLoader extends ClassLoader {
    private final Map<String, byte[]> bytecodeMap = new ConcurrentHashMap<>();
    
    public HotSwapClassLoader(ClassLoader parent) {
        super(parent);
    }
    
    public void addClass(String className, byte[] bytecode) {
        bytecodeMap.put(className, bytecode);
    }
    
    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        // 1. 检查是否已加载
        Class<?> clazz = findLoadedClass(name);
        if (clazz != null) return clazz;
        
        // 2. 系统类委托给父类加载器
        if (name.startsWith("java.")) {
            return super.loadClass(name, resolve);
        }
        
        // 3. 从本地字节码加载（打破双亲委派）
        byte[] bytecode = bytecodeMap.get(name);
        if (bytecode != null) {
            return defineClass(name, bytecode, 0, bytecode.length);
        }
        
        // 4. 委托给父类加载器
        return super.loadClass(name, resolve);
    }
}

使用方式：

java

// 1. 编译新代码
byte[] bytecode = compiler.compile(className, sourceCode);

// 2. 创建新的类加载器
HotSwapClassLoader loader = new HotSwapClassLoader(parent);
loader.addClass(className, bytecode);

// 3. 加载新类
Class<?> newClass = loader.loadClass(className);

// 4. 创建实例
Object instance = newClass.getDeclaredConstructor().newInstance();

4. 动态编译有哪些应用场景？

问题描述：请列举动态编译的实际应用场景。

答案要点：

应用场景：

场景	说明
规则引擎	动态编译业务规则，无需重启应用
脚本支持	为应用提供Java脚本扩展能力
代码生成器	根据配置动态生成并编译代码
在线编程	在线代码编辑和运行平台
热修复	线上问题快速修复
测试平台	动态执行测试代码
数据处理	动态生成数据处理逻辑

具体示例：

规则引擎

java

// 业务人员编写的规则
String rule = "if (amount > 1000) { return amount * 0.9; }";

// 动态编译并执行
RuleEngine engine = new RuleEngine();
double result = engine.execute(rule, context);

在线编程平台
- 用户提交Java代码
- 服务器动态编译执行
- 返回执行结果
热修复
- 发现线上Bug
- 编写修复代码
- 动态编译替换
- 无需重启服务

五、综合面试题

1. 类加载器有哪些实际应用场景？

问题描述：请列举类加载器的实际应用场景。

答案要点：

应用场景：

场景	说明
Tomcat等Web容器	实现Web应用隔离和热部署
OSGi框架	模块化管理和动态更新
热部署/热替换	不重启应用更新代码
动态代理	生成代理类
字节码增强	AOP、监控、日志等
插件系统	动态加载插件
隔离运行环境	沙箱安全

详细说明：

Web容器类加载器
- Tomcat、Jetty等使用自定义类加载器
- 实现Web应用间隔离
- 支持JSP热替换
OSGi模块化
- Eclipse插件系统基于OSGi
- 实现插件的动态安装和更新
热部署工具
- JRebel、Spring Loaded等
- 使用自定义类加载器重新加载类
AOP框架
- Spring AOP、AspectJ
- 生成代理类或增强类
数据库驱动加载
- 动态加载不同版本的数据库驱动

2. 如何解决类加载器冲突问题？

问题描述：在实际项目中如何解决类加载器冲突问题？

答案要点：

冲突类型：

NoClassDefFoundError
- 类存在但无法加载
- 原因：类在父类加载器可见范围外
ClassNotFoundException
- 类根本不存在
- 原因：依赖缺失或类路径错误
LinkageError
- 类已加载但版本不匹配
- 原因：不同类加载器加载了同一类的不同版本

解决方案：

调整类加载顺序
- 将冲突的类库放到父类加载器加载的范围
- 如放到Tomcat的lib目录
使用自定义类加载器
- 为冲突的模块创建独立的类加载器
- 实现类库隔离
使用OSGi
- 精确控制类的导入和导出
- 支持多版本共存
Maven/Gradle依赖管理
- 使用 <dependencyManagement> 统一管理版本
- 排除冲突的传递依赖
类加载器分析工具
- 使用-verbose:class查看类加载过程
- 使用JVM工具分析类加载器层次

3. 请设计一个简单的插件系统。

问题描述：请设计一个简单的插件系统，说明其类加载器架构。

答案要点：

系统设计：

PluginManager
    ↓ 管理
PluginClassLoader (每个插件一个)
    ↓ 加载
Plugin Interface
    ↓ 实现
Plugin Implementation

核心组件：

插件接口

java

public interface Plugin {
    String getName();
    void init();
    void execute();
    void destroy();
}

插件类加载器

java

public class PluginClassLoader extends URLClassLoader {
    public PluginClassLoader(URL[] urls, ClassLoader parent) {
        super(urls, parent);
    }
    
    // 优先加载插件本地类
    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        // 插件核心接口委托给父类加载器
        if (name.startsWith("com.example.plugin.api")) {
            return super.loadClass(name, resolve);
        }
        
        // 其他类优先本地加载
        try {
            return findClass(name);
        } catch (ClassNotFoundException e) {
            return super.loadClass(name, resolve);
        }
    }
}

插件管理器

java

public class PluginManager {
    private final Map<String, Plugin> plugins = new HashMap<>();
    private final Map<String, PluginClassLoader> loaders = new HashMap<>();
    
    public void loadPlugin(String pluginId, String pluginPath) {
        // 创建类加载器
        URL[] urls = {new File(pluginPath).toURI().toURL()};
        PluginClassLoader loader = new PluginClassLoader(urls, this.getClass().getClassLoader());
        loaders.put(pluginId, loader);
        
        // 加载插件类
        ServiceLoader<Plugin> serviceLoader = ServiceLoader.load(Plugin.class, loader);
        for (Plugin plugin : serviceLoader) {
            plugins.put(pluginId, plugin);
            plugin.init();
        }
    }
    
    public void unloadPlugin(String pluginId) {
        Plugin plugin = plugins.remove(pluginId);
        if (plugin != null) {
            plugin.destroy();
        }
        
        PluginClassLoader loader = loaders.remove(pluginId);
        if (loader != null) {
            loader.close();
        }
    }
}

插件目录结构：

plugins/
├── plugin-a/
│   ├── plugin-a.jar
│   └── lib/
│       └── dependency.jar
├── plugin-b/
│   └── plugin-b.jar
└── ...

4. 动态代理在框架中有哪些应用？

问题描述：请列举动态代理在主流框架中的应用。

答案要点：

框架应用：

框架	应用场景	代理类型
Spring	AOP、事务管理、远程调用	JDK/CGLIB
MyBatis	Mapper接口代理	JDK
Dubbo	服务接口代理	JDK/Javassist
Hibernate	懒加载代理	CGLIB/Javassist
Mockito	Mock对象	CGLIB/Byte Buddy
Feign	HTTP客户端代理	JDK

详细说明：

Spring AOP
- 为Bean创建代理
- 实现事务、日志、权限等横切关注点

MyBatis Mapper

java

// Mapper接口
public interface UserMapper {
    @Select("SELECT * FROM user WHERE id = #{id}")
    User selectById(int id);
}

// MyBatis使用JDK动态代理创建实现
UserMapper mapper = sqlSession.getMapper(UserMapper.class);

Dubbo服务调用
- 消费者端创建服务接口代理
- 代理负责网络调用和负载均衡
Hibernate懒加载
- 为实体类创建代理
- 延迟加载关联对象

5. 如何排查类加载相关的问题？

问题描述：在实际项目中如何排查类加载相关的问题？

答案要点：

排查工具和方法：

JVM参数查看类加载

bash

# 查看类加载过程
java -verbose:class YourClass

# 查看类加载器信息
java -XX:+TraceClassLoading YourClass

使用jcmd工具

bash

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

# 查看类加载器层次
jcmd <pid> VM.class_hierarchy

使用arthas

bash

# 查看类加载器树
classloader -t

# 查看类加载详情
classloader -c <hashcode>

# 查看类加载来源
sc -d com.example.YourClass

分析堆转储
- 使用MAT（Memory Analyzer Tool）
- 分析类加载器泄露

常见问题排查：

问题	排查方法
ClassNotFoundException	检查类路径、依赖是否正确
NoClassDefFoundError	检查类加载器层次、依赖版本
LinkageError	检查是否有重复类、版本冲突
类加载器泄露	分析堆转储，检查类加载器引用链

附录：类加载器相关面试题速查

基础概念

问题	答案要点
什么是类加载器？	负责加载类的对象，将字节码加载到JVM中
类加载器的层次？	Bootstrap → Extension → Application → 自定义
什么是双亲委派？	先委托父类加载器加载，父类加载器找不到再自己加载
为什么要双亲委派？	保证Java核心类库的安全性，避免重复加载

Tomcat相关

问题	答案要点
Tomcat如何打破双亲委派？	WebApp类加载器优先本地加载
为什么打破双亲委派？	实现Web应用类库隔离
Tomcat有哪些类加载器？	Common、Catalina、Shared、WebApp、JSP

OSGi相关

问题	答案要点
OSGi是什么？	动态模块化系统规范
OSGi的核心概念？	Bundle、Module、Lifecycle、Service
OSGi如何实现多版本共存？	每个Bundle独立的类加载器

动态代理相关

问题	答案要点
JDK动态代理要求？	目标类必须实现接口
CGLIB动态代理要求？	目标类不能是final
Spring AOP默认代理？	Spring Boot 2.x+默认CGLIB

总结：本章面试题主要围绕类加载器架构（Tomcat、OSGi）、字节码生成与动态代理、动态编译与热部署等实际应用场景。理解这些知识对于解决实际项目中的类加载问题、设计灵活的架构具有重要意义。

第9章 类加载及执行子系统的案例与实战 - 面试题总结 ​

目录 ​

一、Tomcat类加载器架构 ​

1. Tomcat为什么要打破双亲委派模型？ ​

2. Tomcat中WebApp类加载器的加载顺序是怎样的？ ​

3. Tomcat如何实现多个Web应用的类库隔离？ ​

4. 什么是类加载器泄露？Tomcat中如何避免？ ​

二、OSGi类加载器架构 ​

1. OSGi是什么？它解决了什么问题？ ​

2. OSGi类加载器与双亲委派模型有什么区别？ ​

3. OSGi如何实现同一个类的多版本共存？ ​

4. OSGi的服务层是如何工作的？ ​

三、字节码生成与动态代理 ​

1. JDK动态代理和CGLIB动态代理有什么区别？ ​

2. 动态代理的实现原理是什么？ ​

3. 常见的字节码生成技术有哪些？ ​

4. Spring AOP使用哪种动态代理？如何选择？ ​

四、动态编译与热部署 ​

1. JavaCompiler API是什么？如何使用？ ​

2. 如何实现Java代码的热部署？ ​

3. 什么是热替换类加载器？如何实现？ ​

4. 动态编译有哪些应用场景？ ​

五、综合面试题 ​

1. 类加载器有哪些实际应用场景？ ​

2. 如何解决类加载器冲突问题？ ​

3. 请设计一个简单的插件系统。 ​

4. 动态代理在框架中有哪些应用？ ​

5. 如何排查类加载相关的问题？ ​

附录：类加载器相关面试题速查 ​

基础概念 ​

Tomcat相关 ​

OSGi相关 ​

动态代理相关 ​

第9章类加载及执行子系统的案例与实战 - 面试题总结

目录

一、Tomcat类加载器架构

1. Tomcat为什么要打破双亲委派模型？

2. Tomcat中WebApp类加载器的加载顺序是怎样的？

3. Tomcat如何实现多个Web应用的类库隔离？

4. 什么是类加载器泄露？Tomcat中如何避免？

二、OSGi类加载器架构

1. OSGi是什么？它解决了什么问题？

2. OSGi类加载器与双亲委派模型有什么区别？

3. OSGi如何实现同一个类的多版本共存？

4. OSGi的服务层是如何工作的？

三、字节码生成与动态代理

1. JDK动态代理和CGLIB动态代理有什么区别？

2. 动态代理的实现原理是什么？

3. 常见的字节码生成技术有哪些？

4. Spring AOP使用哪种动态代理？如何选择？

四、动态编译与热部署

1. JavaCompiler API是什么？如何使用？

2. 如何实现Java代码的热部署？

3. 什么是热替换类加载器？如何实现？

4. 动态编译有哪些应用场景？

五、综合面试题

1. 类加载器有哪些实际应用场景？

2. 如何解决类加载器冲突问题？

3. 请设计一个简单的插件系统。

4. 动态代理在框架中有哪些应用？

5. 如何排查类加载相关的问题？

附录：类加载器相关面试题速查

基础概念

Tomcat相关

OSGi相关

动态代理相关