类加载器

JVM预定义的三种类型类加载器：

启动（Bootstrap）类加载器：

是用native实现的类装入器，它负责将  <Java_Runtime_Home>/lib 下面的类库加载到内存中（比如 rt.jar ）。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作。

标准扩展（Extension）类加载器：

是由 Sun 的  ExtClassLoader（sun.misc.Launcher$ExtClassLoader） 实现的。它负责将 < Java_Runtime_Home >/lib/ext 或者由系统变量  java.ext.dir 指定位置中的类库加载到内存中。开发者可以直接使用标准扩展类加载器。

系统（System）类加载器：

是由 Sun 的  AppClassLoader（sun.misc.Launcher$AppClassLoader） 实现的。它负责将系统类路径（ CLASSPATH ）中指定的类库加载到内存中。开发者可以直接使用系统类加载器。

除了以上列举的三种类加载器，还有一种比较特殊的类型 — 线程上下文类加载器。

双亲委派机制
某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。

理解：

Java虚拟机的第一个类加载器是Bootstrap，这个加载器很特殊，它不是Java类，因此它不需要被别人加载，它嵌套在Java虚拟机内核里面，也就是JVM启动的时候Bootstrap就已经启动，它是用C++写的二进制代码（不是字节码），它可以去加载别的类。这也是我们在测试时为什么发现System.class.getClassLoader()结果为null的原因，这并不表示System这个类没有类加载器，而是它的加载器比较特殊，是BootstrapClassLoader，由于它不是Java类，因此获得它的引用肯定返回null。

委托机制具体含义 ：

当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？

首先当前线程的类加载器去加载线程中的第一个类（假设为类A）。 
注：当前线程的类加载器可以通过Thread类的getContextClassLoader()获得，也可以通过setContextClassLoader()自己设置类加载器。

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

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

委托机制的意义： 防止内存中出现多份同样的字节码。

比如两个类A和类B都要加载System类：

如果不用委托而是自己加载自己的，那么类A就会加载一份System字节码，然后类B又会加载一份System字节码，这样内存中就出现了两份System字节码。

如果使用委托机制，会递归的向父类查找，也就是首选用Bootstrap尝试加载，如果找不到再向下。这里的System就能在Bootstrap中找到然后加载，如果此时类B也要加载System，也从Bootstrap开始，此时Bootstrap发现已经加载过了System那么直接返回内存中的System即可而不需要重新加载，这样内存中就只有一份System的字节码了。

自定义类加载器

虽然在绝大多数情况下系统默认提供的类加载器实现已经可以满足需求。但是在某些情况下，您还是需要为应用开发出自己的类加载器。 比如你的应用通过网络来传输 Java 类的字节代码，为了保证安全性，这些字节码经过了加密处理。这个时候您就需要自己的类加载器来从某个网络地址上读取加密后的字节代码，接着进行解密和验证，最后定义出要在 Java 虚拟机中运行的类来。

通过继承ClassLoader类来实现自定义类加载器，首先要知道ClassLoader加载类的顺序，如下：

1）调用findLoadedClass(String) 来检查是否已经加载类

2）在父类加载器上调用loadClass方法。如果父亲不能加载，一次一级一级传给子类

3）调用子类findClass(String) 方法查找类

自定义类加载器通常有以下几种方式：

1、只重写findClass(String)：

使用父类的 loadClass(String)，依旧使用双亲委派机制，如果父类可以加载该类，则会直接在父类中得到加载，这时子类的findClass方法得不到执行，也就是说，如果父类能够加载该类，则自定义的加载器不起作用，比如，在bin目录下存在一个类A.class，则当我们调用loadClass(A)时，A可以在父加载器中得到加载，这时自定义加载器不起作用，怎样使其起作用呢？首先A.java文件要删掉，否则总会存在A.class文件，可以把A.java放到别的项目中，把生成的A.class拷贝到测试的工程的bin下，注意包名要一致，然后把后缀改成如myclass等，这时父加载器找不到可以加载的类（因为它默认找的是.class文件），这时自定义的类加载器会起作用，也即findClass方法会被执行。该方式最常见的一个应用是，通过网络接收一个class文件，然后动态加载该文件，保存class文件时名字要与class的类名一致，保存的位置要与class所在的包名一致。

2、重写 findClass(String)和 loadClass(String)：

该方式可以打破双亲委派机制，但一个加载器即使有多个实例，这些实例加载同一个类是只能加载一次，也就是说，如果实例1加载了某个类，则实例2再去加载这个类的时候， findLoadedClass返回非null，也就是发现该类已经加载过了，所以，虽然打破双亲委派，但还是无法多次加载同一个类。

3、在第2种的基础上进一步重写 defineClass和findLoadedClass：

该方式可以对同一个类加载多次。

例子：

例1：只重写findClass(String)

1、在别的项目中编写一个将要被加载的测试类：

package   testClass;

public   class   Animal {

     private   static   int   num =  0 ;

     public   void   say(String name){

         num++;

         System.out.println(name+ ":" +num);

     }

}

把编译后的class文件拷贝到当前项目的bin目录下的对应的包中， 把后缀名改成myclass

2、自定义类加载器

package   classLoader;

import   java.io.ByteArrayOutputStream;

import   java.io.File;

import   java.io.FileInputStream;

public   class   MyClassLoader  extends   ClassLoader {

     // 被加载的类存放的路径

     private   String path = MyClassLoader.getSystemClassLoader().getResource( "" ).getPath();

     @Override

     public   Class<?> findClass(String name) {

         System.out.println( "重写的findClass..." );

         byte [] data = loadClassData(name);

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

     }

     public   byte [] loadClassData(String name) {

         try   {

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

             FileInputStream is =  new   FileInputStream( new   File(path + name +  ".myclass" ));

             ByteArrayOutputStream baos =  new   ByteArrayOutputStream();

             int   b =  0 ;

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

                 baos.write(b);

             }

             return   baos.toByteArray();

         }  catch   (Exception e) {}

         return   null ;

     }

}

3、测试

package   classLoader;

import   java.lang.reflect.Method;

public   class   ClassLoaderTest {

     public   static   void   main(String[] args)  throws   Exception {

         MyClassLoader c1 =  new   MyClassLoader();

         Class<?> clazz = c1.loadClass( "testClass.Animal" );

         Object animal = clazz.newInstance();

         Method sayMethod = clazz.getMethod( "say" ,  new   Class[]{String. class });

         sayMethod.invoke(animal,  new   Object[]{ "wudiyong" });

         Class<?> clazz2 = c1.loadClass( "testClass.Animal" );

         Object animal2 = clazz2.newInstance();

         Method sayMethod2 = clazz2.getMethod( "say" ,  new   Class[]{String. class });

         sayMethod2.invoke(animal2,  new   Object[]{ "wudiyong" });

     }

}

输出：

重写的findClass...

wudiyong:1

wudiyong:2

如果把 Class<?> clazz2 = c1.loadClass( "testClass.Animal" );改成

MyClassLoader c2 =  new   MyClassLoader();

Class<?> clazz2 = c2.loadClass( "testClass.Animal" );

则输出：

重写的findClass...

wudiyong:1

重写的findClass...

wudiyong:1

可见，同一个类加载器多次加载同一个类，最终都只会加载一次，不同的类加载器加载同一个类，会加载多次。加载一次不代表只有一个实例，每newInstance一次就生成一个实例，但是静态变量属于类的，所以与加载的次数有关。

注意：

如果Animal类后缀名不改变，还是用.class，则自定义的类加载器中的findClass不会被执行，因为父加载器直接加载了Animal类，这时上面两种情况中Animal都只加载一次。同理，如果要想用上面的自定义类加载器来加载本工程中的类，总会被父加载器加载从而自定义的加载器没有效果，可以通过重写loadClass方法来破坏双亲委派机制，如例2。当然，如果不在乎哪个加载器起作用，只要能加载便可，用例1的方式最好不过了。

例2：重写findClass(String)和loadClass(String)

1、Animal类与例1相同，不过可以不用修改后缀名，因为这里重写了loadClass方法。

2、自定义类加载器

package   classLoader;

import   java.io.ByteArrayOutputStream;

import   java.io.File;

import   java.io.FileInputStream;

public   class   MyClassLoader  extends   ClassLoader {

     // 被加载的类存放的路径

     private   String path = MyClassLoader.getSystemClassLoader().getResource( "" ).getPath();

     @Override

     public   Class<?> findClass(String name) {

         System.out.println( "重写的findClass..." );

         byte [] data = loadClassData(name);

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

     }

     @Override

     public   Class<?> loadClass(String name) {

         /*

          * 这里不可省，因为loadClass会被执行两次，两次的参数不一样

          */

         if   (name.startsWith( "java." )) {

             try   {

                 return   super .loadClass(name,  false );

             }  catch   (ClassNotFoundException e) {}

         }

         /*

          * 用于查找是否已加载过了，一个类加载器如果重复加载同一个类会在调用defineClass方法时报错：

          * attempted duplicate class definition

          */

         Class<?> c = findLoadedClass(name);

         if   (c ==  null ) {

             c = findClass(name);

         }

         return   c;

     }

     public   byte [] loadClassData(String name) {

         try   {

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

             FileInputStream is =  new   FileInputStream( new   File(path + name +  ".class" ));

             ByteArrayOutputStream baos =  new   ByteArrayOutputStream();

             int   b =  0 ;

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

                 baos.write(b);

             }

             return   baos.toByteArray();

         }  catch   (Exception e) {

            return null;

        }

         return   null ;

     }

}

3、测试代码与例1一样，输出的结果也一样。

当然，也可以不重写findClass方法，把该方法的实现代码放到loadClass中便可。

例2中同一个类加载器多次加载同一个类也只会加载一次，如果希望加载多次，还需要重写defineClass、findLoadedClass等这些父类中的方法。

方式3这里不做说明，以后再研究。

能不能自己写个类叫java.lang.System？

答案：通常不可以，但可以采取另类方法达到这个需求。 

解释：为了不让我们写System类，类加载采用委托机制，这样可以保证爸爸们优先，爸爸们能找到的类，儿子就没有机会加载。而System类是Bootstrap加载器加载的，就算自己重写，也总是使用Java系统提供的System，自己写的System类根本没有机会得到加载。 但是，我们可以 自己定义一个类加载器来达到这个目的 ，为了避免双亲委托机制，这个类加载器也必须是特殊的，需要重写loadClass方法。由于系统自带的三个类加载器都加载特定目录下的类，如果我们自己的类加载器放在一个特殊的目录，那么系统的加载器就无法加载，也就是最终还是由我们自己的加载器加载。

版权声明：本文为博主原创文章，未经博主允许不得转载。