Java——类加载器探究

最新推荐文章于 2024-10-28 09:54:22 发布

扶不起来的阿强

最新推荐文章于 2024-10-28 09:54:22 发布

阅读量195

点赞数

本文介绍Java的类加载机制，包括启动类加载器、扩展类加载器及应用程序类加载器的工作原理，同时通过实例演示自定义类加载器的过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java内置类加载器

java内置了三层次结构的类加载器
1：启动类加载器也叫引导类加载器（Bootstrap）     加载JAVA_HOME/lib 下的类比如rt.jar（加载系统jar包，对程序不可见的）
2：扩展类加载器（ExtClassLoader）      加载JAVA_HOME/lib/ext 下的类
3：应用程序类加载器（AppClassLoader）     加载应用程序CLASSPATH下的class文件
一个加载器在加载一个类的时候，都要先使用它的父类加载器去加载这个类，如果它的父类加载器可以加载这个类，
那么就用父类加载器加载这个类，否则自己加载这个类。
下面看一段程序：

[java]view plaincopy
package com.lyz.classloader.test;  
/** 
 * Java类加载器 
 * @author liuyazhuang 
 * 
 */  
public class Test {  
  
    public static void main(String[] args) {  
          
        //应用类加载器   Test在classpath下 所以AppClassLoader会加载这个类  
        System.out.println(Test.class.getClassLoader().getClass().getName());  
  
        //启动类加载器    System类是rt.jar 包下的类 是启动类加载器加载的，但是启动类加载器对程序不可见，得到的是null  
        System.out.println(System.class.getClassLoader());  
  
        //扩展类加载器结构  
        ClassLoader loader = Test.class.getClassLoader();  
        while (null != loader) {  
            System.out.println(loader.getClass().getName());  
            loader = loader.getParent();  
        }  
        System.out.println(loader);  
    }  
}  

输出结果如下：

[plain]view plaincopy
sun.misc.Launcher$AppClassLoader  
null  
sun.misc.Launcher$AppClassLoader  
sun.misc.Launcher$ExtClassLoader  
null  

自定义类加载器

自定义的类加载器继承ClassLoader，推荐只重写findClass方法，这样就维持了加载器的父类委派机制。它的父类加载器默认为AppClassLoader。

[java]view plaincopy
package com.lyz.classloader.test;  
  
import java.io.ByteArrayOutputStream;  
import java.io.File;  
import java.io.FileInputStream;  
  
/** 
 * 自定义类加载器 
 * @author liuyazhuang 
 * 
 */  
public class MyClassLoader extends ClassLoader {  
    // 类存放的路径  
    private String classpath;  
  
    public MyClassLoader(String classpath){  
        this.classpath = classpath;  
    }  
      
    /** 
     * 重写findClass方法 
     */  
    @Override  
    public Class<?> findClass(String name) {  
        byte[] data = loadClassData(name);  
        return this.defineClass(name, data, 0, data.length);  
    }  
  
    public byte[] loadClassData(String name) {  
        System.out.println("加载"+name); //注意这里的输出  
        try {  
            name = name.replace(".", "//");  
            FileInputStream is = new FileInputStream(new File(classpath + name + ".class"));  
            ByteArrayOutputStream baos = new ByteArrayOutputStream();  
            int b = 0;  
            while ((b = is.read()) != -1) {  
                baos.write(b);  
            }  
            is.close();  
            return baos.toByteArray();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return null;  
    }  
}  

验证一下父类委派机制.

[java]view plaincopy
//验证一下父类委派机制.  
@Test  
public void testParentLoader() throws ClassNotFoundException{  
    //com.load.Test 此类在classpath下  
    MyClassLoader loader = new MyClassLoader("D:\\Workspaces\\MySelf\\Test\\bin\\");  
    Class<?> loadClass = loader.loadClass("com.lyz.classloader.test.MyClassLoaderTest");  
    System.out.println(loadClass.getClassLoader());  
      
      
    MyClassLoader loader1 = new MyClassLoader("D:\\Workspaces\\MySelf\\Test\\bin\\");  
    Class<?> loadClass1 = loader1.loadClass("com.lyz.classloader.test.MyClassLoaderTest");  
    System.out.println(loadClass1.getClassLoader());  
}  

运行结果如下：

[plain]view plaincopy
sun.misc.Launcher$AppClassLoader@2a139a55  
sun.misc.Launcher$AppClassLoader@2a139a55  

从这里的输出我们看到，两次类加载都没有调用MyClassLoader的findClass方法。在加载的过程中，先要调用父类AppClassLoader来加载此类，因为com.load.Test在classpath下所以父类加载器可以加载这个类，然后直接就把这个类加载了，并没有调用子类的加载方法。还可以看出两次加载得到的class对象是一致的。其实第二次其实并没有加载，在类加载的时候首先会查看这个类是否加载过，如果已经加载了就不再加载，直接返回之前的class对象。
加载classpath之外的类，在d盘下新建一个类，如下：

[java]view plaincopy
package com.lyz.classloader.test;  
  
/** 
 * 测试在classpth以外的类 
 * @author liuyazhuang 
 * 
 */  
public class ClassOutOfClasspath {  
    static{  
        System.out.println("测试在classpath以外的类");  
    }  
    public void say(){  
        System.out.println("我是在classpath以外的类");  
    }  
}  

加载这个类：

[java]view plaincopy
@Test  
public void testDiffLoader() throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {  
    MyClassLoader myLoader = new MyClassLoader("D:/");  
      
      
    Class<?> clazz = myLoader.loadClass("com.lyz.classloader.test.ClassOutOfClasspath");  
    Class<?> clazz1 = myLoader.loadClass("com.lyz.classloader.test.ClassOutOfClasspath");  
    System.out.println(clazz == clazz1);  
    System.out.println(clazz.getClassLoader());  
    System.out.println(clazz1.getClassLoader());  
      
    System.out.println("================");  
      
    MyClassLoader myLoader1 = new MyClassLoader("D:/");  
    Class<?> clazz2 = myLoader1.loadClass("com.lyz.classloader.test.ClassOutOfClasspath");  
    System.out.println(clazz2 == clazz1 );  
    System.out.println(clazz2.getClassLoader());  
      
    System.out.println("================");  
      
    Object newInstance = clazz.newInstance();  
    Method declaredMethod = clazz.getDeclaredMethod("say", new Class[]{});  
    declaredMethod.invoke(newInstance, new Object[]{});  
}  

输出结果如下：

[plain]view plaincopy
加载com.lyz.classloader.test.ClassOutOfClasspath  
true  
com.lyz.classloader.test.MyClassLoader@5010be6  
com.lyz.classloader.test.MyClassLoader@5010be6  
================  
加载com.lyz.classloader.test.ClassOutOfClasspath  
false  
com.lyz.classloader.test.MyClassLoader@7daf6ecc  
================  
测试在classpath以外的类  
我是在classpath以外的类  

从输出我们看到，这次的加载不是父类加载器加载的，因为这个类并不在AppClassLoader的加载范围之内。我们使用myLoader加载了两次ClassOutOfClasspath类，从输出结果我们看到这两次加载的结果是一致的。因为我们使用了同一个类加载器myLoader,然后我们用myLoader1重新加载一次ClassOutOfClasspath类，这次输出和前两次输出的结果是不一样的。也就是说这次加载和前两次加载得到的class对象是不一样的。
tomcat也自定义了类加载器。每个部署的tomcat下的项目都使用不同的类加载器来加载，所以项目与项目之间的类是不可共用的。这也是自定义类加载器的用处之一。其实tomcat中的类加载器分为
1：catalina加载器
2：公共类加载器
3：分享类加载器
对tomcat类加载器有兴趣的同学，可以深入看一下tomcat源码。