类加载器负责将 Java 类文件加载到 Java 虚拟机。
只有当类被加载进虚拟机内存,才能使用对应的类。
在 Java 中,类加载过程大概分为以下几步:
- 通过全限类名获取类文件字节数组。可来自本地文件、jar 包、网络等。
- 在方法区/元空间保存类的描述信息、静态属性。
- 在 JVM 堆中生成一个对应的 java.lang.Class 对象。
具体的加载过程为:
加载:在硬盘上查找并通过IO读入字节码文件,使用到类时才会加载,例如调用类的 main() 方法,new 对象等等,在加载阶段会在内存中生成一个代表这个类的 java.lang.Class 对象,作为方法区这个类的各种数据的访问入口。
验证:校验字节码文件的正确性。
准备:给类的静态变量分配内存,并赋予默认值。
解析:将符号引用替换为直接引用,该阶段会把一些静态方法(符号引用,比如 main() 方法)替换为指向数据所存内存的指针或句柄等(直接引用),这是所谓的静态链接过 程(类加载期间完成),动态链接是在程序运行期间完成的将符号引用替换为直接引用。
初始化:对类的静态变量初始化为指定的值,执行静态代码块。
Java 默认提供三个类加载器,分别为:
- Bootstrap ClassLoader
- Extension ClassLoader
- App ClassLoader
Bootstrap ClassLoader 负责加载Java基础类,主要是 %JRE_HOME%/lib/ 目录下的rt.jar、resources.jar、charsets.jar等。
Extension ClassLoader 负责加载Java扩展类,主要是 %JRE_HOME%/lib/ext 目录下的jar。
App ClassLoader 负责加载当前应用的ClassPath中的所有类。
类加载器加载的流程如下:
先简单的打印一下默认的加载器:
public class Hello {
public static void main(String[] args) {
ClassLoader classLoader = Hello.class.getClassLoader();
System.out.println(classLoader.getParent().getParent());
System.out.println(classLoader.getParent());
System.out.println(classLoader);
}
}
打印结果为:
null
sun.misc.Launcher$ExtClassLoader@61bbe9ba
sun.misc.Launcher$AppClassLoader@18b4aac2
由于引导类加载器由 c++ 实现 故为 null(加载器之间不是真正的继承关系)
类加载器初始化过程:
创建 JVM 启动器实例 sun.misc.Launcher。
sun.misc.Launcher 初始化使用了单例模式设计,保证一个 JVM 虚拟机内只有一个 sun.misc.Launcher 实例。
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); // 创建应用类加载器,并把自己的parent引用指向扩展类加载器
} catch (IOException var9) {
throw new InternalError("Could not create application class loader", var9);
}
...其它代码省略
}
在Launcher构造方法内部,其创建了两个类加载器,分别是Launcher.ExtClassLoader (扩展类加载器) 和 Launcher.AppClassLoader (应用类加载器)。
JVM 默认使用 Launcher 的 getClassLoader() 方法返回的类加载器 AppClassLoader 的实例加载我们的应用程序。
双亲委派机制
加载器在加载某个类时会先委托父加载器寻找目标类,找不到再委托上层父加载器加载,如果所有父加载器在自己的加载类路径下都找不到目标类,则在自己的类加载路径中查找并载入目标类。部分实现如下:
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
c = parent.loadClass(name, false); // 直接委托父加载器加载
} else {
c = findBootstrapClassOrNull(name); // 父加载器为空,则委托引导类加载器加载
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
为什么要设计双亲委派机制?
沙箱安全机制:自己写的 java.lang.String.class 类不会被加载,这样便可以防止核心 API库被随意篡改。
避免类的重复加载:当父亲已经加载了该类时,就没有必要子 ClassLoader 再加载一 次,保证被加载类的唯一性。
若想打破双亲加载机制,重写此加载方法,实现自己的加载逻辑,不委派给双亲加载即可。
全盘负责委托机制
“全盘负责”是指当一个 ClassLoder 装载一个类时,除非显示的使用另外一个 ClassLoder ,该类所依赖及引用的类也由这个 ClassLoder 载入。
自定义类加载器
自定义类加载器则可以实现额外的需求,例如:
从网络文件加载类。
从任意目录加载类。
对字节码文件做加密处理,由自定义类加载器做解密。
下面是继承了 URLClassLoader 的一个简单自定义类加载器
public class MyClassLoader extends URLClassLoader {
private String classPath;
public MyClassLoader(URL[] urls){
super(urls);
}
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, MalformedURLException {
File file = new File("/opt"); // 自定义的加载根目录
URL[] URLs = new URL[] {file.toURI().toURL()};
MyClassLoader myClassLoader = new MyClassLoader(URLs);
Class<?> aClass = myClassLoader.loadClass("com.app.Hello"); // java文件的具体地址
Object object = aClass.newInstance(); // 通过反射来调用对象里的方法
Method method = aClass.getDeclaredMethod("sayHello", String.class);
method.invoke(object, "lilei");
System.out.println(object.getClass().getClassLoader().getParent());
System.out.println(object.getClass().getClassLoader());
}
}
打印结果为:
hello lilei
sun.misc.Launcher$AppClassLoader@18b4aac2
com.app.MyClassLoader@61bbe9ba
URLClassLoader 类中主要帮我们实现了 ClassLoader 的 findClass 方法,实现代码如下:
protected Class<?> findClass(final String name)
throws ClassNotFoundException
{
final Class<?> result;
try {
result = AccessController.doPrivileged(
new PrivilegedExceptionAction<Class<?>>() {
public Class<?> run() throws ClassNotFoundException {
String path = name.replace('.', '/').concat(".class");
Resource res = ucp.getResource(path, false);
if (res != null) {
try {
return defineClass(name, res);
} catch (IOException e) {
throw new ClassNotFoundException(name, e);
}
} else {
return null;
}
}
}, acc);
} catch (java.security.PrivilegedActionException pae) {
throw (ClassNotFoundException) pae.getException();
}
if (result == null) {
throw new ClassNotFoundException(name);
}
return result;
}
实现自定义类加载器的主要步骤为:
继承 ClassLoader 类。如果只是从目录或者jar包加载类,也可以选择继承 URLClassLoader 类。
重写 findClass 方法。
在重写的 findClass 方法中,无论用何种方法,获取类文件对应的字节数组,然后调用 defineClass 方法转换成类实例。
需要注意下,即使自己自定义了类加载器,并重写了 loadClass 方法打破双亲委派机制,也无法篡改 java 核心类,最后来看一下 ClassLoader 中 defineClass 的部分校验代码:
private ProtectionDomain preDefineClass(String name, ProtectionDomain pd) {
if (!checkName(name))
throw new NoClassDefFoundError("IllegalName: " + name);
// 防止篡改其核心类
if ((name != null) && name.startsWith("java.")) {
throw new SecurityException
("Prohibited package name: " +
name.substring(0, name.lastIndexOf('.')));
}
if (pd == null) {
pd = defaultDomain;
}
if (name != null) checkCerts(name, pd.getCodeSource());
return pd;
}