ClassLoader、loadClass方法，Class，forName方法

Java在需要使用类的时候，才会将类加载，Java的类加载是由类加载器来完成的。当在命令行模式下执行java XXX.class指令后，java运行程序会尝试找到JRE安装的所在目录，然后寻找jvm.dll(默认是在JRE目录下bin\client目录中)，接着启动JVM并进行初始化动作，产生Bootstrap Loader,Bootstrap Loader会加载Extended Loader，并设定Extende Loader的parent为Bootstrap Loader。接着Bootstrap Loader会加载System Loader，并将System Loader的parent设定为Extended Loader。
    Bootstrap Loader通常由C编写而成，Extended Loader是由Java编写而成，实际是对应于sun.misc.Launcher$ExtClassLoader(Launcher中的内部类).System Loader是由java编写而成，实际对你关于 sun.misc.Launcher$AppClassLoader(Launcher中的内部类)。
    Bootstrap Loader会搜索系统参数sun.boot.class.path中指定位置的类，默认是JRE所在目录的classes下的.class文件，或lib目录下.jar文件中（如tr.jar）的类并加载。可用System.getProperty(“sun.boot.class.path”)来显示sun.boot.class.path中指定的路径。
    Extended Loader是由Java编写而成，会搜索系统参数java.ext.dirs中指定位置的类，默认是JRE目录下的lib\ext\classes目录下的.class文件，或lib\ext目录下的.jar文件中的类并加载。
    System Loader是由java编写而成，会搜索系统参数java.class.path中指定位置的类，也就是Classpath所指定的路径，默认是当前工作路径下的.class文件。
    在加载类时，每个类加载器会先将加载类的任务交给其parent，如果parent找不到，再由自己负责加载。所以在加载类顺序为：Bootstrap Loader——》Extended Loader——》System Loader的顺序来寻找类，若都找不到，会抛出NoClassDefFoundError.
    类加载器在Java中是以java.lang.ClassLoader类型存在，每一个类被加载后，都会有一个Class的实例来代表，而每个Class的实例都会记得自己是由哪个ClassLoader加载的。可以由Class的getClassLoader()取得加载该类的ClassLoader，而从ClassLoader的getParent()方法可以取得自己的parent。

我们把test1文件放在D：\盘根目录下
例子： 
public class test1 {
public static void main(String args[]){
   test1 t=new test1();
   Class c=t.getClass();
   ClassLoader loader=c.getClassLoader();
   System.out.println(loader);
   System.out.println(loader.getParent());
   System.out.println(loader.getParent().getParent());
  
}
}
结果
sun.misc.Launcher$AppClassLoader@197d257
sun.misc.Launcher$ExtClassLoader@7259da
null
依次以Bootstrap Loader——》ExtClass Loader——》AppClass Loader的顺序来寻找类，由于前两者都找不到，最后在Classpath中找到了类并加载。此时，它的Classloader就是AppClassLoader,而其parent为ExtClassLoader,再parent为BootstrapLoader，由于BootStrapLoader是C语言写的，所以此处为null。

如果我们把test1.java放在lib\ext\classes下，结果如图

因为此时的class可在ExtClassLoader的设定路径下找到，所以会由ExtClassLoader来加载test1类，而其parent肯定为null了，再取parent报错了。

Class.forName()和classloader.loadClass()的比较

测试代码：
Test.java
package ying;

public class test {
static{
   System.out.println("静态代码块运行");
   int x=1;
}
public test(){
   System.out.println("构造方法运行");
}
}

 

Main.java
package ying;

public class main {
public static void main(String args[]) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
   //ClassLoader loader=test.class.getClassLoader();
   //可以用别的classloader来load其他类
   ClassLoader loader=main.class.getClassLoader();
   /*
   System.out.println("before load");
   Class c=loader.loadClass("ying.test"); 
   System.out.println("after load");
  
   System.out.println("------华丽的-----------------------分割线-----");
  
   System.out.println("before load newInstance");
   test t=(test) c.newInstance();
   System.out.println("after load newInstance");*/
  
   System.out.println("before forName");
   Class c2=Class.forName("ying.test");
   System.out.println("after forName");
   c2.newInstance();
  
   System.out.println("------华丽的-----------------------分割线-----");
  
   System.out.println("before forName false");
   Class c3=Class.forName("ying.test",false, loader);
   System.out.println("after forName false");
   c3.newInstance();
}
}

此时时调用Class.forName，结果如下：
before forName
静态代码块运行
after forName
构造方法运行
------华丽的-----------------------分割线-----
before forName false
after forName false
构造方法运行

可以看出Class.forName(String className)方法默认是加载静态代码块的，而它的另一个方法Class.forName(String className,boolean initialize,ClassLoader loader)则可以控制是否调用静态代码块。Class.forName只是让类加载，并没有把类初始化，只有当调用newInstance时才初始化类，调用构造方法等。

调用ClassLoader时：
package ying;

public class main {
public static void main(String args[]) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
   //ClassLoader loader=test.class.getClassLoader();
   //可以用别的classloader来load其他类
   ClassLoader loader=main.class.getClassLoader();
  
   System.out.println("before load");
   Class c=loader.loadClass("ying.test"); 
   System.out.println("after load");
  
   System.out.println("------华丽的-----------------------分割线-----");
  
   System.out.println("before load newInstance");
   test t=(test) c.newInstance();
   System.out.println("after load newInstance");
  
/* System.out.println("before forName");
   Class c2=Class.forName("ying.test");
   System.out.println("after forName");
   c2.newInstance();
  
   System.out.println("------华丽的-----------------------分割线-----");
  
   System.out.println("before forName false");
   Class c3=Class.forName("ying.test",false, loader);
   System.out.println("after forName false");
   c3.newInstance();*/
}
}
结果：
before load
after load
------华丽的-----------------------分割线-----
before load newInstance
静态代码块运行
构造方法运行
变量a初始化1
after load newInstance

可见，当我们用ClassLoader进行类加载时，不会调用静态代码块，相当于Class.forName的第二个方法，只有在newInstance时才调用静态代码块——》初始化变量——》调用构造方法——》生成类实例。

事实上，JVM在加载类时，需要经过如下几个步骤。
1. 加载——找到相应的class字节码文件，读入JVM
2. 链接——包括进行验证，准备和解析
a) 验证：确信引入类型的正确性，即class是否符合java规范并且不会损害JVM的完整性。
b) 准备：为类变量分配内存同时设置默认初始值，如上例中加载test时，会初始化a=0;x=0;
c) 解析（可选）：根据loadClass方法的第二个参数来判断是否需要解释。解析是把符号引用转为直接引用的过程，如原来JVM知道类test中有一个成员叫“a”，通过解析则知道了该成员的地址是0xBBEDF，以后使用这个成员时，就直接去这个内存地址去找了。同时这个阶段，类的其他方法也会被映射到某个内存地址以待调用。
3. 初始化——激活类变量的初始化java代码。利用类定义的java代码确定成员变量的初值（若没有相应的java代码对其进行初始赋值操作，则会沿用准备阶段获得的该类型默认值），在这个阶段，所有的静态代码都会被执行，事实上，类在编译时期编译器会把这些静态代码封装到一个<clinit>方法中去，在使用这个类的时候，初始化过程就会调用这个<clinit>方法。这个方法程序员不能调用，只能被JVM调用。

事实上，ClassLoader也有两种方法，只是第二个带参数的方法是受保护的。
如下：
    protected synchronized Class loadClass(String name, boolean resolve)
throws ClassNotFoundException
    {
// 首先检查该name指定的class是否有被加载
Class c = findLoadedClass(name);
if (c == null) {
     try {
   if (parent != null) {
      //如果parent不为null，则调用parent的loadClass进行加载
c = parent.loadClass(name, false);
   } else {
    //parent为null，则调用BootstrapClassLoader进行加载
      c = findBootstrapClass0(name);
   }
     } catch (ClassNotFoundException e) {
         //如果仍然无法加载成功，则调用自身的findClass进行加载   
         c = findClass(name);
     }
}
if (resolve) {
     resolveClass(c);
}
return c;
    }
而用户使用的是一个参数的方法，而一个参数的方法实际调用了两个参数的方法，第二个，因此在这里可以看出通过loadClass加载类实际上就是加载的时候并不对该类进行解释，因此也不会初始化该类。而Class类的forName方法则是相反，使用forName加载的时候就会将Class进行解释。

例子：JDBC Driver的加载，网上都说JDBC驱动是通过DriverManager，必须在DriverMangaer中注册，如果驱动类没被初始化，则不能注册到DriverManager中，因此必须用forName而非loadClass。事实上这种说法是错误的，forName并没有把类初始化，类的初始化只能通过两种方式：
a) 隐式：使用New关键字，new一个对象
b) 显示：通过class的New Instance方法。
事实上forName和loadClass的区别也就在于那个“解释”的过程是否调用。ForName调用了，loadClass没调用，如此而已。
大家可以看下DriverManger的源码：
private static void loadInitialDrivers() {
        String drivers;
        try {
     drivers = (String) java.security.AccessController.doPrivileged(
   new sun.security.action.GetPropertyAction("jdbc.drivers"));
        } catch (Exception ex) {
            drivers = null;
        }
        println("DriverManager.initialize: jdbc.drivers = " + drivers);
        if (drivers == null) {
            return;
        }
        while (drivers.length() != 0) {
            int x = drivers.indexOf(':');
            String driver;
            if (x < 0) {
                driver = drivers;
                drivers = "";
            } else {
                driver = drivers.substring(0, x);
                drivers = drivers.substring(x+1);
            }
            if (driver.length() == 0) {
                continue;
            }
            try {
                println("DriverManager.Initialize: loading " + driver);
                Class.forName(driver, true,
         ClassLoader.getSystemClassLoader());
            } catch (Exception ex) {
                println("DriverManager.Initialize: load failed: " + ex);
            }
        }
    }
我们发现，其内部其实也是调用了forName方法。

LoadClass（）方法加载类及初始化过程：
类加载（loadclass（））（加载）——》newInstance（）（链接+初始化）
newInstance（）:
（开始连接）静态代码块——》普通变量分配准备（a=0;b=0;c=null）——》（开始初始化）普通变量赋值（a=1;b=2;c=”haha”）——》构造方法——》初始化成功。

Class.forName(Stirng className)一个参数方法加载类及初始化过程：
类加载(Class.forName())（加载）——》静态代码块——》newInstance（）（链接+初始化）

newInstance（）：
（开始连接）普通变量分配准备（a=0;b=0;c=null）——》（开始初始化）普通变量赋值（a=1;b=2;c=”haha”）——》构造方法——》初始化成功。

Class.forName()三个参数的加载类及初始化过程同classLoader一样。

从上边的断点调试可以看出，静态代码块不是在初始化阶段完成的，它陷于类初始化，先于普通变量默认分配（整型分配为0，字符串分配为null），这也就是为什么我们不能在静态代码块中引用普通变量的原因之一，这与上面所谓的“分配”、“初始化”相违背。

所以我觉得JVM的类加载及初始化过程应该是这样的。

1. 类加载：Bootstrap Loader——》Extended Loader——》System Loader
2. 静态代码块初始化
3. 链接：
a) 验证：是否符合java规范
b) 准备：默认初始值
c) 解析：符号引用转为直接引用，解析地址
4. 初始化
a) 赋值：java代码中的初始值
b) 构造:构造函数

因此ClassLoader.loadClass(String className)和Class.forName(String className)两者的区别就一目了然了。如下：

而loadClass直接就干“加载类“的这些事，不干多余的事儿。
而class.forName默认是老好人，就把加载静态代码块的工作也一并做了。但是又有一个带3个参数的方法，用来决定静态代码块的位置变化，加载（true）的话就把的位置提到“类加载“部分，不加载（false）的话就把它的位置滞后到newInstance的时候。

 

 

注：整合了一些javaeye上兄弟们的心血，实际断点调试了一把，有可能我的结论是片面的，欢迎大家指正。（Ps：再次鄙视下百度的文本编辑功能，直接copyword，格式全乱，给大家造成不便，请原谅）