ClassLoader.loadClass 和 Class.forName 区别

原文： http://blog.chinaunix.net/uid-21227800-id-65873.html

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.LauncherAppClassLoader(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在加载类时，需要经过如下几个步骤。

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

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

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

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

ClassLoader.loadClass 和 Class.forName 区别

你可能感兴趣的:(ClassLoader.loadClass 和 Class.forName 区别)