ClassLoader 概述
什么是 ClassLoader？
ClassLoader（类加载器）是 Java 虚拟机的重要组成部分，负责加载 Java 类和接口。它在 Java 程序运行时，根据需要动态加载类到 JVM 中。
为什么需要 ClassLoader？
- 动态加载：按需加载类
- 隔离性：不同加载器加载的类互相隔离
- 安全性：控制代码来源和访问权限
- 灵活性：支持热部署和插件机制
类加载过程
加载阶段
// 类加载的三个阶段
public class LoadingProcess {
/*
* 1. Loading（加载）
* - 通过类名获取二进制字节流
* - 转换为方法区的运行时数据结构
* - 在堆中生成 java.lang.Class 对象
*/
/*
* 2. Linking（链接）
* - Verification（验证）：确保类的正确性
* - Preparation（准备）：为静态变量分配内存
* - Resolution（解析）：符号引用转为直接引用
*/
/*
* 3. Initialization（初始化）
* - 执行静态初始化块
* - 为静态变量赋予正确的初始值
*/
}
ClassLoader 层次结构
1. Bootstrap ClassLoader
// 启动类加载器
public class BootstrapExample {
public static void main(String[] args) {
// 获取 Bootstrap ClassLoader 加载的路径
System.out.println(System.getProperty("sun.boot.class.path"));
// Bootstrap ClassLoader 在 Java 中显示为 null
System.out.println(String.class.getClassLoader());
}
}
2. Extension ClassLoader
// 扩展类加载器
public class ExtensionExample {
public static void main(String[] args) {
// 获取扩展类加载器的加载路径
System.out.println(System.getProperty("java.ext.dirs"));
// 获取扩展类加载器
ClassLoader extClassLoader = ClassLoader.getSystemClassLoader().getParent();
System.out.println(extClassLoader);
}
}
3. Application ClassLoader
// 应用类加载器
public class ApplicationExample {
public static void main(String[] args) {
// 获取应用类加载器
ClassLoader appClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(appClassLoader);
// 获取类路径
System.out.println(System.getProperty("java.class.path"));
}
}
双亲委派模型
工作原理
public class ParentDelegation {
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException {
// 首先检查类是否已经加载
Class<?> c = findLoadedClass(name);
if (c == null) {
try {
// 委托给父类加载器加载
if (parent != null) {
c = parent.loadClass(name, false);
} else {
// 使用启动类加载器加载
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// 父类加载器无法加载时
// 调用自己的 findClass 方法加载
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
优点和作用
- 确保安全性：防止核心类被篡改
- 避免重复加载：父加载器加载过的类不会重复加载
- 保证类的唯一性：相同类由同一加载器加载
自定义 ClassLoader
基本实现
public class CustomClassLoader extends ClassLoader {
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
// 加载类文件的字节码
byte[] classData = loadClassData(name);
if (classData == null) {
throw new ClassNotFoundException();
}
// 将字节码转换为 Class 对象
return defineClass(name, classData, 0, classData.length);
}
private byte[] loadClassData(String name) {
// 实现类文件的加载逻辑
// 例如：从特定位置读取类文件
return null;
}
}
高级特性
public class AdvancedClassLoader extends ClassLoader {
private final String classPath;
public AdvancedClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
// 从自定义路径加载类文件
String fileName = classPath + File.separator +
name.replace('.', File.separatorChar) + ".class";
try (FileInputStream fis = new FileInputStream(fileName);
ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
int bufferSize = 1024;
byte[] buffer = new byte[bufferSize];
int bytesNumRead;
while ((bytesNumRead = fis.read(buffer)) != -1) {
baos.write(buffer, 0, bytesNumRead);
}
byte[] classBytes = baos.toByteArray();
return defineClass(name, classBytes, 0, classBytes.length);
}
} catch (IOException e) {
throw new ClassNotFoundException("Could not load class " + name, e);
}
}
}
常见应用场景
1. 热部署
public class HotDeployExample {
private static Map<String, Long> classModifiedTimes = new HashMap<>();
private static CustomClassLoader loader = new CustomClassLoader();
public static void checkAndReload(String className) {
File classFile = new File(className.replace('.', '/') + ".class");
long lastModified = classFile.lastModified();
if (classModifiedTimes.containsKey(className) &&
lastModified > classModifiedTimes.get(className)) {
// 重新加载类
loader = new CustomClassLoader();
try {
Class<?> clazz = loader.loadClass(className);
// 处理重新加载的类
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
classModifiedTimes.put(className, lastModified);
}
}
2. 类隔离
public class IsolationExample {
public static void main(String[] args) throws Exception {
// 创建两个不同的类加载器
CustomClassLoader loader1 = new CustomClassLoader("path1");
CustomClassLoader loader2 = new CustomClassLoader("path2");
// 加载同名但不同版本的类
Class<?> class1 = loader1.loadClass("com.example.MyClass");
Class<?> class2 = loader2.loadClass("com.example.MyClass");
// 验证类的隔离性
System.out.println(class1 == class2); // false
}
}
性能优化
1. 缓存机制
public class CachedClassLoader extends ClassLoader {
private Map<String, Class<?>> classCache = new ConcurrentHashMap<>();
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
// 检查缓存
Class<?> cachedClass = classCache.get(name);
if (cachedClass != null) {
return cachedClass;
}
// 加载类
Class<?> loadedClass = super.findClass(name);
classCache.put(name, loadedClass);
return loadedClass;
}
}
2. 并发处理
public class ConcurrentClassLoader extends ClassLoader {
private final ReentrantLock lock = new ReentrantLock();
@Override
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException {
lock.lock();
try {
return super.loadClass(name, resolve);
} finally {
lock.unlock();
}
}
}
常见问题
1. ClassNotFoundException
try {
Class.forName("com.example.MyClass");
} catch (ClassNotFoundException e) {
// 处理类未找到异常
System.err.println("类加载失败：" + e.getMessage());
}
2. NoClassDefFoundError
try {
// 检查类文件是否存在
InputStream is = getClass().getResourceAsStream(
"/com/example/MyClass.class");
if (is == null) {
System.err.println("类文件不存在");
}
} catch (Exception e) {
e.printStackTrace();
}
最佳实践
- 遵循双亲委派模型
- 正确处理资源释放
- 避免类加载器泄漏
- 合理使用缓存
- 处理并发情况
总结
ClassLoader 是 Java 平台的核心机制之一，理解其工作原理对于：
- 开发高级 Java 应用
- 实现插件系统
- 处理类加载问题
- 优化应用性能
都具有重要意义。通过合理使用 ClassLoader，可以实现更灵活、安全的 Java 应用。