自定义的ClassLoader

为什么要自定义ClassLoader

       java的系统提供了3种类加载器：启动类加载器(Bootstrap ClassLoader)、扩展类加载器(Extendsion ClassLoader)、应用程序类加载器(Application ClassLoader)。他们分别加载 java核心类库、\lib\ext目录下的扩展类库、用户类路径(CLASSPATH)下的类库。我们所写的Java代码通过编译器编译为字节码，然后由虚拟机载入执行，这个载入就是通过应用程序类加载器加载。类加载器的作用就是读取字节码文件，并把文件数据翻译为JVM方法区中存放的class信息。
       系统给定的这三个类加载器有具体的分工，加载的类路径也是确定的，如果我们需要动态加载不在这几个路径下的类，显然这几个类加载器无法完成。同时，如果我们要加载的类文件存放在远程服务器，那么为了数据的安全，可能存放的类的数据是经过加密的，也就是这不是标准的class文件，那么我们也需要自定义ClassLoader来加载这些类文件。
 

ClassLoader类

       除了BoostrapClassLoader，其他ClassLoader都是继承java.lang.ClassLoader抽象类，我们先研究一下这个抽象类。几个比较重要的方法：

1. loadClass(String name)，这个方法在加载类的时候会自动调用，源码如下，比较简单，也是双亲委派模型的实现。

    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;
        }
    }

2. findClass(String name)，在上面的方法中我们看到在Bootstrap和父加载器都没有加载到需要的类的时候，会通过findClass这个方法去加载我们需要的类，我们看到ClassLoader这个方法的源码的实现只抛出了个异常，也就是我们要自定义类加载器的时候需要重写这个方法。

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

3. defineClass(String name, byte[] b, int off, int len)，这个方法已经由ClassLoader实现并且声明为final，不可修改，主要把加载的二进制数据转化为jvm中的class对象数据。底层由native方法实现。

    protected final Class<?> defineClass(String name, byte[] b, int off, int len)
        throws ClassFormatError
    {
        return defineClass(name, b, off, len, null);
    }

    protected final Class<?> defineClass(String name, byte[] b, int off, int len,
                                         ProtectionDomain protectionDomain)
        throws ClassFormatError
    {
        protectionDomain = preDefineClass(name, protectionDomain);
        String source = defineClassSourceLocation(protectionDomain);
        Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
        postDefineClass(c, protectionDomain);
        return c;
    }

    private native Class<?> defineClass1(String name, byte[] b, int off, int len,
                                         ProtectionDomain pd, String source);

 

动手实现MyClassLoader

       分析完毕，我们就可以入手继承ClassLoder实现我们自己的类加载器。我们这里实现一个在指定文件夹下加载类的类加载器，代码如下:

public class MyClassLoader extends ClassLoader {

    private String loadPath;
    private static final String suffix = ".class";

    public MyClassLoader(String loadPath) {
        File file = new File(loadPath);
        try {
            this.loadPath = file.getCanonicalPath() + "\\";
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

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

    // 读取类文件数据
    private byte[] getClassData(String name) {
        String fileName = loadPath + name + suffix;
        InputStream is;
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        int b;
        try {
            is = new FileInputStream(fileName);
            while ((b = is.read()) != -1) {
                os.write(b);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return os.toByteArray();
    }

}

 

在D:/tmp 文件夹下编写TClass.java并编译

在主类路径下的类会被系统的应用程序类加载器加载，不能达到目的，所以选择去其他目录编译一个class文件。当然也可以直接重写loadClass方法避开双亲委派机制。

public class TClass {
    public void sayHello() {
        System.out.println("Hello word from TClass !!");
    }

    public void printClassLoaderName() {
        System.out.println(TClass.class.getClassLoader().getClass().getSimpleName());
    }
}

javac TClass.java
 

测试

public class Main {
    public static void main(String[] args) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName("TClass", true,new MyClassLoader("D:\\tmp\\"));
            Object o = clazz.newInstance();
            Method[] methods = clazz.getDeclaredMethods();
            for(Method method: methods) {
                System.out.println("execute method: " + method.getName());
                method.invoke(o);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}

测试结果

execute method: printClassLoaderName
MyClassLoader
execute method: sayHello
Hello word from TClass !!