JVM 自定义的类加载器的实现和使用

1、用户自定义的类加载器：

要创建用户自己的类加载器，只需要扩展java.lang.ClassLoader类，然后覆盖它的findClass(String name)方法即可，该方法根据参数指定类的名字，返回对应的Class对象的引用。

findClass

protected Class<?> findClass(String name)

                      throws ClassNotFoundException

使用指定的二进制名称查找类。此方法应该被类加载器的实现重写，该实现按照委托模型来加载类。在通过父类加载器检查所请求的类后，此方法将被 loadClass 方法调用。默认实现抛出一个 ClassNotFoundException。

参数：

name - 类的二进制名称

返回：

得到的 Class 对象

抛出：

ClassNotFoundException - 如果无法找到类

从以下版本开始：

1.2

创建用户自定义的类加载器：

public class MyClassLoader extends ClassLoader {



    //类加载器名称

    private String name;

    //加载类的路径

    private String path = "D:/";

    private final String fileType = ".class";

    public MyClassLoader(String name){

        //让系统类加载器成为该 类加载器的父加载器

        super();

        this.name = name;

    }



    public MyClassLoader(ClassLoader parent, String name){

        //显示指定该类加载器的父加载器

        super(parent);

        this.name = name;

    }



    public String getPath() {

        return path;

    }



    public void setPath(String path) {

        this.path = path;

    }



    @Override

    public String toString() {

        return this.name;

    }



    /**

     * 获取.class文件的字节数组

     * @param name

     * @return

     */

    private byte[] loaderClassData(String name){

        InputStream is = null;

        byte[] data = null;

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        this.name = this.name.replace(".", "/");

        try {

            is = new FileInputStream(new File(path + name + fileType));

            int c = 0;

            while(-1 != (c = is.read())){

                baos.write(c);

            }

            data = baos.toByteArray();



        } catch (Exception e) {

            e.printStackTrace();

        } finally{

            try {

                is.close();

                baos.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

        return data;

    }



    /**

     * 获取Class对象

     */

    @Override

    public Class<?> findClass(String name){

        byte[] data = loaderClassData(name);

        return this.defineClass(name, data, 0, data.length);

    }



    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {

        //loader1的父加载器为系统类加载器

        MyClassLoader loader1 = new MyClassLoader("loader1");

        loader1.setPath("D:/lib1/");

        //loader2的父加载器为loader1

        MyClassLoader loader2 = new MyClassLoader(loader1, "loader2");

        loader2.setPath("D:/lib2/");

        //loader3的父加载器为根类加载器

        MyClassLoader loader3 = new MyClassLoader(null, "loader3");

        loader3.setPath("D:/lib3/");



        Class clazz = loader2.loadClass("Sample");

        Object object = clazz.newInstance();

    }

}

public class Sample {



    public Sample(){

        System.out.println("Sample is loaded by " + this.getClass().getClassLoader());

        new A();

    }

}

public class A {



    public A(){

        System.out.println("A is loaded by " + this.getClass().getClassLoader());

    }

}

当执行loader2.loaderClass("Sample")时，先由它上层的所有父加载器尝试加载Sample类。loader1从D:/lib1/目录下成功的加载了Sample类，因此laoder1是Sample类的定义类加载器，loader1和loader2是Sample类的初始类加载器。

当执行loader3.loadClass("Sample")时，先由它上层的所有父加载器尝试加载Sample类。loader3的父加载器为根类加载器，它无法加载Sample类，接着loader3从D:/lib3/目录下成功地加载了Sample类，因此loader3是Sample类的定义类加载器即初始类加载器。

在Sample类中主动使用了A类，当执行Sample类的构造方法中的new A()语句时，Java虚拟机需要先加载Dog类，Java虚拟机会勇Sample类的定义类加载器去加载Dog类，加载过程也同样采用父亲委托机制。

2、不同类加载器的命名空间关系：

同一个命名空间内的类是相互可见的。

子加载器的命名空间包含所有父加载器的命名空间。因此子加载器加载的类能看见父加载器加载的类。例如系统类加载器加载的类能看见根类加载器加载的类。

由父加载器加载的类不能看见子加载器加载的类。

如果两个加载器之间没有直接或间接的父子关系，那么它们各自加载的类相互不可见。

当两个不同命名空间内的类相互不可见时，可以采用Java的反射机制来访问实例的属性和方法。

转载自：http://www.itzhai.com/java-virtual-machine-notes-custom-class-loader-implementation-and-use-of.html