自定义ClassLoader案例

首先说明,本文是参考《Java高并发编程详解》一书总结的。

所有自定义的类加载器都是ClassLoader的直接或间接子类,此类中并没有抽象方法,但是有findClass方法,这个一定要实现,不然会抛异常:

protected Class findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }

自定义类加载器:

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class MyClassLoader extends ClassLoader {

    //自定义默认的class存放路径
    private final static Path DEFAULT_CLASS_DIR = Paths.get("E:","classloader1");

    private final Path classDir;

    //使用默认的class路径
    public MyClassLoader(){
        super();
        this.classDir = DEFAULT_CLASS_DIR;
    }

    //允许传入指定路径的class路径
    public MyClassLoader(String classDir){
        super();
        this.classDir = Paths.get(classDir);
    }

    //指定class路径的同时,指定父类加载器
    public MyClassLoader(String classDir,ClassLoader parent){
        super(parent);
        this.classDir = Paths.get(classDir);
    }

    //重写父类方法,这是至关重要的步骤
    @Override
    protected Class findClass(String name) throws ClassNotFoundException {
        //读取class的二进制数据
        byte[] classBytes = this.readClassBytes(name);
        if(null == classBytes || classBytes.length == 0){
            throw new ClassNotFoundException("can not load the class "+name);
        }
        //调用defineclass方法定义class
        return this.defineClass(name,classBytes,0,classBytes.length);
    }

    //将class文件读入内存
    private byte[] readClassBytes(String name) throws ClassNotFoundException {
        //将包名分隔符转换为文件路径分隔符
        String classPath = name.replace(".", "/");
        Path classFullPath = classDir.resolve(Paths.get(classPath + ".class"));
        if(!classFullPath.toFile().exists()){
            throw new ClassNotFoundException("the class "+name+" not found");
        }
        try(ByteArrayOutputStream baos = new ByteArrayOutputStream()){
            Files.copy(classFullPath,baos);
            return baos.toByteArray();
        }catch (IOException e){
            throw new ClassNotFoundException("load the class "+name+" occur error",e);
        }
    }

    @Override
    public String toString() {
        return "my classloader";
    }
}

此函数包括三个构造函数,第一个使用默认的文件路径,第二个允许外部指定一个特定的磁盘目录,第三个还可以指定该类加载类的父加载器。

这里需要强调一个defineClass方法,该方法的完整描述是

defineClass(String name, byte[] b, int off, int len)

其中第一个是要定义类的名字,一般与findClass方法中的类名保持一致即可,第二个是class文件的二进制字节数组,第三个是字节数组的偏移量,第四个是从偏移量开始读取多长的byte数据。在类的加载过程中,第一个阶段的加载主要是获取class的字节流信息,而这里在将字节数组传递后还指定了偏移量和读取长度,这是为什么呢?原因就是因为class字节数组不一定是从一个class文件中获取的,有可能来自网络,也有可能是用编程的方式写入的,所有说,一个字节数组有可能存储多个class的字节信息。

下面写一个简单的程序,使用自定义的加载器进行加载

public class HelloWorld {
    static {
        System.out.println("HelloWorld class is initialized");
    }

    public String welcome() {
        return "hello world";
    }
}

Java文件编译后,将class文件复制到自定义的类加载器中设置的目录下,同时在程序运行的class patch中删除掉HelloWorld这个class,IDE测试的话,对应的Java类也要一并删除,否则测试类将会被系统类加载器加载

编写测试类:

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MyClassLoaderTest {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //声明自定义的class loader
        MyClassLoader classLoader = new MyClassLoader();

        Class aClass = classLoader.loadClass("thread.classloader.HelloWorld");
        System.out.println(aClass.getClassLoader());
        System.out.println(aClass.getClassLoader().getParent());

        //注释此代码后,静态代码块没有输出,因为类加载器loadclass并不会导致类的主动初始化
        Object hello = aClass.newInstance();
        System.out.println(hello);
        Method welcome = aClass.getMethod("welcome");
        String result = (String) welcome.invoke(hello);
        System.out.println(result);
    }
}

注释中的信息说明,使用类加载器loadClass并不会导致类的主动初始化,它只是执行了加载过程中的加载阶段而已。

思考:如何不删除HelloWorld.java文件又可以使用自定义类加载器加载呢?

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 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
                    // 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();
                    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;
        }
    }

这是jdk中的loadClass源码,分析可知:

  1. 从当前类加载器的已加载类缓存中根据类的全路径名查询是否存在,存在即返回。
  2. 如果当前类存在父类加载器,则调用父类loadClass(name,false)方法对其进行加载。
  3. 如果当前类加载器不存在父类加载器,直接调用根类加载器进行加载。
  4. 如果当前类的所有父类加载器都没有成功加载class,尝试调用当前类加载器的findClass方法对其进行加载,该方法就是我们自定义加载器需要重写的方法。
  5. 最后如果类被成功加载,做一些性能数据的统计。
  6. 由于loadClass指定了resolve为false,所以不会进行连接阶段的继续执行,不会导致类的初始化。

 解答:

第一种方式是绕过系统类加载器,直接将扩展类加载器作用MyClassLoader的父类加载器:

        ClassLoader extClassLoader = MyClassLoaderTest.class.getClassLoader().getParent();
        MyClassLoader loader = new MyClassLoader("E:\\classloader1", extClassLoader);
        loader.loadClass("thread.classloader.HelloWorld");

首先获取到系统类加载器,然后再获取系统类加载器的父类加载器中扩展类加载器,使其成为MyClassLoader的父类加载器,这样,根加载器和扩展类加载器都无法对E:\\classloader1中的类文件进行加载,自然就交给MyClassLoader对HelloWorld进行加载了。

第二种方式是在构造MyClassLoader的时候指定其父类加载器为null:

        MyClassLoader loader = new MyClassLoader("E:\\classloader1", null);
        loader.loadClass("thread.classloader.HelloWorld");

当前类在没有父类加载器的情况下,会直接使用根加载器对该类进行加载,但是HelloWorld在根加载器的加载路径下是无法找到的,那么就只能交给当前类加载器进行加载了。

你可能感兴趣的:(代码片段,classloader)