一文读懂类加载机制 --- ClassLoader
?
From：https://www.cnblogs.com/sunnick/p/9609326.html
【JVM筆記】classloader加載class文件的原理和機制：https://www.jianshu.com/p/52c38cf2e3d4
?
JVM 架構整體架構
?
在進入 classloader 分析之前，先了解一下 jvm 整體架構：
JVM 被分為三個主要的子系統
- （1）類加載器子系統
- （2）運行時數據區
- （3）執行引擎
?
1.?類加載器子系統
大致分為 5 個階段：
- （1）加載：java類運行時候會生成一個class字節碼文件，加載的過程就是去我們的操作系統尋找這個class文件。
- （2）鏈接：這個過程就是把class文件加載到java虛擬機。
- （3）初始化：在虛擬機中根據class文件進行初始化。
- （4）使用：這個過程大家都明白。
- （5）卸載：使用完了，java虛擬機進行清理。
對于 class.forName 和 classloader 來說針對的就是第一個過程，也就是加載過程。不過這倆雖然有一定的相似性，但是區別還是挺大的。（?https://baijiahao.baidu.com/s?id=1654865863100987859 ）
- （1）class.forName() 除了將類的.class文件加載到 jvm 中之外，還會對類進行解釋，執行類中的 static 塊。當然還可以指定是否執行靜態塊。
- （2）classLoader只干一件事情，就是將.class文件加載到jvm中，不會執行static中的內容,只有在newInstance才會去執行static塊。
Java 的動態類加載功能是由類加載器子系統處理。當它在運行時（不是編譯時）首次引用一個類時，它加載、鏈接并初始化該類文件。
?
1.1 加載
加載：類由此組件加載。啟動類加載器 (BootStrap class Loader)、擴展類加載器(Extension class Loader)和應用程序類加載器(Application class Loader) 這三種類加載器幫助完成類的加載。
- 1. 啟動類加載器 – 負責從啟動類路徑中加載類，無非就是rt.jar。這個加載器會被賦予最高優先級。
- 2. 擴展類加載器 – 負責加載ext 目錄(jre\lib)內的類.
- 3. 應用程序類加載器 – 負責加載應用程序級別類路徑，涉及到路徑的環境變量等etc.上述的類加載器會遵循委托層次算法（Delegation Hierarchy Algorithm）加載類文件，這個在后面進行講解。
加載過程主要完成三件事情：
-
通過類的全限定名來獲取定義此類的二進制字節流
-
將這個類字節流代表的靜態存儲結構轉為方法區的運行時數據結構
-
在堆中生成一個代表此類的java.lang.Class對象，作為訪問方法區這些數據結構的入口。
?
1.2 鏈接
校驗 –?字節碼校驗器會校驗生成的字節碼是否正確，如果校驗失敗，我們會得到校驗錯誤。
- 文件格式驗證：基于字節流驗證，驗證字節流符合當前的Class文件格式的規范，能被當前虛擬機處理。驗證通過后，字節流才會進入內存的方法區進行存儲。
- 元數據驗證：基于方法區的存儲結構驗證，對字節碼進行語義驗證，確保不存在不符合java語言規范的元數據信息。
- 字節碼驗證：基于方法區的存儲結構驗證，通過對數據流和控制流的分析，保證被檢驗類的方法在運行時不會做出危害虛擬機的動作。
- 符號引用驗證：基于方法區的存儲結構驗證，發生在解析階段，確保能夠將符號引用成功的解析為直接引用，其目的是確保解析動作正常執行。換句話說就是對類自身以外的信息進行匹配性校驗。
準備 – 分配內存并初始化默認值給所有的靜態變量。
public static int value=33;這據代碼的賦值過程分兩次， 一是上面我們提到的階段，此時的value將會被賦值為0； 二是 value=33 這個過程發生在類構造器的<clinit>()方法中。解析所有符號內存引用被方法區(Method Area)的原始引用所替代。
舉個例子來說明，在com.sbbic.Person類中引用了com.sbbic.Animal類，在編譯階段，Person類并不知道Animal的實際內存地址，因此只能用com.sbbic.Animal來代表Animal真實的內存地址。在解析階段，JVM可以通過解析該符號引用，來確定com.sbbic.Animal類的真實內存地址（如果該類未被加載過，則先加載）。
主要有以下四種：類或接口的解析，字段解析，類方法解析，接口方法解析
?
1.3 初始化
初始化：這是類加載的最后階段，這里所有的靜態變量會被賦初始值, 并且靜態塊將被執行。
java中，對于初始化階段，有且只有**以下五種情況才會對要求類立刻初始化：
-
使用new關鍵字實例化對象、訪問或者設置一個類的靜態字段（被final修飾、編譯器優化時已經放入常量池的例外）、調用類方法，都會初始化該靜態字段或者靜態方法所在的類；
-
初始化類的時候，如果其父類沒有被初始化過，則要先觸發其父類初始化；
-
使用java.lang.reflect包的方法進行反射調用的時候，如果類沒有被初始化，則要先初始化；
-
虛擬機啟動時，用戶會先初始化要執行的主類（含有main）；
-
jdk 1.7后，如果java.lang.invoke.MethodHandle的實例最后對應的解析結果是 REF_getStatic、REF_putStatic、REF_invokeStatic方法句柄，并且這個方法所在類沒有初始化，則先初始化；
?
2.運行時數據區（Runtime Data Area）
The 運行時數據區域被劃分為5個主要組件：
① 方法區 (線程共享) 常量 靜態變量 JIT(即時編譯器)編譯后代碼也在方法區存放
② 堆內存(線程共享) 垃圾回收的主要場地
③ 程序計數器 當前線程執行的字節碼的位置指示器
④ Java虛擬機棧(棧內存) :保存局部變量,基本數據類型以及堆內存中對象的引用變量
⑤ 本地方法棧 (C棧):為JVM提供使用native方法的服務
?
3. 執行引擎
分配給運行時數據區的字節碼將由執行引擎執行。執行引擎讀取字節碼并逐段執行。
3.1 解釋器: 解釋器能快速的解釋字節碼，但執行卻很慢。 解釋器的缺點就是,當一個方法被調用多次，每次都需要重新解釋。
3.2 編譯器：JIT編譯器消除了解釋器的缺點。執行引擎利用解釋器轉換字節碼，但如果是重復的代碼則使用JIT編譯器將全部字節碼編譯成本機代碼。本機代碼將直接用于重復的方法調用，這提高了系統的性能。a. 中間代碼生成器– 生成中間代碼b. 代碼優化器– 負責優化上面生成的中間代碼c. 目標代碼生成器– 負責生成機器代碼或本機代碼d. 探測器(Profiler) – 一個特殊的組件，負責尋找被多次調用的方法。
3.3 垃圾回收器: 收集并刪除未引用的對象。可以通過調用"System.gc()"來觸發垃圾回收，但并不保證會確實進行垃圾回收。JVM的垃圾回收只收集哪些由new關鍵字創建的對象。所以，如果不是用new創建的對象，你可以使用finalize函數來執行清理。Java本地接口 (JNI): JNI會與本地方法庫進行交互并提供執行引擎所需的本地庫。本地方法庫:它是一個執行引擎所需的本地庫的集合。
下面，通過一個小程序認識JVM：
package com.spark.jvm;/*** 從JVM調用的角度分析java程序堆內存空間的使用：* 當JVM進程啟動的時候，會從類加載路徑中找到包含main方法的入口類HelloJVM* 找到HelloJVM會直接讀取該文件中的二進制數據，并且把該類的信息放到運行時的Method內存區域中。* 然后會定位到HelloJVM中的main方法的字節碼中，并開始執行Main方法中的指令* 此時會創建Student實例對象，并且使用student來引用該對象（或者說給該對象命名），其內幕如下：* 第一步：JVM會直接到Method區域中去查找Student類的信息，此時發現沒有Student類，就通過類加載器加載該Student類文件；* 第二步：在JVM的Method區域中加載并找到了Student類之后會在Heap區域中為Student實例對象分配內存，* 并且在Student的實例對象中持有指向方法區域中的Student類的引用（內存地址）；* 第三步：JVM實例化完成后會在當前線程中為Stack中的reference建立實際的應用關系，此時會賦值給student* 接下來就是調用方法* 在JVM中方法的調用一定是屬于線程的行為，也就是說方法調用本身會發生在線程的方法調用棧：* 線程的方法調用棧（Method Stack Frames），每一個方法的調用就是方法調用棧中的一個Frame，* 該Frame包含了方法的參數，局部變量，臨時數據等 student.sayHello();*/public class HelloJVM {//在JVM運行的時候會通過反射的方式到Method區域找到入口方法mainpublic static void main(String[] args) {//main方法也是放在Method方法區域中的/*** student(小寫的)是放在主線程中的Stack區域中的* Student對象實例是放在所有線程共享的Heap區域中的*/Student student = new Student("spark");/*** 首先會通過student指針（或句柄）* （指針就直接指向堆中的對象，句柄表明有一個中間的,student指向句柄，句柄指向對象）* 找 Student對象，當找到該對象后會通過對象內部指向方法區域中的指針來調用具體的方法去執行任務*/student.sayHello();} }class Student {// name本身作為成員是放在stack區域的但是name指向的String對象是放在Heap中private String name;public Student(String name) {this.name = name;}//sayHello這個方法是放在方法區中的public void sayHello() {System.out.println("Hello, this is " + this.name);} }?
?
classloader 加載 class 文件的原理和機制
?
下面部分內容，整理自《深入分析JavaWeb技術內幕》
Classloader負責將Class加載到JVM中，并且確定由那個ClassLoader來加載（父優先的等級加載機制）。還有一個任務就是將Class字節碼重新解釋為JVM統一要求的格式
?
1.Classloader 類結構分析
(1) 主要由四個方法，分別是 defineClass ， findClass ， loadClass ， resolveClass
- <1> defineClass(byte[] , int ,int) 將byte字節流解析為JVM能夠識別的Class對象（直接調用這個方法生成的Class對象還沒有resolve，這個resolve將會在這個對象真正實例化時resolve）
- <2> findClass，通過類名去加載對應的Class對象。當我們實現自定義的classLoader通常是重寫這個方法，根據傳入的類名找到對應字節碼的文件，并通過調用defineClass解析出Class獨享
- <3> loadClass運行時可以通過調用此方法加載一個類（由于類是動態加載進jvm，用多少加載多少的？）
- <4> resolveClass手動調用這個使得被加到JVM的類被鏈接（解析resolve這個類？）
(2) 實現自定義 ClassLoader 一般會繼承 URLClassLoader 類，因為這個類實現了大部分方法。
?
2. 常見加載類錯誤分析
- (1) ClassNotFoundException ：通常是jvm要加載一個文件的字節碼到內存時，沒有找到這些字節碼(如forName，loadClass等方法)
- (2) NoClassDefFoundError ：通常是使用new關鍵字，屬性引用了某個類，繼承了某個類或接口，但JVM加載這些類時發現這些類不存在的異常
- (3) UnsatisfiedLinkErrpr：如native的方法找不到本機的lib
?
3. 常用 classLoader （書本此處其實是對 tomcat 加載 servlet 使用的 classLoader 分析）
- (1)AppClassLoader ：加載jvm的classpath中的類和tomcat的核心類
- (2) StandardClassLoader：加載tomcat容器的classLoader，另外webAppClassLoader在loadclass時，發現類不在JVM的classPath下，在PackageTriggers(是一個字符串數組，包含一組不能使用webAppClassLoader加載的類的包名字符串)下的話，將由該加載器加載(注意：StandardClassLoader并沒有覆蓋loadclass方法，所以其加載的類和AppClassLoader加載沒什么分別，并且使用getClassLoader返回的也是AppClassLoader)(另外，如果web應用直接放在tomcat的webapp目錄下該應用就會通過StandardClassLoader加載，估計是因為webapp目錄在PackageTriggers中？)
- (3) webAppClassLoader 如：Servlet等web應用中的類的加載（loadclass方法的規則詳見P169）
?
4. 自定義的 classloader
(1) 需要使用自定義 classloader 的情況
- <1> 不在System.getProperty("java.class.path")中的類文件不可以被AppClassLoader找到（LoaderClass方法只會去classpath下加載特定類名的類），當class文件的字節碼不在ClassPath就需要自定義classloader
- <2> 對加載的某些類需要作特殊處理
- <3> 定義類的實效機制，對已經修改的類重新加載，實現熱部署
(2) 加載自定義路徑中的 class 文件
- <1>加載特定來源的某些類：重寫find方法，使特定類或者特定來源的字節碼 通過defineClass獲得class類并返回(應該符合jvm的類加載規范，其他類仍使用父加載器加載)
- <2>加載自頂一個是的class文件(如經過網絡傳來的經過加密的class文件字節碼)：findclass中加密后再加載
?
5. 實現類的熱部署：
- (1)同一個classLoader的兩個實例加載同一個類，JVM也會識別為兩個
- (2)不能重復加載同一個類（全名相同，并使用同一個類加載器），會報錯
- (3)不應該動態加載類，因為對象唄引用后，對象的屬性結構被修改會引發問題
注意：使用不同classLoader加載的同一個類文件得到的類，JVM將當作是兩個不同類，使用單例模式，強制類型轉換時都可能因為這個原因出問題。
?
6 類加載器的雙親委派模型
當一個類加載器收到一個類加載的請求，它首先會將該請求委派給父類加載器去加載，每一個層次的類加載器都是如此，因此所有的類加載請求最終都應該被傳入到頂層的啟動類加載器(Bootstrap ClassLoader)中，只有當父類加載器反饋無法完成這個列的加載請求時（它的搜索范圍內不存在這個類），子類加載器才嘗試加載。其層次結構示意圖如下：
不難發現，該種加載流程的好處在于：可以避免重復加載，父類已經加載了，子類就不需要再次加載。更加安全，很好的解決了各個類加載器的基礎類的統一問題，如果不使用該種方式，那么用戶可以隨意定義類加載器來加載核心api，會帶來相關隱患。
接下來，我們看看雙親委派模型是如何實現的：
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) {//交給父類加載c = parent.loadClass(name, false);} else {//父類不存在，則交給啟動類加載器加載c = findBootstrapClassOrNull(name);}} catch (ClassNotFoundException e) {//父類加載器拋出異常，無法完成類加載請求}if (c == null) {//long t1 = System.nanoTime();//父類加載器無法完成類加載請求時，調用自身的findClass方法來完成類加載c = findClass(name);sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);sun.misc.PerfCounter.getFindClasses().increment();}}if (resolve) {resolveClass(c);}return c;}}這里有些童鞋會問，JVM怎么知道一個某個類加載器的父加載器呢?如果你有此疑問，請重新再看一遍.
?
7 類加載器的特點
運行任何一個程序時，總是由Application Loader開始加載指定的類。
一個類在收到加載類請求時，總是先交給其父類嘗試加載。
Bootstrap Loader是最頂級的類加載器，其父加載器為null。
?
8 類加載的三種方式
通過命令行啟動應用時由JVM初始化加載含有main()方法的主類。
通過Class.forName()方法動態加載，會默認執行初始化塊（static{}），但是Class.forName(name,initialize,loader)中的initialze可指定是否要執行初始化塊。
通過ClassLoader.loadClass()方法動態加載，不會執行初始化塊。
?
9 自定義類加載器的兩種方式
1、遵守雙親委派模型：繼承ClassLoader，重寫findClass()方法。 2、破壞雙親委派模型：繼承ClassLoader,重寫loadClass()方法。 通常我們推薦采用第一種方法自定義類加載器，最大程度上的遵守雙親委派模型。 自定義類加載的目的是想要手動控制類的加載,那除了通過自定義的類加載器來手動加載類這種方式,還有其他的方式么?
利用現成的類加載器進行加載:
1. 利用當前類加載器：Class.forName();
2. 通過系統類加載器：Classloader.getSystemClassLoader().loadClass();
3. 通過上下文類加載器：Thread.currentThread().getContextClassLoader().loadClass();
l 利用URLClassLoader進行加載:
URLClassLoader loader=new URLClassLoader();loader.loadClass();類加載實例演示： 命令行下執行 HelloWorld.java
public class HelloWorld{public static void main(String[] args){System.out.println("Hello world");} }該段代碼大體經過了一下步驟:
-
尋找jre目錄，尋找jvm.dll，并初始化JVM.
-
產生一個Bootstrap ClassLoader；
-
Bootstrap ClassLoader加載器會加載他指定路徑下的java核心api，并且生成Extended ClassLoader加載器的實例，然后Extended ClassLoader會加載指定路徑下的擴展java api，并將其父設置為Bootstrap ClassLoader。
-
Bootstrap ClassLoader生成Application ClassLoader，并將其父Loader設置為Extended ClassLoader。
-
最后由AppClass ClassLoader加載classpath目錄下定義的類——HelloWorld類。
我們上面談到 Extended ClassLoader和Application ClassLoader是通過Launcher來創建,現在我們再看看源代碼:
public Launcher() {Launcher.ExtClassLoader var1;try {//實例化ExtClassLoadervar1 = Launcher.ExtClassLoader.getExtClassLoader();} catch (IOException var10) {throw new InternalError("Could not create extension class loader", var10);}try {//實例化AppClassLoaderthis.loader = Launcher.AppClassLoader.getAppClassLoader(var1);} catch (IOException var9) {throw new InternalError("Could not create application class loader", var9);}//主線程設置默認的Context ClassLoader為AppClassLoader.//因此在主線程中創建的子線程的Context ClassLoader 也是AppClassLoaderThread.currentThread().setContextClassLoader(this.loader);String var2 = System.getProperty("java.security.manager");if(var2 != null) {SecurityManager var3 = null;if(!"".equals(var2) && !"default".equals(var2)) {try {var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();} catch (IllegalAccessException var5) {;} catch (InstantiationException var6) {;} catch (ClassNotFoundException var7) {;} catch (ClassCastException var8) {;}} else {var3 = new SecurityManager();}if(var3 == null) {throw new InternalError("Could not create SecurityManager: " + var2);}System.setSecurityManager(var3);}}?
10 非常重要
在這里呢我們需要注意幾個問題:
1. 我們知道ClassLoader通過一個類的全限定名來獲取二進制流,那么如果我們需要通過自定義類加載其來加載一個Jar包的時候,難道要自己遍歷jar中的類,然后依次通過ClassLoader進行加載嗎?或者說我們怎么來加載一個jar包呢?
2. 如果一個類引用的其他的類,那么這個其他的類由誰來加載?
3. 既然類可以由不同的加載器加載,那么如何確定兩個類如何是同一個類?
我們來依次解答這兩個問題: 對于動態加載jar而言,JVM默認會使用第一次加載該jar中指定類的類加載器作為默認的ClassLoader.假設我們現在存在名為sbbic的jar包,該包中存在ClassA和ClassB這兩個類(ClassA中沒有引用ClassB).現在我們通過自定義的ClassLoaderA來加載在ClassA這個類,那么此時此時ClassLoaderA就成為sbbic.jar中其他類的默認類加載器.也就是,ClassB也默認會通過ClassLoaderA去加載.
那么如果ClassA中引用了ClassB呢?當類加載器在加載ClassA的時候,發現引用了ClassB,此時類加載如果檢測到ClassB還沒有被加載,則先回去加載.當ClassB加載完成后,繼續回來加載ClassA.換句話說,類會通過自身對應的來加載其加載其他引用的類.
JVM規定,對于任何一個類,都需要由加載它的類加載器和這個類本身一同確立在java虛擬機中的唯一性,通俗點就是說,在jvm中判斷兩個類是否是同一個類取決于類加載和類本身,也就是同一個類加載器加載的同一份Class文件生成的Class對象才是相同的,類加載器不同,那么這兩個類一定不相同.
?
?
一、什么是 ClassLoader?
?
? ? ? ? ?寫好一個Java程序之后，不是管是CS還是BS應用，都是由若干個.class文件組織而成的一個完整的Java應用程序，當程序在運行時，即會調用該程序的一個入口函數來調用系統的相關功能，而這些功能都被封裝在不同的class文件當中，所以經常要從這個class文件中要調用另外一個class文件中的方法，如果另外一個文件不存在的，則會引發系統異常。而程序在啟動的時候，并不會一次性加載程序所要用的所有class文件，而是根據程序的需要，通過Java的類加載機制（ClassLoader）來動態加載某個class文件到內存當中的，從而只有class文件被載入到了內存之后，才能被其它class所引用。所以ClassLoader就是用來動態加載class文件到內存當中用的。
?
?
二、Java 默認提供的三個 ClassLoader
?
BootStrap ClassLoader：稱為啟動類加載器，是Java類加載層次中最頂層的類加載器，負責加載JDK中的核心類庫，如：rt.jar、resources.jar、charsets.jar等。
Extension ClassLoader：稱為擴展類加載器，負責加載Java的擴展類庫，默認加載JAVA_HOME/jre/lib/ext/目下的所有jar。
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認為它們就是兩個不同的類。
?
4、ClassLoader的體系架構：
?
?
驗證 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配置對話框：
?
置好如圖中所述的參數后，重新運行程序，產的結果如下所示：（類加載的過程，只摘下了一部份）
打印結果：
方式 2：將ClassLoaderTest.jar解壓后，放到JAVA_HOME/jre/classes目錄下，如下圖所示：
提示：jre目錄下默認沒有classes目錄，需要自己手動創建一個
打印結果：
從結果中可以看出，兩種方式都實現了將ClassLoaderTest.class由Bootstrcp ClassLoader加載成功了。
?
?
四、定義自已的 ClassLoader
?
既然 JVM 已經提供了默認的類加載器，為什么還要定義自已的類加載器呢 ？
? ? ? 因為Java中提供的默認ClassLoader，只加載指定目錄下的jar和class，如果我們想加載其它位置的類或jar時，比如：我要加載網絡上的一個class文件，通過動態加載到內存之后，要調用這個類中的方法實現我的業務邏輯。在這樣的情況下，默認的ClassLoader就不能滿足我們的需求了，所以需要定義自己的ClassLoader。
定義自已的類加載器分為兩步：
1、繼承java.lang.ClassLoader
2、重寫父類的findClass方法
讀者可能在這里有疑問，父類有那么多方法，為什么偏偏只重寫findClass方法？
? ? ? 因為JDK已經在loadClass方法中幫我們實現了ClassLoader搜索類的算法，當在loadClass方法中搜索不到類時，loadClass方法就會調用findClass方法來搜索類，所以我們只需重寫該方法即可。如沒有特殊的要求，一般不建議重寫loadClass搜索類的算法。下圖是API中ClassLoader的loadClass方法：
示例：自定義一個 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層次結構
?
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的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Java8 Stream详解~Strea
- 下一篇： 排序子序列