JVM-classloader深入分析

一、什麼是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等，可通過如下程序獲得該類加載器從哪些地方加載了相關的jar或class文件：
[java] view plain copy
1. URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
2. for (int i = 0; i < urls.length; i++) {
3. System.out.println(urls[i].toExternalForm());
4. }
以下內容是上述程序從本機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這個系統屬性所得知的。
[java] view plain copy
1. System.out.println(System.getProperty("sun.boot.class.path"));
打印結果：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
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類

[java]view
plain copy

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是否相同

[java]view
plain copy

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類的層次結構，請看下面這段代碼：

[java]view
plain copy

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配置對話框：

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

打印結果：

[java]view
plain copy

[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.

方式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文件

[java]view
plain copy

ackage 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;    

    }    

    @Override   

    protected 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";    

    }    

}

測試類：

[java]view
plain copy

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層次結構

[java]view
plain copy

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()+"");    

            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，並啓動服務

[java]view
plain copy

<?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，獲得顯示結果

JVM-classloader深入分析

一、什麼是ClassLoader?

三、ClassLoader加載類的原理

1、原理介紹

驗證ClassLoader加載類的原理：

記一次 .NET某工業設計軟件崩潰分析

創建 Vue3 項目

TS + Webpack 整合 Jest

分享5款.NET開源免費的Redis客戶端組件庫

安卓手機如何登錄抖音境外版

golang開發 gorilla websocket的使用

面試官：如果不允許線程池丟棄任務，應該選擇哪個拒絕策略？

嵌入式汽車電子學習路線

Mac卸載 Node npm，升級 Node

uni.showModel內容換行

JAVA結合testng斷言verify(斷言失敗不中斷繼續執行)

JVM-classloader深入分析

git 教程

JVM-FULL-GC

spring ioc原理

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結