类加载器

概述

public abstract class ClassLoader

extends Object

类加载器是负责加载类的对象。ClassLoader 类是一个抽象类。如果给定类的二进制名称，那么类加载器会试图查找或生成构成类定义的数据。一般策略是将名称转换为某个文件名，然后从文件系统读取该名称的“类文件”。

所谓类加载器，顾名思义，就是加载类的工具，它的作用是将Java的字节码文件加载到内存中

JVM中可以安装多个类加载器，系统默认的有三个类加载器，

BootStrap,ExtClassLoader,AppClassLoader

ExtClassLoader与AppClassLoader都是一个java类，所以必须有一个类加载器来加载这两个类加载器，正是BootStrap

类加载器的委托机制

JVM中所有的类加载器采用具有父子关系的树状结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。

当Java虚拟机要加载一个类时，究竟会用哪一个类加载器去加载？

首先当前线程的类加载器去加载线程中的第一个类。

如果类A中引用了类B，Java虚拟机将使用加载类A的类加载器来加载类B。

还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。

每个类加载器加载类时，又先委托给其上级类加载器。

当所有父类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException异常

由于这个机制，最好将有继承关系的一些类字节码文件放到同一级目录下，确保加载A类的加载器，不会因为找不到与之相关的B类而报错

类加载器之间的父子关系和管辖范围图

下面看一个例子

public static void main(String[] args) {

    //自己定义的类存放在classpath中，所以由appClassLoader来加载
    ClassLoader cl = ClassLoaderTest.class.getClassLoader();
    while(cl != null){
        System.out.println(cl.getClass().getName());
        cl = cl.getParent();
    }

    //由于这些系统lib中的类是由BootStrap加载的，它并不是一个类，所以无法获取ClassLoader
    System.out.println(System.class.getClassLoader());
    System.out.println(Date.class.getClassLoader());
}

定义自己的类加载器

ClassLoader类实现了将硬盘的字节码文件分析其结构，并加载到内存的操作

其中有两个方法

loadClass与findClass

loadClass()封装了前面提到的委托模式的实现。该方法会首先调用 findLoadedClass()方法来检查该类是否已经被加载过；如果没有加载过的话，会调用父类加载器的 loadClass()方法来尝试加载该类；如果父类加载器无法加载该类的话，就调用 findClass()方法来查找该类。因此，为了保证类加载器都正确实现代理模式，在开发自己的类加载器时，最好不要覆写 loadClass()方法，而是覆写 findClass()方法。

findClass()方法首先根据类的全名在硬盘上查找类的字节代码文件（.class 文件），然后读取该文件内容，最后通过 defineClass()方法来把这些字节代码转换成 java.lang.Class类的实例。

这其实是利用的模板设计方法，ClassLoader将写好的委托模式代码放在loadClass中，而具体的加载的过程代码放在findClass中，由子类自行定义

在定义自己的类加载器的时候，我们还可以实现对字节码文件的加密解密操作

首先，先定义自己的加密器

/**
 * @author Shawn
 * 加密器
 */
public class Encipher {
    private String myLibDir;
    private String srcDir;
    private int encryCode = 0xff;

    public Encipher(String myLibDir, String srcDir) {
        super();
        this.myLibDir = myLibDir;
        this.srcDir = srcDir;
    }

    //加密，并将加密后的文件放入自己的libDir中
    public void encipher(String name) throws Exception{
        buildEntryLibDir(name);
        String encryFile = classNameToPath(myLibDir, name);
        String srcFile = classNameToPath(srcDir,name);

        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(encryFile);

        int b = -1;
        while( ( b = fis.read()) != -1){
            fos.write(b ^ encryCode);
        }

        fis.close();
        fos.close();
    }

    private String classNameToPath(String dir,String className) {
        return dir + File.separatorChar
                + className.replace('.', File.separatorChar) + ".class";
    }

    private void buildEntryLibDir(String className){
        String path =  myLibDir + File.separatorChar + className.substring(
                0,
                className.lastIndexOf("."));
        File libDir = new File(path);
        if(!libDir.exists())
            libDir.mkdirs();
    }
}

接下来，对已经写好一个测试类进行加密

public class Code {

    @Override
    public String toString(){
        return "Hello,world!";
    }
}

public class ClassLoaderTest2 {

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        String myLibDir = "D:";
        String srcDir = "bin";
        Encipher en = new Encipher(myLibDir,srcDir);
        en.encipher("classloader.Code");
    }
}

这个时候，如果将自己lib下的Code.class文件覆盖到原来目录，那么编译器就会报错

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
    Code cannot be resolved to a type

说明此类已经不能用JVM自己的类加载器解析了

好了，现在定义自己的类加载器

public class MyClassLoader extends ClassLoader {

    //类加载器需要加载的类文件存放目录
    private String rootDir;

    public MyClassLoader(String rootDir) {
        super();
        this.rootDir = rootDir;
    }


    //重写Classloader中findClass方法
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException{
        byte[] b = getBytes(name);
        if(b == null)
            throw new ClassNotFoundException();
        else
            //将读到的数据转为字节码对象，并返回
            return defineClass(name,b, 0, b.length);
    }

    private byte[] getBytes(String name) {
        String fileName = classNameToPath(name,rootDir);
        //定义字节数组流，将读到的数据写到字节数组中
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        FileInputStream fis = null;

        try {
            fis = new FileInputStream(fileName);

            int b = -1;
            while((b = fis.read()) != -1){
                baos.write(b^0xff);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return baos.toByteArray();
    }

    //将带有包名的className转为路径
    private String classNameToPath(String className,String dir) {
        return dir + File.separatorChar
                + className.replace('.', File.separatorChar) + ".class";
    }
}

这个时候，只要将原来目录的Code.class文件删除，确保JVM自己的类加载器找不到这个类，我们就可以做下面的测试，自己加载自己的类了

public class ClassLoaderTest2 {

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        String myLibDir = "D:";

        MyClassLoader mcl = new MyClassLoader(myLibDir);
        Class cls = mcl.loadClass("classloader.Code");
        System.out.println(cls.newInstance());
    }
}