类加载机制的加载阶段主要负责通过全限定名获取定义此类的二进制字节流,并将该字节流所代表的静态存储结构转化为方法区的运行时数据结构,同时在内存中生成一个代表这个类的 java.lang.class 对象。这一过程由类加载器(classloader)完成,它并不局限于从本地文件系统读取 .class 文件,而是可以从 zip 包、网络甚至动态计算生成字节流。加载阶段是用户自定义类加载器最可控制的阶段,开发者可以通过重写 loadclass 方法来改变默认的加载逻辑。

如何自定义类加载器以拦截特定包的加载
要拦截特定包的加载,需要继承 java.lang.ClassLoader 并重写 findClass 方法,或者更彻底地重写 loadClass 方法以打破双亲委派模型。通常推荐的做法是保留父加载器的委托逻辑,仅在找不到类时尝试从自定义来源加载。以下代码展示了一个简单的自定义类加载器,它尝试从指定目录加载 com.example.custom 包下的类。
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class CustomClassLoader extends ClassLoader {
private String classPath;
public CustomClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class> findClass(String name) throws ClassNotFoundException {
if (name.startsWith("com.example.custom")) {
try {
String fileName = classPath + File.separator + name.replace(".", File.separator) + ".class";
File file = new File(fileName);
FileInputStream fis = new FileInputStream(file);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1) {
bos.write(buffer, 0, len);
}
fis.close();
byte[] bytes = bos.toByteArray();
return defineClass(name, bytes, 0, bytes.length);
} catch (IOException e) {
throw new ClassNotFoundException("Cannot load class: " + name, e);
}
} else {
return super.findClass(name);
}
}
public static void main(String[] args) throws Exception {
CustomClassLoader loader = new CustomClassLoader("/path/to/classes");
Class> clazz = loader.loadClass("com.example.custom.MyClass");
System.out.println("Loaded by: " + clazz.getClassLoader().getClass().getName());
}
}
运行上述代码后,控制台将输出 Loaded by: CustomClassLoader,证明该类确实由自定义加载器加载。如果请求的类不在 com.example.custom 包下,则会自动委托给父加载器处理。

双亲委派模型在加载阶段的具体执行流程是什么
双亲委派模型要求当一个类加载器收到类加载请求时,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成,每一层的类加载器都是如此,因此所有的加载请求最终都应该传送到顶层的启动类加载器中,只有当父加载器反馈自己无法完成这个加载请求(它的搜索范围中没有找到所需的类)时,子加载器才会尝试自己去加载。这种机制保证了 Java 核心 API 的安全性和一致性,防止用户自定义的 java.lang.Object 等核心类被替换。
import java.util.ArrayList;
import java.util.List;
public class DelegationTest {
public static void main(String[] args) {
// 模拟双亲委派链
List<string> delegationChain = new ArrayList();
delegationChain.add("Bootstrap ClassLoader (JRE/lib/rt.jar)");
delegationChain.add("Extension ClassLoader (JRE/lib/ext/*.jar)");
delegationChain.add("Application ClassLoader (Classpath)");
for (String cl : delegationChain) {
System.out.println("Delegating to: " + cl);
}
// 实际加载测试
try {
Class> objClass = Class.forName("java.lang.Object");
System.out.println("Object loaded by: " + objClass.getClassLoader());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}</string>
执行该程序,输出显示 java.lang.Object 是由 null 表示的 Bootstrap ClassLoader 加载的,这验证了双亲委派的最终层级。如果尝试加载一个位于 Classpath 中的同名恶意类,由于父加载器已经找到了核心库中的类,子加载器将不会执行加载操作,从而确保了安全性。

加载阶段生成的 Class 对象在内存中有什么特征
在加载阶段结束时,虚拟机会在堆内存中创建一个 java.lang.Class 对象,这个对象作为方法区中该类的数据结构的访问入口。这个 Class 对象并不是类的简单镜像,它包含了类的元数据信息,如类名、父类、接口、字段、方法等。每个类在 JVM 中只有一个对应的 Class 对象,无论该类被实例化多少次,其 Class 对象都是唯一的。这意味着可以通过 Class 对象进行反射操作,获取类的详细信息。
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ClassObjectDemo {
public static void main(String[] args) throws Exception {
Class> stringClass = String.class;
// 获取类名
System.out.println("Class Name: " + stringClass.getName());
// 获取父类
System.out.println("Superclass: " + stringClass.getSuperclass().getName());
// 获取所有方法
Method[] methods = stringClass.getDeclaredMethods();
System.out.println("Number of methods: " + methods.length);
// 获取所有字段
Field[] fields = stringClass.getDeclaredFields();
System.out.println("Number of fields: " + fields.length);
// 验证唯一性
Class> stringClass2 = Class.forName("java.lang.String");
System.out.println("Same Class object? " + (stringClass == stringClass2));
}
}
运行结果会显示 java.lang.String 的类名、父类为 java.lang.Object、方法数量和字段数量,并且最后输出 true,证明两次获取的 Class 对象是同一个实例。这表明加载阶段创建的 Class 对象在 JVM 内部是单例的,用于统一管理类的元数据。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南











