ClassLoader 的相关介绍，classloader

ClassLoader 的相关介绍，classloader

1.ClassLoader

        类加载器(ClassLoader)用来加载JAVA类到JAVA虚拟机中。JAVA源程序（.java文件）在经过JAVA编译器编译之后就被转换成JAVA字节码（.class文件）。类加载器负责读取JAVA字节代码，并转换成java.lang.Class类的一个实例。

2.ClassLoader Hierarchy

        JVM在加载类时，使用的是双亲委托模式（delegation model），也就是说除了Bootstrap ClassLoader之外，每个ClassLoader都有一个Parent ClassLoader。ClassLoader是按需进行加载class文件。当ClassLoader试图加载一个类时，首先检查本地缓冲，查看类是否已被加载，如果类没被加载，尝试委托给父ClassLoader进行加载，如果父ClassLoader加载失败，才会由该ClassLoader进行加载，从而避免了重复加载的问题，以下为类装载器层次图：

 

Bootstrap ClassLoader：负责加载java_home/lib目录下的核心类或-Xbootclasspath指定目录下的类

Extension ClassLoader：负责加载java_home/lib/ext目录下的扩展类或-Djava.ext.dirs指定目录下的类。

System ClassLoader：负责加载-classpath/-Djava.class.path所指的目录下的类。

如果类App1在本地缓冲中没有class文件(没有被加载)，那么它会自底向上依次检查是否已经加载了类，如果已经加载了，则直接返回该类实例的引用。如果BootstrapClassLoader也未成功加载该类，那么会抛出异常，然后自顶向下依次尝试加载，如果到了App1 ClassLoader还没有加载成功，那么会抛出ClassNotFoundException异常给调用者。

             JAVA代码：

1. public static void main(String[] args) {  
2.         ClassLoader cl = ClassLoader.getSystemClassLoader();  
3.         while(cl != null){  
4.             System.out.println(cl);  
5.             System.out.println("parent class loader: " + cl.getParent());  
6.             cl = cl.getParent();  
7.         }  
8.     }  

输出代码：

 

1. sun.misc.Launcher$AppClassLoader@19821f  
2. parent class loader: sun.misc.Launcher$ExtClassLoader@addbf1  
3. sun.misc.Launcher$ExtClassLoader@addbf1  
4. parent class loader: null  

 

             我们看到，当前系统类加载器为AppClassLoader，AppClassLoader的父类装载器是ExtClassLoader，ExtClassLoader的父装载器为null，表示为BootstrapClassLoader。BootstrapClassLoader由JVM采用本地代码实现，因此没有对应的JAVA类，所以ExtClassLoader的getParent()返回null。

             ClassLoader的职责之一是保护系统名字空间，以下为ClassLoader类部分代码：

             JAVA代码：

 

1. private ProtectionDomain preDefineClass(String name,  
2.                         ProtectionDomain protectionDomain)  
3.     {  
4.     if (!checkName(name))  
5.         throw new NoClassDefFoundError("IllegalName: " + name);  
6.   
7.     if ((name != null) && name.startsWith("java.")) {  
8.         throw new SecurityException("Prohibited package name: " +  
9.                     name.substring(0, name.lastIndexOf('.')));  
10.     }  
11.     if (protectionDomain == null) {  
12.         protectionDomain = getDefaultDomain();  
13.     }  
14.   
15.     if (name != null)  
16.         checkCerts(name, protectionDomain.getCodeSource());  
17.   
18.     return protectionDomain;  
19.     }  

             那么，当我们定义如下类Foo，虽然能够通过编译，但是会报java.lang.SecurityException:Prohibited package name:java.lang异常，因为我们试图将Foo类写入到java.lang包下。

             java代码：

 

1. package java.lang;  
2.   
3. public class Foo {  
4.       
5.     public static void main(String args[]) throws Exception {  
6.         Foo f = new Foo();  
7.         System.out.println(f.toString());  
8.     }  
9. }  

 3.定制ClassLoader

             java自带的ClassLoader类的定义为：

             java代码：

 

1. public abstract class ClassLoader{   
2. } 

             启动类加载器是JVM通过调用ClassLoader.loadClass()方法。

             JAVA代码：

 

1. public Class<?> loadClass(String name) throws ClassNotFoundException {  
2.     return loadClass(name, false);  
3.     }  
4.   
5. protected synchronized Class<?> loadClass(String name, boolean resolve)  
6.     throws ClassNotFoundException  
7.     {  
8.     // First, check if the class has already been loaded  
9.     Class c = findLoadedClass(name);  
10.     if (c == null) {  
11.         try {  
12.         if (parent != null) {  
13.             c = parent.loadClass(name, false);  
14.         } else {  
15.             c = findBootstrapClass0(name);  
16.         }  
17.         } catch (ClassNotFoundException e) {  
18.             // If still not found, then invoke findClass in order  
19.             // to find the class.  
20.             c = findClass(name);  
21.         }  
22.     }  
23.     if (resolve) {  
24.         resolveClass(c);  
25.     }  
26.     return c;  
27.     }  
28.   
29. protected Class<?> findClass(String name) throws ClassNotFoundException {  
30.     throw new ClassNotFoundException(name);  
31.     }  

             loadClass(String name,boolean resolve)方法中的resolve如果为true，表示分析这个Class对象，包括检查ClassLoader是否已经初始化等。loadClass(String name)在加载类之后不会对该类进行初始化，直到第一次使用该类时，才会对该类进行初始化。那么我们在制定ClassLoader的时候，通常只需要重写findClass(String name)方法。在findClass(String name)方法内，我们可以通过文件、网络（URL）等形式获取字节码，以下为获取字节码的方法：

             JAVA代码：

 

1. public InputStream getResourceAsStream(String name);  
2. public URL getResource(String name);  
3. public InputStream getResourceAsStream(String name);  
4. public Enumeration<URL> getResources(String name) throws IOException;  

 

             在取得字节码后，需要调用defineClass()方法将字节数组转换成Class对象，该方法签名如下：

             JAVA代码：

 

1. protected final Class<?> defineClass(String name, byte[] b, int off, int len,  
2.                      ProtectionDomain protectionDomain)  
3.     throws ClassFormatError  

 

            对于相同的类，JVM最多会载入一次。如果同一个class文件被不同的ClassLoader载入(定义)，那么载入后的两个类是完全不同的。

            JAVA代码：

 

1. public class Foo{  
2.     //  
3.     private static final AtomicInteger COUNTER = new AtomicInteger(0);  
4.   
5.     public Foo() {  
6.         System.out.println("counter: " + COUNTER.incrementAndGet());  
7.     }  
8.       
9.     public static void main(String args[]) throws Exception {  
10.         URL urls[] = new URL[]{new URL("file:/c:/")};  
11.         URLClassLoader ucl1 = new URLClassLoader(urls);  
12.         URLClassLoader ucl2 = new URLClassLoader(urls);  
13.         Class<?> c1 = ucl1.loadClass("Foo");  
14.         Class<?> c2 = ucl2.loadClass("Foo");  
15.         System.out.println(c1 == c2);  
16.         c1.newInstance();  
17.         c2.newInstance();  
18.     }  
19. }  

             以上程序需要保证Foo.calss文件不在classpath路径下。从而使AppClassLoader无法加载Foo.class

             输出结果：

 

1. false  
2. counter: 1  
3. counter: 1 

4.Web应用的ClassLoader

             绝大多数的EJB容器，Servlet容器等都会提供定制的ClassLoader，来实现特定的功能，但通常情况下，所有的servlet和filter使用一个ClassLoader。每个jsp都使用一个独立的ClassLoader。

5.隐式（implicit）和显式（explicit）的加载

              隐式加载：我们使用new关键字实例化一个类，就是隐式的加载了类。

              显式加载分为两种：

              java.lang.Class的forName()方法；

              java.lang.ClassLoader的loadClass()方法；

              Class.forName()方法有两个重载的版本：

 

1.  public static Class<?> forName(String className)   
2.                 throws ClassNotFoundException {  
3.         return forName0(className, true, ClassLoader.getCallerClassLoader());  
4.     }  
5.   
6. public static Class<?> forName(String name, boolean initialize,  
7.                    ClassLoader loader)  
8.         throws ClassNotFoundException 

可以看出，forName(String className)默认以true和ClassLoader.getCallerClassLoader()调用了三参数的重载方法。ClassLoader.getCallerClassLoader()表示以caller class loader加载类，并会初始化类(即静态变量会被初始化，静态初始化块中的代码也会被执行)。如果以false和ClassLoader.getCallerClassLoader()调用三参数的重载方法，表示加载后的类不会被初始化。

ClassLoader.loadClass()方法在类加载后，也同样不会初始化类。

6.两个异常(exception)

           NoClassDefFoundError：当JAVA源文件已编成.class文件，但是ClassLoader在运行期间搜寻路径load某个类时，没有找到.class文件则抛出这个异常。

           ClassNotFoundException：试图通过一个String变量来创建一个Class类时不成功则抛出这个异常。

7.自己创建ClassLoader

除了JVM自带的ClassLoader，我们还可以自己创建ClassLoader。

因为JVM自带的ClassLoader只是懂得从本地文件系统加载标准的java class文件，如果编写你自己的ClassLoader，你可以做到：

1、在执行非置信代码前，自动验证数字签字

2、动态地创建符合用户特定需要的定制化构建类

3、从特定的场所取得java class，例如数据库中等等

事实上当使用Applet的时候，就用到了特定的ClassLoader，因为这时需要从网络上加载javaclass，并且要检查相关的安全信息

当你决定创建你自己的ClassLoader时，需要继承java.lang.ClassLoader或者它的子类。在实例化每个ClassLoader对象时，需要指定一个父对象；如果没有指定的话，系统自动指定ClassLoader.getSystemClassLoader()为父对象，在java1.2后，javaclass的加载采用所谓的委托模式（delegation modle），当调用一个ClassLoader.loadClass()加载一个类的时候，将遵循以下的步骤：

1、检查这个类是否已经被加载进来了？

2、如果还没有加载，调用父对象加载该类

3、如果父对象无法加载，调用本对象的findClass()取得这个类。

所以当创建自己的classLoader时，只需要重载findClass()这个方法。