java classloader

本文主要分析：
1.classloader模型
2.自定义classloader实例


是么是classloader？
java中的class其实都是通过classloader来装载的。并且，只有当你使用该class的时候才会去装载，一个classloader只会装载同一个class一次。

classloader体系结构在三个方面对java沙箱起作用：
1）它防止恶意代码去干涉善意的代码。
2）它保护了被信任的类库的边界。
3）它将代码归入某个保护域，该类确定了代码可以进行哪些操作。

下面分别举例说明上述三点：
1.被不同类装载器装载的class，相当于在不同的环境当中，他们彼此不知道对方的存在。
看一段代码如下：

/**
 * 类TestClassloader1.java的实现描述：测试被不同classloader装载的类，彼此毫无干系
 * 
 * @author lq 2009-3-16 下午10:26:06
 */
public class TestClassloader1 {

    /**
     * @param args
     * @throws ClassNotFoundException
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws NoSuchFieldException 
     * @throws SecurityException 
     * @throws IllegalArgumentException 
     */
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException,
                                          IllegalAccessException, IllegalArgumentException, SecurityException, NoSuchFieldException {
        MyClassloader1 cl1 = new MyClassloader1();
        MyClassloader1 cl2 = new MyClassloader1();
        Class c1 = cl1.loadClass("TestMe");
        Class c2 = cl2.loadClass("TestMe");
        Object t1 =  c1.newInstance();
        t1.getClass().getField("i").setInt(t1, 100);
        Object t2 = c2.newInstance();
        System.out.println(t1.getClass().getField("i").getInt(t1));
        System.out.println(t2.getClass().getField("i").getInt(t2));
    }

}

/**
 * 
 * 类TestMe.java的实现描述：被装载的测试类
 * @author lq 2009-3-16 下午10:31:09
 */
public class TestMe {

    public static int i = 0;
}

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/**
 * 
 * 类MyClassloader1.java的实现描述：测试的classloader
 * @author lq 2009-3-16 下午11:08:29
 */
public class MyClassloader1 extends ClassLoader {

    public static final String drive    = "D:/";
    public static final String fileType = ".class";

    public Class findClass(String name) {
        byte[] data = loadClassData(name);
        return defineClass(name, data, 0, data.length);
    }

    public byte[] loadClassData(String name) {
        FileInputStream fis = null;
        byte[] data = null;
        try {
            fis = new FileInputStream(new File(drive + name + fileType));
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int ch = 0;
            while ((ch = fis.read()) != -1) {
                baos.write(ch);
            }
            data = baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return data;
    }

}

运行结果：
100
0
可以看出，实践已经论证了第一条理论。
当然，你运行java命令的时候，请把当前classpath下的TestMe.class删除。否则classloader将会先向上委派类路径的classloader去加载TestMe.class。这样的话，其实都是同一个classloader加载了你的TestMe.class,并且只加载了一次。


2.由于不同的classloader装载的类互相不能访问，所以说保护了被信任的类库的边界。

看一段代码：

public class TestClassloader1 {

    /**
     * @param args
     * @throws ClassNotFoundException
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws NoSuchFieldException
     * @throws SecurityException
     * @throws IllegalArgumentException
     */
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException,
                                          IllegalAccessException, IllegalArgumentException, SecurityException,
                                          NoSuchFieldException {
        MyClassloader1 cl1 = new MyClassloader1();
        MyClassloader1 cl2 = new MyClassloader1();

        Class c1 = cl1.loadClass("TestMe");
        TestMe t = (TestMe) c1.newInstance();
}
}

运行结果如下：
Exception in thread "main" java.lang.NoClassDefFoundError: TestMe
        at TestClassloader1.main(TestClassloader1.java:19)
可见被不同classloader加载的类是互相不可见的。

3.先看下classloader的体系结构
bootstrap classloader
        |
ext classloader
        |
classpath classloader
        |
uri classloader

从上图可以看出，java的classloader是一个树状结构，并且，加载class的过程是通过委派父classloader去装载的方式做到的。如果父classloader找不到该class，则该classloader试图自己去加载class。

可以把刚才的例子里的TestMe.class放到你的classpath中，然后在运行java命令，可以看到，打印的结果为：
100
100

再来看个这样做的好处：

贴段代码：

public class TestClassloader2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
       new Hello();

    }

}

package java.lang;

public class Hello {

}

运行结果：
Exception in thread "main" java.lang.SecurityException: Prohibited package name: java.lang
at java.lang.ClassLoader.preDefineClass(Unknown Source)
at java.lang.ClassLoader.defineClass(Unknown Source)
at java.security.SecureClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.defineClass(Unknown Source)
at java.net.URLClassLoader.access$100(Unknown Source)
at java.net.URLClassLoader$1.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClass(Unknown Source)
at java.lang.ClassLoader.loadClassInternal(Unknown Source)
at TestClassloader2.main(TestClassloader2.java:8)


由于通过双亲委派的机制，classloader会最先委派bootstrap classloader去装载java.lang.Hello.class，但是classloader安全管理下的class并没有Hello.class，安全审核通不过。结果就有了以上的结果。。。

总结：
灵活运用classloader会给大家带来意想不到的好处，比如JBOSS的classloader体系结构。