?

一、什么是ClassLoader?

? ? ? ? ?ClassLoader就是類加載器，當我們寫好一個Java程序之后，都是由若干個.class文件組成的一個完整的Java應用程序，當程序在運行時，即會調用該程序的一個入口函數來調用系統的相關功能，而這些功能都被封裝在不同的class文件當中，所以經常要從這個class文件中要調用另外一個class文件中的方法，如果另外一個文件不存在的，則會引發系統異常。而程序在啟動的時候，并不會一次性加載程序所要用的所有class文件，而是根據程序的需要，通過Java的類加載機制（ClassLoader）來動態加載某個class文件到內存當中的，從而只有class文件被載入到了內存之后，才能被其它class所引用。如果一次性加載那么多jar包那么多class，那內存不就崩潰了？所以ClassLoader就是用來動態加載class文件到內存當中用的。

1、Class文件的認識：

我們都知道在Java中程序是運行在虛擬機中，我們平常用文本編輯器或者是IDE編寫的程序都是.java格式的文件，這是最基礎的源碼，但這類文件是不能直接運行的。如我們編寫一個簡單的程序HelloWorld.java：

public class HelloWorld{public static void main(String[] args){System.out.println("Hello world!");} }

如圖：

可以看到目錄下生成了.class文件，我們再從命令行中執行命令：

java HelloWorld

上面是基本代碼示例，這里重新拿出來是想讓大家將焦點回到class文件上，class文件是字節碼格式文件，java虛擬機并不能直接識別我們平常編寫的.java源文件，所以需要javac這個命令轉換成.class文件。另外，如果用C或者Python 編寫的程序正確轉換成.class文件后，java虛擬機也是可以識別運行的。

?

二、Java默認提供的三個ClassLoader：

1、BootStrap ClassLoader：稱為啟動類加載器，是Java類加載層次中最頂層的類加載器，負責加載JDK中的核心類庫，如：rt.jar、resources.jar、charsets.jar等，可以通過啟動jvm時指定-Xbootclasspath和路徑來改變Bootstrap ClassLoader的加載目錄。比如java -Xbootclasspath/a:path，被指定的文件追加到默認的bootstrap路徑中。也可通過如下程序獲得該類加載器從哪些地方加載了相關的jar或class文件：

URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs(); for (int i = 0; i < urls.length; i++) {System.out.println(urls[i].toExternalForm()); }

以下內容是上述程序從本機JDK環境所獲得的結果：

file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/resources.jar
file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/rt.jar
file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/sunrsasign.jar
file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/jsse.jar
file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/jce.jar
file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/charsets.jar
file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/classes/

其實上述結果也是通過查找sun.boot.class.path這個系統屬性所得知的。?

System.out.println(System.getProperty("sun.boot.class.path"));

打印結果：

C:\Program Files\Java\jre1.8.0_91\lib\resources.jar;
C:\Program Files\Java\jre1.8.0_91\lib\rt.jar;
C:\Program Files\Java\jre1.8.0_91\lib\sunrsasign.jar;
C:\Program Files\Java\jre1.8.0_91\lib\jsse.jar;
C:\Program Files\Java\jre1.8.0_91\lib\jce.jar;
C:\Program Files\Java\jre1.8.0_91\lib\charsets.jar;
C:\Program Files\Java\jre1.8.0_91\lib\jfr.jar;
C:\Program Files\Java\jre1.8.0_91\classes

2、Extension ClassLoader：稱為擴展類加載器，負責加載Java的擴展類庫，默認加載JAVA_HOME/jre/lib/ext/目下的所有jar。還可以加載-D java.ext.dirs選項指定的目錄。

3、App ClassLoader：稱為系統類加載器，負責加載應用程序classpath目錄下的所有jar和class文件。

?????? ?注意：?除了Java默認提供的三個ClassLoader之外，用戶還可以根據需要定義自已的ClassLoader，而這些自定義的ClassLoader都必須繼承自java.lang.ClassLoader類，也包括Java提供的另外二個ClassLoader（Extension ClassLoader和App ClassLoader）在內，但是Bootstrap ClassLoader不繼承自ClassLoader，因為它不是一個普通的Java類，底層由C++編寫，已嵌入到了JVM內核當中，當JVM啟動后，Bootstrap ClassLoader也隨著啟動，負責加載完核心類庫后，并構造Extension ClassLoader和App ClassLoader類加載器。

?

三、ClassLoader加載類的原理：

?1、原理介紹：

???????ClassLoader使用的是雙親委托模型來搜索類的，每個ClassLoader實例都有一個父類加載器的引用（不是繼承的關系，是組合關系），虛擬機內置的啟動類加載器（Bootstrap ClassLoader）本身沒有父類加載器，但可以用作其它ClassLoader實例的的父類加載器。當一個ClassLoader實例需要加載某個類時，它會試圖親自搜索某個類之前，先把這個任務委托給它的父類加載器，這個過程是由上至下依次檢查的，首先由最頂層的類加載器Bootstrap ClassLoader試圖加載，如果沒加載到，則把任務轉交給Extension ClassLoader試圖加載，如果也沒加載到，則轉交給App ClassLoader?進行加載，如果它也沒有加載得到的話，則返回給委托的發起者，由它到指定的文件系統或網絡等URL中加載該類。如果它們都沒有加載到這個類時，則拋出ClassNotFoundException異常。否則將這個找到的類生成一個類的定義，并將它加載到內存當中，最后返回這個類在內存中的Class實例對象。

整個流程可以如下圖所示：

可以發現委托是從下向上，然后具體查找過程卻是自上至下。

2、為什么要使用雙親委托這種模型呢？

???????因為這樣可以避免重復加載，當父親已經加載了該類的時候，就沒有必要子ClassLoader再加載一次。考慮到安全因素，我們試想一下，如果不使用這種委托模式，那我們就可以隨時使用自定義的String來動態替代java核心api中定義的類型，這樣會存在非常大的安全隱患，而雙親委托的方式，就可以避免這種情況，因為String已經在啟動時就被引導類加載器（Bootstrcp ClassLoader）加載，所以用戶自定義的ClassLoader永遠也無法加載一個自己寫的String，除非你改變JDK中ClassLoader搜索類的默認算法。

3、?但是JVM在搜索類的時候，又是如何判定兩個class是相同的呢？

? ? ?JVM在判定兩個class是否相同時，不僅要判斷兩個類名是否相同，而且要判斷是否由同一個類加載器實例加載的。只有兩者同時滿足的情況下，JVM才認為這兩個class是相同的。就算兩個class是同一份class字節碼，如果被兩個不同的ClassLoader實例所加載，JVM也會認為它們是兩個不同class。比如網絡上的一個Java類org.classloader.simple.NetClassLoaderSimple，javac編譯之后生成字節碼文件NetClassLoaderSimple.class，ClassLoaderA和ClassLoaderB這兩個類加載器并讀取了NetClassLoaderSimple.class文件，并分別定義出了java.lang.Class實例來表示這個類，對于JVM來說，它們是兩個不同的實例對象，但它們確實是同一份字節碼文件，如果試圖將這個Class實例生成具體的對象進行轉換時，就會拋運行時異常java.lang.ClassCaseException，提示這是兩個不同的類型。現在通過實例來驗證上述所描述的是否正確：

（1）在web服務器上建一個org.classloader.simple.NetClassLoaderSimple.java類

package org.classloader.simple;public class NetClassLoaderSimple {private NetClassLoaderSimple instance;public void setNetClassLoaderSimple(Object obj) {this.instance = (NetClassLoaderSimple)obj;} }

org.classloader.simple.NetClassLoaderSimple類的setNetClassLoaderSimple方法接收一個Object類型參數，并將它強制轉換成org.classloader.simple.NetClassLoaderSimple類型。?

（2）測試兩個class是否相同（NetWorkClassLoader.java）

package classloader;public class NewworkClassLoaderTest {public static void main(String[] args) {try {//測試加載網絡中的class文件String rootUrl = "http://localhost:8080/httpweb/classes";String className = "org.classloader.simple.NetClassLoaderSimple";NetworkClassLoader ncl1 = new NetworkClassLoader(rootUrl);NetworkClassLoader ncl2 = new NetworkClassLoader(rootUrl);Class<?> clazz1 = ncl1.loadClass(className);Class<?> clazz2 = ncl2.loadClass(className);Object obj1 = clazz1.newInstance();Object obj2 = clazz2.newInstance();clazz1.getMethod("setNetClassLoaderSimple", Object.class).invoke(obj1, obj2);} catch (Exception e) {e.printStackTrace();}}}

首先獲得網絡上一個class文件的二進制名稱，然后通過自定義的類加載器NetworkClassLoader創建兩個實例，并根據網絡地址分別加載這份class，并得到這兩個ClassLoader實例加載后生成的Class實例clazz1和clazz2，最后將這兩個Class實例分別生成具體的實例對象obj1和obj2，再通過反射調用clazz1中的setNetClassLoaderSimple方法。

（3）查看測試結果：

結論：從結果中可以看出，雖然是同一份class字節碼文件，但是由于被兩個不同的ClassLoader實例所加載，所以JVM認為它們就是兩個不同的類。

?

三、源碼解析：

我們看到了系統的3個類加載器，他們的具體執行順序為Bootstrap CLassloder → Extention ClassLoader→AppClassLoader

為了更好的理解，我們可以查看源碼。

1、sum.misc.Launcher：

它是一個java虛擬機的入口應用。

public class Launcher {private static Launcher launcher = new Launcher();private static String bootClassPath =System.getProperty("sun.boot.class.path");public static Launcher getLauncher() {return launcher;}private ClassLoader loader;public Launcher() {// Create the extension class loaderClassLoader extcl;try {extcl = ExtClassLoader.getExtClassLoader();} catch (IOException e) {throw new InternalError("Could not create extension class loader", e);}// Now create the class loader to use to launch the applicationtry {loader = AppClassLoader.getAppClassLoader(extcl);} catch (IOException e) {throw new InternalError("Could not create application class loader", e);}//設置AppClassLoader為線程上下文類加載器，這個文章后面部分講解Thread.currentThread().setContextClassLoader(loader);}/** Returns the class loader used to launch the main application.*/public ClassLoader getClassLoader() {return loader;}/** The class loader used for loading installed extensions.*/static class ExtClassLoader extends URLClassLoader {}/*** The class loader used for loading from java.class.path.* runs in a restricted security context.*/static class AppClassLoader extends URLClassLoader {}

源碼有精簡，我們可以得到相關的信息。

（1）Launcher初始化了ExtClassLoader和AppClassLoader。

（2）Launcher中并沒有看見BootstrapClassLoader，但通過System.getProperty("sun.boot.class.path")得到了字符串bootClassPath,這個應該就是BootstrapClassLoader加載的jar包路徑。

我們可以先代碼測試一下sun.boot.class.path是什么內容。

System.out.println(System.getProperty("sun.boot.class.path"));

得到的結果是：

C:\Program Files\Java\jre1.8.0_91\lib\resources.jar;
C:\Program Files\Java\jre1.8.0_91\lib\rt.jar;
C:\Program Files\Java\jre1.8.0_91\lib\sunrsasign.jar;
C:\Program Files\Java\jre1.8.0_91\lib\jsse.jar;
C:\Program Files\Java\jre1.8.0_91\lib\jce.jar;
C:\Program Files\Java\jre1.8.0_91\lib\charsets.jar;
C:\Program Files\Java\jre1.8.0_91\lib\jfr.jar;
C:\Program Files\Java\jre1.8.0_91\classes

可以看到，這些全是JRE目錄下的jar包或者是class文件。

2、ExtClassLoader源碼：

如果你有足夠的好奇心，你應該會對它的源碼感興趣：

/** The class loader used for loading installed extensions.*/static class ExtClassLoader extends URLClassLoader {static {ClassLoader.registerAsParallelCapable();}/*** create an ExtClassLoader. The ExtClassLoader is created* within a context that limits which files it can read*/public static ExtClassLoader getExtClassLoader() throws IOException{final File[] dirs = getExtDirs();try {// Prior implementations of this doPrivileged() block supplied// aa synthesized ACC via a call to the private method// ExtClassLoader.getContext().return AccessController.doPrivileged(new PrivilegedExceptionAction<ExtClassLoader>() {public ExtClassLoader run() throws IOException {int len = dirs.length;for (int i = 0; i < len; i++) {MetaIndex.registerDirectory(dirs[i]);}return new ExtClassLoader(dirs);}});} catch (java.security.PrivilegedActionException e) {throw (IOException) e.getException();}}private static File[] getExtDirs() {String s = System.getProperty("java.ext.dirs");File[] dirs;if (s != null) {StringTokenizer st =new StringTokenizer(s, File.pathSeparator);int count = st.countTokens();dirs = new File[count];for (int i = 0; i < count; i++) {dirs[i] = new File(st.nextToken());}} else {dirs = new File[0];}return dirs;}......}

我們先前的內容有說過，可以指定-D java.ext.dirs參數來添加和改變ExtClassLoader的加載路徑。這里我們通過可以編寫測試代碼。

System.out.println(System.getProperty("java.ext.dirs"));

結果如下：

C:\Program Files\Java\jre1.8.0_91\lib\ext;C:\Windows\Sun\Java\lib\ext

3、AppClassLoader源碼：

/*** The class loader used for loading from java.class.path.* runs in a restricted security context.*/static class AppClassLoader extends URLClassLoader {public static ClassLoader getAppClassLoader(final ClassLoader extcl)throws IOException{final String s = System.getProperty("java.class.path");final File[] path = (s == null) ? new File[0] : getClassPath(s);return AccessController.doPrivileged(new PrivilegedAction<AppClassLoader>() {public AppClassLoader run() {URL[] urls =(s == null) ? new URL[0] : pathToURLs(path);return new AppClassLoader(urls, extcl);}});}......}

可以看到AppClassLoader加載的就是java.class.path下的路徑。我們同樣打印它的值。

System.out.println(System.getProperty("java.class.path"));

結果：

D:\workspace\ClassLoaderDemo\bin

這個路徑其實就是當前java工程目錄bin，里面存放的是編譯生成的class文件。

好了，自此我們已經知道了BootstrapClassLoader、ExtClassLoader、AppClassLoader實際是查閱相應的環境屬性sun.boot.class.path、java.ext.dirs和java.class.path來加載資源文件的。

4、父加載器不是父類：

（1）接下來我們先驗證ClassLoader加載類的原理：?

測試1：打印ClassLoader類的層次結構，請看下面這段代碼：

ClassLoader loader = ClassLoaderTest.class.getClassLoader(); //獲得加載ClassLoaderTest.class這個類的類加載器 while(loader != null) {System.out.println(loader);loader = loader.getParent(); //獲得父類加載器的引用 } System.out.println(loader);

?打印結果：

第一行結果說明：ClassLoaderTest的類加載器是AppClassLoader。

第二行結果說明：AppClassLoader的類加器是ExtClassLoader，即parent=ExtClassLoader。

第三行結果說明：ExtClassLoader的類加器是Bootstrap ClassLoader，因為Bootstrap ClassLoader不是一個普通的Java類，所以ExtClassLoader的parent=null，所以第三行的打印結果為null就是這個原因。（詳細原因下面會講）

測試2：將ClassLoaderTest.class打包成ClassLoaderTest.jar，放到Extension ClassLoader的加載目錄下（JAVA_HOME/jre/lib/ext），然后重新運行這個程序，得到的結果會是什么樣呢？

打印結果：

打印結果分析：為什么第一行的結果是ExtClassLoader呢？

????? 因為ClassLoader的委托模型機制，當我們要用ClassLoaderTest.class這個類的時候，AppClassLoader在試圖加載之前，先委托給Bootstrcp ClassLoader，Bootstracp ClassLoader發現自己沒找到，它就告訴ExtClassLoader，兄弟，我這里沒有這個類，你去加載看看，然后Extension ClassLoader拿著這個類去它指定的類路徑（JAVA_HOME/jre/lib/ext）試圖加載，唉，它發現在ClassLoaderTest.jar這樣一個文件中包含ClassLoaderTest.class這樣的一個文件，然后它把找到的這個類加載到內存當中，并生成這個類的Class實例對象，最后把這個實例返回。所以ClassLoaderTest.class的類加載器是ExtClassLoader。

第二行的結果為null，是因為ExtClassLoader的父類加載器是Bootstrap ClassLoader。

測試3：用Bootstrcp ClassLoader來加載ClassLoaderTest.class，有兩種方式：

1、在jvm中添加-Xbootclasspath參數，指定Bootstrcp ClassLoader加載類的路徑，并追加我們自已的jar（ClassTestLoader.jar）

2、將class文件放到JAVA_HOME/jre/classes/目錄下（上面有提到）

方式1：（我用的是Eclipse開發工具，用命令行是在java命令后面添加-Xbootclasspath參數）

打開Run配置對話框：

配置好如圖中所述的參數后，重新運行程序，產的結果如下所示：（類加載的過程，只摘下了一部份）

打印結果：

[Loaded java.io.FileReader from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded sun.nio.cs.StreamDecoder from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.ArrayList from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.lang.reflect.Array from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.Locale from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.ConcurrentMap from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.ConcurrentHashMap from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.locks.Lock from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.locks.ReentrantLock from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.ConcurrentHashMap$Segment from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.locks.AbstractOwnableSynchronizer from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.locks.AbstractQueuedSynchronizer from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.locks.ReentrantLock$Sync from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.locks.ReentrantLock$NonfairSync from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.locks.AbstractQueuedSynchronizer$Node from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.concurrent.ConcurrentHashMap$HashEntry from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.lang.CharacterDataLatin1 from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.io.ObjectStreamClass from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded sun.net.www.ParseUtil from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.BitSet from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.net.Parts from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.net.URLStreamHandler from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded sun.net.www.protocol.file.Handler from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.util.HashSet from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded sun.net.www.protocol.jar.Handler from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded sun.misc.Launcher$AppClassLoader from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded sun.misc.Launcher$AppClassLoader$1 from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.lang.SystemClassLoaderAction from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Path C:\Program Files\Java\jdk1.6.0_22\jre\classes]
[Loaded classloader.ClassLoaderTest from C:\Program Files\Java\jdk1.6.0_22\jre\classes]
null ?//這是打印的結果
C:\Program Files\Java\jdk1.6.0_22\jre\lib\resources.jar;C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar;
C:\Program Files\Java\jdk1.6.0_22\jre\lib\sunrsasign.jar;C:\Program Files\Java\jdk1.6.0_22\jre\lib\jsse.jar;
C:\Program Files\Java\jdk1.6.0_22\jre\lib\jce.jar;C:\Program Files\Java\jdk1.6.0_22\jre\lib\charsets.jar;
C:\Program Files\Java\jdk1.6.0_22\jre\classes;c:\ClassLoaderTest.jar ?
//這一段是System.out.println(System.getProperty("sun.boot.class.path"));打印出來的。這個路徑就是Bootstrcp ClassLoader默認搜索類的路徑
[Loaded java.lang.Shutdown from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]
[Loaded java.lang.Shutdown$Lock from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]

方式2：將ClassLoaderTest.jar解壓后，放到JAVA_HOME/jre/classes目錄下，如下圖所示：

提示：jre目錄下默認沒有classes目錄，需要自己手動創建一個

打印結果：

從結果中可以看出，兩種方式都實現了將ClassLoaderTest.class由Bootstrcp ClassLoader加載成功了。

（2）為什么上面輸出的Bootstrcp ClassLoader的值是null呢？

難道是Bootstrcp ClassLoader類加載器沒有加載？當然不是！要想弄明白這些，我們首先得知道一個前提：父加載器不是父類。

我們先前已經粘貼了ExtClassLoader和AppClassLoader的代碼。

static class ExtClassLoader extends URLClassLoader {} static class AppClassLoader extends URLClassLoader {}

可以看見ExtClassLoader和AppClassLoader同樣繼承自URLClassLoader，但上面一小節代碼中，為什么調用AppClassLoader的getParent()代碼會得到ExtClassLoader的實例呢？先從URLClassLoader說起，這個類又是什么？

先上一張類的繼承關系圖：

URLClassLoader的源碼中并沒有找到getParent()方法。這個方法在ClassLoader.java中。

public abstract class ClassLoader {// The parent class loader for delegation // Note: VM hardcoded the offset of this field, thus all new fields // must be added *after* it. private final ClassLoader parent; // The class loader for the system// @GuardedBy("ClassLoader.class") private static ClassLoader scl;private ClassLoader(Void unused, ClassLoader parent) {this.parent = parent;... } protected ClassLoader(ClassLoader parent) {this(checkCreateClassLoader(), parent); } protected ClassLoader() {this(checkCreateClassLoader(), getSystemClassLoader()); } public final ClassLoader getParent() {if (parent == null)return null;return parent; } public static ClassLoader getSystemClassLoader() {initSystemClassLoader();if (scl == null) {return null;}return scl; }private static synchronized void initSystemClassLoader() {if (!sclSet) {if (scl != null)throw new IllegalStateException("recursive invocation");sun.misc.Launcher l = sun.misc.Launcher.getLauncher();if (l != null) {Throwable oops = null;//通過Launcher獲取ClassLoaderscl = l.getClassLoader();try {scl = AccessController.doPrivileged(new SystemClassLoaderAction(scl));} catch (PrivilegedActionException pae) {oops = pae.getCause();if (oops instanceof InvocationTargetException) {oops = oops.getCause();}}if (oops != null) {if (oops instanceof Error) {throw (Error) oops;} else {// wrap the exceptionthrow new Error(oops);}}}sclSet = true;} } }

我們可以看到getParent()實際上返回的就是一個ClassLoader對象parent，parent的賦值是在ClassLoader對象的構造方法中，它有兩個情況：

（1）由外部類創建ClassLoader時直接指定一個ClassLoader為parent。

（2）由getSystemClassLoader()方法生成，也就是在sun.misc.Laucher通過getClassLoader()獲取，也就是AppClassLoader。直白的說，一個ClassLoader創建時如果沒有指定parent，那么它的parent默認就是AppClassLoader。

我們主要研究的是ExtClassLoader與AppClassLoader的parent的來源，正好它們與Launcher類有關，我們上面已經粘貼過Launcher的部分代碼。

public class Launcher {private static URLStreamHandlerFactory factory = new Factory();private static Launcher launcher = new Launcher();private static String bootClassPath =System.getProperty("sun.boot.class.path");public static Launcher getLauncher() {return launcher;}private ClassLoader loader;public Launcher() {// Create the extension class loaderClassLoader extcl;try {extcl = ExtClassLoader.getExtClassLoader();} catch (IOException e) {throw new InternalError("Could not create extension class loader", e);}// Now create the class loader to use to launch the applicationtry {//將ExtClassLoader對象實例傳遞進去loader = AppClassLoader.getAppClassLoader(extcl);} catch (IOException e) {throw new InternalError("Could not create application class loader", e);}public ClassLoader getClassLoader() {return loader;} static class ExtClassLoader extends URLClassLoader {/*** create an ExtClassLoader. The ExtClassLoader is created* within a context that limits which files it can read*/public static ExtClassLoader getExtClassLoader() throws IOException{final File[] dirs = getExtDirs();try {// Prior implementations of this doPrivileged() block supplied// aa synthesized ACC via a call to the private method// ExtClassLoader.getContext().return AccessController.doPrivileged(new PrivilegedExceptionAction<ExtClassLoader>() {public ExtClassLoader run() throws IOException {//ExtClassLoader在這里創建return new ExtClassLoader(dirs);}});} catch (java.security.PrivilegedActionException e) {throw (IOException) e.getException();}}/** Creates a new ExtClassLoader for the specified directories.*/public ExtClassLoader(File[] dirs) throws IOException {super(getExtURLs(dirs), null, factory);}}}

我們需要注意的是：

ClassLoader extcl;extcl = ExtClassLoader.getExtClassLoader();loader = AppClassLoader.getAppClassLoader(extcl);

代碼已經說明了問題AppClassLoader的parent是一個ExtClassLoader實例。

ExtClassLoader并沒有直接找到對parent的賦值。它調用了它的父類也就是URLClassLoder的構造方法并傳遞了3個參數。

public ExtClassLoader(File[] dirs) throws IOException {super(getExtURLs(dirs), null, factory); }

對應的代碼：

public URLClassLoader(URL[] urls, ClassLoader parent,URLStreamHandlerFactory factory) {super(parent); }

答案已經很明了了，ExtClassLoader的parent為null。

上面張貼這么多代碼也是為了說明AppClassLoader的parent是ExtClassLoader，ExtClassLoader的parent是null。這符合我們之前編寫的測試代碼。

不過，細心的同學發現，還是有疑問的我們只看到ExtClassLoader和AppClassLoader的創建，那么BootstrapClassLoader呢？

還有，ExtClassLoader的父加載器為null,但是Bootstrap CLassLoader卻可以當成它的父加載器這又是為何呢？

我們繼續往下進行。

（3）Bootstrap ClassLoader是由C++編寫的：

Bootstrap ClassLoader是由C/C++編寫的，它本身是虛擬機的一部分，所以它并不是一個JAVA類，也就是無法在java代碼中獲取它的引用，JVM啟動時通過Bootstrap類加載器加載rt.jar等核心jar包中的class文件，之前的int.class,String.class都是由它加載。然后呢，我們前面已經分析了，JVM初始化sun.misc.Launcher并創建Extension ClassLoader和AppClassLoader實例。并將ExtClassLoader設置為AppClassLoader的父加載器。Bootstrap沒有父加載器，但是它卻可以作用一個ClassLoader的父加載器。比如ExtClassLoader。這也可以解釋之前通過ExtClassLoader的getParent方法獲取為Null的現象。具體是什么原因，很快就知道答案了。

（4）重要方法：

①loadClass()：

JDK文檔中是這樣寫的，通過指定的全限定類名加載class，它通過同名的loadClass(String,boolean)方法。

protected Class<?> loadClass(String name,boolean resolve)throws ClassNotFoundException

上面是方法原型，一般實現這個方法的步驟是

執行findLoadedClass(String)去檢測這個class是不是已經加載過了。

執行父加載器的loadClass方法。如果父加載器為null，則jvm內置的加載器去替代，也就是Bootstrap ClassLoader。這也解釋了ExtClassLoader的parent為null,但仍然說Bootstrap ClassLoader是它的父加載器。

如果向上委托父加載器沒有加載成功，則通過findClass(String)查找。

如果class在上面的步驟中找到了，參數resolve又是true的話，那么loadClass()又會調用resolveClass(Class)這個方法來生成最終的Class對象。 我們可以從源代碼看出這個步驟。

protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException{synchronized (getClassLoadingLock(name)) {// 首先，檢測是否已經加載Class<?> c = findLoadedClass(name);if (c == null) {long t0 = System.nanoTime();try {if (parent != null) {//父加載器不為空則調用父加載器的loadClassc = parent.loadClass(name, false);} else {//父加載器為空則調用Bootstrap Classloaderc = findBootstrapClassOrNull(name);}} catch (ClassNotFoundException e) {// ClassNotFoundException thrown if class not found// from the non-null parent class loader}if (c == null) {// If still not found, then invoke findClass in order// to find the class.long t1 = System.nanoTime();//父加載器沒有找到，則調用findclassc = findClass(name);// this is the defining class loader; record the statssun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);sun.misc.PerfCounter.getFindClasses().increment();}}if (resolve) {//調用resolveClass()resolveClass(c);}return c;}}

?

?

四、定義自已的ClassLoader

既然JVM已經提供了默認的類加載器，為什么還要定義自已的類加載器呢？

? ? ? 因為Java中提供的默認ClassLoader，只加載指定目錄下的jar和class，如果我們想加載其它位置的類或jar時，比如：我要加載網絡上的一個class文件，通過動態加載到內存之后，要調用這個類中的方法實現我的業務邏輯。在這樣的情況下，默認的ClassLoader就不能滿足我們的需求了，所以需要定義自己的ClassLoader。

1、定義自已的類加載器的步驟為：

（1）繼承java.lang.ClassLoader抽象類；

（2）重寫父類的findClass方法，改變搜索類的算法；

（3）在findClass()中調用defineClass()，將class的字節碼數組轉換成Class類的實例。

讀者可能在這里有疑問，父類有那么多方法，為什么偏偏只重寫findClass方法？

因為JDK已經在loadClass方法中幫我們實現了ClassLoader搜索類的算法，當在loadClass方法中搜索不到類時，loadClass方法就會調用findClass方法來搜索類，所以我們只需重寫該方法即可。如沒有特殊的要求，一般不建議重寫loadClass搜索類的算法。下圖是API中ClassLoader的loadClass方法：

注意點：

**一個ClassLoader創建時如果沒有指定parent，那么它的parent默認就是AppClassLoader。 **

上面說的是，如果自定義一個ClassLoader，默認的parent父加載器是AppClassLoader，因為這樣就能夠保證它能訪問系統內置加載器加載成功的class文件。

示例：自定義一個NetworkClassLoader，用于加載網絡上的class文件：

package classloader;import java.io.ByteArrayOutputStream; import java.io.InputStream; import java.net.URL;/*** 加載網絡class的ClassLoader*/ public class NetworkClassLoader extends ClassLoader {private String rootUrl;public NetworkClassLoader(String rootUrl) {this.rootUrl = rootUrl;}@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {Class clazz = null;//this.findLoadedClass(name); // 父類已加載 //if (clazz == null) { //檢查該類是否已被加載過byte[] classData = getClassData(name); //根據類的二進制名稱,獲得該class文件的字節碼數組if (classData == null) {throw new ClassNotFoundException();}clazz = defineClass(name, classData, 0, classData.length); //將class的字節碼數組轉換成Class類的實例//} return clazz;}private byte[] getClassData(String name) {InputStream is = null;try {String path = classNameToPath(name);URL url = new URL(path);byte[] buff = new byte[1024*4];int len = -1;is = url.openStream();ByteArrayOutputStream baos = new ByteArrayOutputStream();while((len = is.read(buff)) != -1) {baos.write(buff,0,len);}return baos.toByteArray();} catch (Exception e) {e.printStackTrace();} finally {if (is != null) {try {is.close();} catch(IOException e) {e.printStackTrace();}}}return null;}private String classNameToPath(String name) {return rootUrl + "/" + name.replace(".", "/") + ".class";} }

測試類：

package classloader;public class ClassLoaderTest {public static void main(String[] args) {try {/*ClassLoader loader = ClassLoaderTest.class.getClassLoader(); //獲得ClassLoaderTest這個類的類加載器while(loader != null) {System.out.println(loader);loader = loader.getParent(); //獲得父加載器的引用}System.out.println(loader);*/String rootUrl = "http://localhost:8080/httpweb/classes";NetworkClassLoader networkClassLoader = new NetworkClassLoader(rootUrl);String classname = "org.classloader.simple.NetClassLoaderTest";Class clazz = networkClassLoader.loadClass(classname);System.out.println(clazz.getClassLoader());} catch (Exception e) {e.printStackTrace();}}}

打印結果：

下圖是我機器上web服務器的目錄結構：

目前常用web服務器中都定義了自己的類加載器，用于加載web應用指定目錄下的類庫（jar或class），如：Weblogic、Jboss、tomcat等，下面我以Tomcat為例，展示該web容器都定義了哪些個類加載器：

1、新建一個web工程httpweb

2、新建一個ClassLoaderServletTest，用于打印web容器中的ClassLoader層次結構

import java.io.IOException; import java.io.PrintWriter;import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse;public class ClassLoaderServletTest extends HttpServlet {public void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {response.setContentType("text/html");PrintWriter out = response.getWriter();ClassLoader loader = this.getClass().getClassLoader();while(loader != null) {out.write(loader.getClass().getName()+"<br/>");loader = loader.getParent();}out.write(String.valueOf(loader));out.flush();out.close();}public void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {this.doGet(request, response);}}

3、配置Servlet，并啟動服務：

<?xml version="1.0" encoding="UTF-8"?> <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"><servlet><servlet-name>ClassLoaderServletTest</servlet-name><servlet-class>ClassLoaderServletTest</servlet-class></servlet><servlet-mapping><servlet-name>ClassLoaderServletTest</servlet-name><url-pattern>/servlet/ClassLoaderServletTest</url-pattern></servlet-mapping><welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list> </web-app>

?4、訪問Servlet，獲得顯示結果：

?

五、總結：

ClassLoader用來加載class文件的。

系統內置的ClassLoader通過雙親委托來加載指定路徑下的class和資源。

可以自定義ClassLoader一般覆蓋findClass()方法。

ContextClassLoader與線程相關，可以獲取和設置，可以繞過雙親委托的機制。

?

?

本文整理自以下的這兩篇博客：

https://blog.csdn.net/xyang81/article/details/7292380

https://blog.csdn.net/briblue/article/details/54973413#commentBox

總結

以上是生活随笔為你收集整理的Java虚拟机：深入详细分析Java ClassLoader原理与源码的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。