ClassLoader的原理及应用

我欲只争朝夕

发布于 2023-11-3 10:48

浏览

0收藏

前言

先来看Java程序是怎么工作的

ClassLoader的原理及应用-鸿蒙开发者社区

我们都知道Java是跨平台的，是因为不同平台下的JVM能将字节码文件解释为本地机器指令，JVM是怎么加载字节码文件的？答案就是ClassLoader，先来打印看一下ClassLoader对象

public class ClassLoaderDemo1 {

   public static void main(String[] args) {
       // null
       System.out.println(String.class.getClassLoader());
       ClassLoader loader = ClassLoaderDemo1.class.getClassLoader();
       while (loader != null) {
           // sun.misc.Launcher$AppClassLoader@58644d46
           // sun.misc.Launcher$ExtClassLoader@7ea987ac
           System.out.println(loader);
           loader = loader.getParent();
       }
   }
}

要理解这个输出，我们就得说一下双亲委派模式，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己想办法去完成。双亲委派模式中的父子关系并非通常所说的类继承关系，而是采用组合关系来复用父类加载器的相关代码。

采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关可以避免类的重复加载，当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次。其次是考虑到安全因素，java核心api中定义类型不会被随意替换，假设通过网络传递一个名为java.lang.Integer的类，通过双亲委托模式传递到启动类加载器，而启动类加载器在核心Java API发现这个名字的类，发现该类已被加载，并不会重新加载网络传递的过来的java.lang.Integer，而直接返回已加载过的Integer.class，这样便可以防止核心API库被随意篡改。检查和加载过程以及系统提供的ClassLoader的作用如下图。

ClassLoader的原理及应用-鸿蒙开发者社区

LZ原来面试的时候就被问到，如果在你项目中建一个java.lang.String的类，那系统中用的String类是你定义的String类，还是原生api中的String类，用双亲加载来解释就很容易理解用的是原生api中的String类

类加载器的关系如下：

启动类加载器，由C++实现，没有父类
拓展类加载器(ExtClassLoader)，由Java语言实现，父类加载器为null
系统类加载器(AppClassLoader)，由Java语言实现，父类加载器为ExtClassLoader系统类加载器(AppClassLoader)
自定义类加载器，父类加载器肯定为AppClassLoader。自定义类加载器，父类加载器肯定为AppClassLoader

源码解析

一般只需要理解ClassLoader 这3个方法即可
loaderClass：实现双亲委派
findClass：用来复写加载
defineClass：本地方法，最终加载类只能通过defineClass

// 从这方法开始加载
public Class<?> loadClass(String name) throws ClassNotFoundException {
 return loadClass(name, false);
}

// 实现双亲委派
protected Class<?> loadClass(String name, boolean resolve)
 throws ClassNotFoundException
{
 synchronized (getClassLoadingLock(name)) {
   // First, check if the class has already been loaded
   // 先从缓存查找该class对象，找到就不用重新加载
   Class<?> c = findLoadedClass(name);
   if (c == null) {
     long t0 = System.nanoTime();
     try {
       if (parent != null) {
         // 如果加载不到，委托父类去加载  
         // 这里体现了自底向上检查类是否已经加载          
         c = parent.loadClass(name, false);
       } else {
         // 如果没有父类，委托启动加载器去加载
         c = findBootstrapClassOrNull(name);
       }
     } catch (ClassNotFoundException e) {
       // ClassNotFoundException thrown if class not found
       // 这里体现了自顶向下尝试加载类，当父类加载加载不到时
       // 会抛出ClassNotFoundException
       // from the non-null parent class loader
     }

     if (c == null) {
       // If still not found, then invoke findClass in order
       // to find the class.
       long t1 = System.nanoTime();
       // 如果都没有找到，通过自己的实现的findClass去加载
       // findClass方法没有找到会抛出ClassNotFoundException
       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);
   }
   return c;
 }
}

// 复写加载
protected Class<?> findClass(String name) throws ClassNotFoundException {
 throw new ClassNotFoundException(name);
}

自定义类加载器

为什么要编写自己的类加载器？

当class文件不在ClassPath路径下，默认系统类加载器无法找到该class文件，在这种情况下我们需要实现一个自定义的ClassLoader来加载特定路径下的class文件生成class对象。
当一个class文件是通过网络传输并且可能会进行相应的加密操作时，需要先对class文件进行相应的解密后再加载到JVM内存中，这种情况下也需要编写自定义的ClassLoader并实现相应的逻辑。当一个class文件是通过网络传输并且可能会进行相应的加密操作时，需要先对class文件进行相应的解密后再加载到JVM内存中，这种情况下也需要编写自定义的ClassLoader并实现相应的逻辑
当需要实现热部署功能时(一个class文件通过不同的类加载器产生不同class对象从而实现热部署功能)，需要实现自定义ClassLoader的逻辑。当需要实现热部署功能时(一个class文件通过不同的类加载器产生不同class对象从而实现热部署功能)，需要实现自定义ClassLoader的逻辑。

当继承ClassLoader时，只要重写findClass方法即可，还可以继承URLClassLoader，代码更简洁，这里不再赘述，下面写一个从指定文件中加载class文件的FileClassLoader

public class DemoObj {

   public String toString() {
       return "I am DemoObj";
   }

}

javac生成相应的class文件，放到指定目录，然后由FileClassLoader去加载

public class FileClassLoader extends ClassLoader {

   // class文件的目录
   private String rootDir;

   public FileClassLoader(String rootDir) {
       this.rootDir = rootDir;
   }

   @Override
   protected Class<?> findClass(String name) throws ClassNotFoundException {
       byte[] classData = getClassData(name);
       if (classData == null) {
           throw new ClassNotFoundException();
       } else {
           return defineClass(name, classData, 0, classData.length);
       }
   }

   private byte[] getClassData(String className) {

       String path = rootDir + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
       try {
           InputStream ins = new FileInputStream(path);
           ByteArrayOutputStream baos = new ByteArrayOutputStream();
           int bufferSize = 4096;
           byte[] buffer = new byte[bufferSize];
           int bytesNumRead = 0;
           while ((bytesNumRead = ins.read(buffer)) != -1) {
               baos.write(buffer, 0, bytesNumRead);
           }
           return baos.toByteArray();
       } catch (IOException e) {
           e.printStackTrace();
       }
       return null;
   }

   public static void main(String[] args) {

       String rootDir="E:\\Code\\study-java\\src\\main\\java";
       FileClassLoader loader = new FileClassLoader(rootDir);

       try {
           // 传入class文件的全限定名
           Class<?> clazz = loader.loadClass("com.st.classloader.DemoObj");
           // com.st.classloader.FileClassLoader@7ea987ac
           System.out.println(clazz.getClassLoader());
           // I am DemoObj
           System.out.println(clazz.newInstance().toString());
       } catch (Exception e) {
           e.printStackTrace();
       }
   }
}

应用

可以对class文件进行加密和解密，实现应用的热部署，防止类重名等。这里只对Tomcat中的ClassLoader进行分析

在解释防止类重名作用前先抛出一个问题，Class对象的唯一标识能否只由全限定名确定？答案是不能，因为你无法保证多个项目间不出现相同的全限定名的类。比如和JDK原生类重名或者你的Web项目和Tomcat类重名（全限定名重名无法沟通，无法约束）。JVM判断2个类是否相同的条件是：（1）全限定名相同（2）由同一个类加载器加载

写个例子验证一下，先自定义一个FileClassLoader1，直接defineClass，不委托父类加载器进行加载

public class FileClassLoader1 extends ClassLoader {

   private String rootDir;

   public FileClassLoader1(String rootDir) {
       this.rootDir = rootDir;
   }

   public Class<?> myLoadClass(String name) throws ClassNotFoundException {
       byte[] classData = getClassData(name);
       if (classData == null) {
           throw new ClassNotFoundException();
       } else {
           return defineClass(name, classData, 0, classData.length);
       }
   }

   private byte[] getClassData(String className) {

       String path = rootDir + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
       try {
           InputStream ins = new FileInputStream(path);
           ByteArrayOutputStream baos = new ByteArrayOutputStream();
           int bufferSize = 4096;
           byte[] buffer = new byte[bufferSize];
           int bytesNumRead = 0;
           while ((bytesNumRead = ins.read(buffer)) != -1) {
               baos.write(buffer, 0, bytesNumRead);
           }
           return baos.toByteArray();
       } catch (IOException e) {
           e.printStackTrace();
       }
       return null;
   }

}

验证即使同一个class文件被不同classloader加载，也会被认为是不同的类

public class ClassLoaderDemo2 {

   public static void main(String[] args) throws Exception {
       String rootDir="E:\\Code\\study-java\\src\\main\\java";
       FileClassLoader1 loader = new FileClassLoader1(rootDir);
       Class<?> clazz = loader.myLoadClass("com.st.classloader.DemoObj");
       // com.st.classloader.FileClassLoader1@12a3a380
       System.out.println(clazz.getClassLoader());
       // sun.misc.Launcher$AppClassLoader@58644d46
       System.out.println(DemoObj.class.getClassLoader());
       Object object = clazz.newInstance();
       // I am DemoObj
       System.out.println(object);
       // 从这里可以看到，虽然class文件一样，但是由不同的classloader加载，则为不同的类
       // false
       System.out.println(object instanceof DemoObj);
   }
}

Tomcat中就定义了很多ClassLoader来防止重名。在Tomcat中提供了一个Common ClassLoader，它主要负责加载Tomcat使用的类和Jar包以及应用通用的一些类和Jar包，例如CATALINA_HOME/lib目录下的所有类和Jar包。Tomcat会为每个部署的应用创建一个唯一的类加载器，也就是WebApp ClassLoader，它负责加载该应用的WEB-INF/lib目录下的Jar文件以及WEB-INF/classes目录下的Class文件。由于没有应用都有自己的WebApp ClassLoader，这样就可以使不同的Web应用之间相互隔离，彼此之间看不到对方使用的类文件。即使不同项目下的类全限定名有可能相等，也能正常工作。

ClassLoader的原理及应用-鸿蒙开发者社区