java文件流classload_深入理解JVM之ClassLoader

1.什么是类加载器

在编写Java程序时需要使用javac命令将.java后缀名的文件编译成.class文件，然后JVM通过执行.class文件来运行我们写的程序，那么JVM怎么才能执行.class文件呢？

这就需要类加载器了。

2.有哪几种类加载器BootstrapClassLoader：这个类加载器可以被称为引导类加载器，它由C++语言编写，在JDK中看到的是使用native标注的方法。它负责加载jre/lib下的核心包，例如：rt.jar。

ExtClassLoader：它被称为扩展类加载器，它是由Java语言编写，用于加载jre/lib/ext目录中的包。

AppClassLoader：这个类加载器叫做应用程序类加载器，它是我们平时使用最频繁的一种类加载器，用于加载classpath下的.class文件，也就是我们自己写的程序。

自定义的类加载器：该类加载器用于加载我们指定的一些类。

3.ClassLoader之间的关系

3.1 类加载器创建过程

在jdk中找到sun.misc.Launcher文件，这个文件是JVM中的启动器实例，在该类内部有getLauncher()方法public static Launcher getLauncher() {

return launcher;

}

它返回的是launcher 实例private static Launcher launcher = new Launcher();

在构造方法调用时会初始化 ExtClassLoader和AppClassLoader(BootstrapClassLoader会在Java虚拟机创建之后进行加载，所以是在此之前)。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);

} catch (IOException var9) {

throw new InternalError("Could not create application class loader", var9);

}

Thread.currentThread().setContextClassLoader(this.loader);

// 非核心的就去掉了

}

通过点击 getXxxClassLoader() 跟到最后可以看到private ClassLoader(Void unused, ClassLoader parent) {

// 通过这行可以让加载器之间建立父子级关系

this.parent = parent;

if (ParallelLoaders.isRegistered(this.getClass())) {

parallelLockMap = new ConcurrentHashMap<>();

package2certs = new ConcurrentHashMap<>();

assertionLock = new Object();

} else {

// no finer-grained lock; lock on the classloader instance

parallelLockMap = null;

package2certs = new Hashtable<>();

assertionLock = this;

}

}

注意： 我们查看ExtClassLoader时会发现这里的parent是null，而查看AppClassLoader时传入的parent是ExtClassLoader的对象实例。所以这里也就印证了上面画的图。

3.2 探究加载类的流程protected Class> loadClass(String name, boolean resolve)

throws ClassNotFoundException

{

synchronized (getClassLoadingLock(name)) {

// 检查目标类是否已加载，如果已加载则返回

Class> c = findLoadedClass(name);

// 没有加载到

if (c == null) {

long t0 = System.nanoTime();

try {

// 当前加载器的父加载器是否存在

if (parent != null) {

// 如果父加载器存在则使用父加载器进行加载

c = parent.loadClass(name, false);

} else {

// 如果父加载器不存在就是用BootstrapClassLoader加载

c = findBootstrapClassOrNull(name);

}

} catch (ClassNotFoundException e) {

// ClassNotFoundException thrown if class not found

// from the non-null parent class loader

}

// 如果父加载器和BootstrapClassLoader都没有加载到的话

if (c == null) {

// If still not found, then invoke findClass in order

// to find the class.

long t1 = System.nanoTime();

// 自己进行加载

// 这个方法默认是一个空实现，需要自己重写

c = findClass(name);

// this is the defining class loader; record the stats

sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);

sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);

sun.misc.PerfCounter.getFindClasses().increment();

}

}

if (resolve) {

resolveClass(c);

}

// 返回已加载到的类或null

return c;

}

}

加载步骤：判断当前类加载器是否已经加载目标类，如果已经加载则返回，否则使用判断是否存在父加载器

如果父加载器存在重复步骤1，直到parent == null，这时会使用 BootstrapClassLoader 加载

如果父加载器和引导类加载器都没有加载到目标类的话，就使用自己的findClass() 方法来加载目标类。

找到某个ClassLoader，这里以AppClassLoader为例static class AppClassLoader extends URLClassLoader {

在AppClassLoader中搜索findClass()方法是找不到的，所以找到每个加载器共同的父类URLClassLoader，在这里可以看到findClass()方法。protected Class> findClass(final String name)

throws ClassNotFoundException

{

final Class> result;

try {

result = AccessController.doPrivileged(

new PrivilegedExceptionAction>() {

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;

}

findClass方法的作用是从指定的路径找到传入的文件名称的.class文件，并返回回去，该方法的主要逻辑在run()方法中。

4.实现自己的ClassLoader

从前面可以知道，要想实现classLoader只需要继承ClassLoader类并重写 findClass 和 loadClass 方法即可。

4.1 创建java文件

在桌面创建了一个名为Test的Java文件，并使用javac命令进行编译。public class Test {

public void sayHi() {

System.out.println("hi!");

}

public static void main(String[] args) {

System.out.println("Hello World!");

}

}

4.2 完成方法重写与测试/**

* Created by luyi on 2021/2/16.

* 描述：自定义ClassLoader

*/

public class MyClassLoader extends ClassLoader {

public String classPath;

public MyClassLoader(String classPath) {

this.classPath = classPath;

}

/**

* 通过输入流读取文件

*

* @param name 文件全限定类名

*/

public byte[] loadByte(String name) throws IOException {

if (name == null || name.length() == 0) {

return new byte[1024];

}

name = name.replaceAll("\\.", "/");

FileInputStream fis = new FileInputStream(classPath + "/" + name + ".class");

int len = fis.available();

byte[] data = new byte[len];

fis.read(data);

fis.close();

return data;

}

/**

* 将指定的路径中的指定的文件进行加载

*

* @param name 全限定类名

* @return

* @throws ClassNotFoundException

*/

@Override

protected Class> findClass(String name) throws ClassNotFoundException {

if (name == null || name.length() == 0) {

return null;

}

try {

byte[] data = loadByte(name);

return defineClass(name, data, 0, data.length);

} catch (IOException e) {

e.printStackTrace();

throw new ClassNotFoundException();

}

}

public static void main(String[] args) throws Exception {

MyClassLoader loader = new MyClassLoader("/Users/luyi/Desktop");

Class> clazz = loader.loadClass("Test", false);

Object instance = clazz.newInstance();

Method sayHi = clazz.getDeclaredMethod("sayHi", null);

sayHi.invoke(instance, null);

System.out.println(clazz.getClassLoader().getClass().getName());

}

}

运行结果：

从运行结果可以看出，自定义的类加载器已经完成了对指定文件的加载，并正确的执行了方法。