Java中類加載機制及熱部署的原理是什么

這篇文章主要介紹了Java中類加載機制及熱部署的原理是什么，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。

一、什么是類加載

類的加載指的是將類的.class文件的二進制數(shù)據(jù)讀入到內(nèi)存中，將其放在運行數(shù)據(jù)區(qū)的方法去，然后再堆區(qū)創(chuàng)建一個java.lang.Class對象，用來封裝類在方法區(qū)的數(shù)據(jù)結(jié)構(gòu)。類的加載的最終產(chǎn)品是位于堆區(qū)中的Class對象，Class對象封裝了類在方法區(qū)的數(shù)據(jù)結(jié)構(gòu)，并且向Java程序員提供了訪問方法區(qū)的數(shù)據(jù)結(jié)構(gòu)的接口。

類加載器并不需要等到某個類被"首次主動使用"時再加載它，JVM規(guī)范允許類加載器在預(yù)料某個類將要被使用時就預(yù)先加載它，如果在預(yù)先加載的過程中遇到了.class文件的缺失或存在錯誤，類加載器必須在程序首次主動使用該類時才報告錯誤(LinkageError錯誤)如果這個類一直沒有被程序主動使用，那么類加載器就不會報告錯誤。

那么加載.class文件的方式如下：

• 從本地系統(tǒng)中直接加載

• 通過網(wǎng)絡(luò)下載.class文件

• 從zip、jar等歸檔文件中加載.class文件

• 從專有數(shù)據(jù)庫中提取.class文件

• 將Java源文件動態(tài)編譯為.class文件

二、類的生命周期

其中類加載的過程包括了加載、驗證、準備、解析、初始化五個階段。在這5個階段中，加載、驗證、準備和初始化這四個階段發(fā)生的順序是確定的，而解析的階段則不一定，它在某些情況下可以在初始化階段之后開始，這是為了支持Java語言的運行時綁定（也成為動態(tài)綁定或晚期綁定）。另外注意這里的幾個階段是按順序開始，而不是按順序進行或完成，因為這些階段通常都是互相交互地混合進行的，通常在一個階段執(zhí)行的過程中調(diào)用或激活另一個階段。

2.1 加載

查找并加載類的二進制數(shù)據(jù)

加載時類加載過程的第一個階段，在加載階段，虛擬機需要完成以下三件事情：

1.通過一個類的全限定名來獲取其定義的二進制字節(jié)流。

2.將這個字節(jié)流所代表的靜態(tài)存儲結(jié)構(gòu)轉(zhuǎn)化為方法區(qū)的運行時數(shù)據(jù)結(jié)構(gòu)。

3.在Java堆中生成一個代表這個類的java.lang.Class對象，作為對方法區(qū)中這些數(shù)據(jù)的訪問入口。

相對于類加載的其他階段而言，加載階段（準確地說，是加載階段獲取類的二進制的二進制字節(jié)流的動作）是可控性最強的階段，因為開發(fā)人員既可以使用系統(tǒng)提供的類加載器來完成加載，也可以自定義自己的類加載器來完成加載。

加載階段完成后，虛擬機外部的二進制字節(jié)流就按照虛擬機所需的格式存儲在方法區(qū)之中，而在Java堆中也創(chuàng)建一個java.lang.Class類的對象，這樣便可以通過該對象訪問方法區(qū)中的這些數(shù)據(jù)。

2.2 連接

驗證：確保被加載的類的正確性

驗證是連接階段的第一步，這一階段的目的是為了確保Class文件的字節(jié)流中包含的信息符合當前虛擬機的要求，并且不會危害虛擬機自身的安全。驗證階段大致會完成4個階段的校驗動作。

• 文件格式驗證：驗證字節(jié)流是否符合Class文件格式的規(guī)范；例如：是否以0xCAFEBABE開頭、主次版本號是否在單簽虛擬機的處理范圍之內(nèi)、常量池中的常量是否有不被支持的類型。

• 元數(shù)據(jù)驗證：對字節(jié)碼描述的信息進行語義分析（注意：對比javac編譯階段的語義分析），以保證其描述信息符合java語言的規(guī)范的要求；例如：這個類是否有父類，除了java.lang.Object之外。

• 字節(jié)碼驗證：通過數(shù)據(jù)流和控制流分析，確定程序語義是合法的、符合邏輯的。

• 符合引用驗證：確保解析動作能正確執(zhí)行。

驗證階段是非常重要的，但不是必須的，它對程序運行期沒有影響，如果所引用的類經(jīng)過反復(fù)驗證，那么可以考慮采用-Xverifynone參數(shù)來關(guān)閉大部分的類驗證措施，以縮短虛擬機類加載的時間。

準備：為類的靜態(tài)變量分配內(nèi)存，并將其初始化為默認值

準備階段是正式為類變量分配內(nèi)存并設(shè)置類變量初始值的階段，這些內(nèi)存都將在方法區(qū)中分配。對于該階段有以下幾點需要注意：

1.這時候進行內(nèi)存分配的僅包括類變量(static),而不包括實例變量，實例變量會在對象實例化時隨著對象一塊分配在java堆中。

2.這里鎖設(shè)置的初值通常情況下是數(shù)據(jù)類型默認的零值(如0、0L、null、false等)，而不是被在java代碼中被顯示地賦予的值。

假設(shè)一個類變量的定義為:public static int value = 3;

那么變量value在準備階段過后的初始值為0，而不是3，因為這時候尚未開始執(zhí)行任何Java方法，而把value賦值為3的putstatic指令是在程序編譯后，存放于類構(gòu)造器()方法之中的，所以把value賦值為3動作將在初始化階段才會執(zhí)行。

注意：

(1)對基本數(shù)據(jù)類型來說，對于類變量(static)和全局變量，如果不顯示地對其賦值而直接使用，則系統(tǒng)會為其默認的零值，而對于局部變量來說，在使用前必須顯示地為其賦值，否則編譯時不通過。

(2)對于同時被static和final修飾的常量，必須在聲明的時候就為其顯示地賦值，否則編譯時不通過；而只被final修飾的常量則既可以在聲明時顯示地為其賦值，也可以在類初始化時顯示地為其賦值，總之，在使用前必須為其顯示地的賦值，系統(tǒng)不會為其賦予默認零值。

(3)對于引用數(shù)據(jù)類型reference來說，如數(shù)組引用、對象引用等，如果沒有對其進行顯示地賦值而直接使用，系統(tǒng)都會為其賦予默認的零值，即null。

(4)如果在數(shù)組初始化時沒有對數(shù)組中的各元素賦值，那么其中的元素將根據(jù)對應(yīng)的數(shù)據(jù)類型而被賦予零值。

3.如果類字段的字段屬性表中存在ConstantValue屬性，即同時被final和static修飾，那么在準備的階段變量value就會被初始化為ConstantValue屬性所指定的值。

假設(shè)上面的類變量value被定義為：public static final int value = 3;

編譯時javac將會為value生成ConstantValue屬性，在準備階段虛擬機就會根據(jù)ConstantValue的設(shè)置將value賦值為3.我們可以理解為static final常量在編譯期就將其結(jié)果放入了調(diào)用它的類的常量池中。

解析：把類中的符合引用轉(zhuǎn)換為直接引用

解析階段是虛擬機將常量池內(nèi)的符號引用替換為直接引用的過程，解析動作主要針對類或接口、字段、類方法、接口方法、方法類型、方法句柄和調(diào)用點限定符7類符號引用進行。符號引用就是一組符號來描述目標，可以是任何字面量。

直接引用就是直接指向目標的指針、相對偏移量或一個間接定位到目標的句柄。

2.3 初始化

初始化，為類的靜態(tài)變量賦予正確的初始值，JVM負責(zé)對類進行初始化，主要對類變量進行初始化。在java中對類變量進行初始值設(shè)定有兩種方式：

1.聲明類變量是指定初始值

2.使用靜態(tài)代碼塊為類變量指定初始值

JVM初始化步驟：

1.假設(shè)這個類還沒有被加載和連接，則程序先加載并連接該類

2.假設(shè)該類的直接父類還沒有被初始化，則先初始化其直接父類

3.假設(shè)類中有初始化語句，則系統(tǒng)依次執(zhí)行這些初始化代碼

類初始化時機：只有當對類的主動使用的時候才會導(dǎo)致類的初始化，類的主動使用包括以下六種：

1.創(chuàng)建類的實例，也就是new的方式

2.訪問某個類或接口的靜態(tài)變量，或者對該靜態(tài)變量賦值

3.調(diào)用類的靜態(tài)方法

4.反射

5.初始化某個類的子類，則其父類也厚被初始化

6.Java虛擬機啟動時被標明為啟動類的類，直接使用java.exe命令來運行某個主類。

2.4 結(jié)束生命周期

在如下幾種情況下，Java虛擬機將結(jié)束生命周期

1.執(zhí)行了System.exit()方法

2.程序正常執(zhí)行結(jié)束

3.程序在執(zhí)行過程中遇到了異?；蝈e誤而異常終止

4.由于操作系統(tǒng)出現(xiàn)錯誤而導(dǎo)致Java虛擬機進程終止

三、類加載器

我們先來寫一個類，看看java類的內(nèi)置了哪些的加載器，具體的代碼如下：

package com.ys.classLoader;

public class FindClassLoaderTest {

    public static void main(String[] args) {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        System.out.println(classLoader);
        System.out.println(classLoader.getParent());
        System.out.println(classLoader.getParent().getParent());
    }
}

運行的結(jié)果如下：

從上圖的結(jié)果可以看出，并沒有獲取到ExtClassLoader的父Loader，原因是BootstrapLoader（引導(dǎo)類加載器）是用C語言實現(xiàn)的，找不到一個確定的返回父Loader的方式，于是就返回null。

這幾種類加載器的層次的關(guān)系如下圖所示：

注意：這里的父類加載器并不是通過繼承的關(guān)系來實現(xiàn)的，而是采用組合實現(xiàn)的。

站在Java虛擬機的角度來講，只存在兩種不同的類加載器：

1.啟動類加載器：它使用C++實現(xiàn)，是虛擬機自身的一部分

2.所有其他的類加載：這些類加載器都由Java語言實現(xiàn)，獨立于虛擬機之外，并且全部繼承抽象類java.lang.ClassLoader，這些類加載器需要由啟動類加載器加載到內(nèi)存中之后才能去加載其他的類。

站在java開發(fā)人員的角度來看，類加載器可以大致劃分以下三類：

1.啟動類加載器：Bootstrap ClassLoader，負責(zé)加載存放在JDK\jre\lib(JDK代表JDK的安裝目錄，下同)下，或被-Xbootclasspath參數(shù)指定的路徑中的，并且能被虛擬機識別的類庫(如rt.jar,所有的java.*開頭的類均被BootstrapClassLoader加載)。啟動類加載器是無法被java程序直接引用的。

2.擴展類加載器：Extension ClassLoader，該加載器由sun.misc.Launcher$ExtClassLoader實現(xiàn)，它負責(zé)加載JDK\jre\lib\ext目錄中，或者由java.ext.dirs系統(tǒng)變量指定的路徑中的所有的類庫(如javax.*開頭的類)，開發(fā)者可以直接使用擴展類加載器。

3.應(yīng)用程序類加載器：Application ClassLoader，該類加載器由sun.misc.Launcher$AppClassLoader來實現(xiàn)，它負責(zé)加載用戶類路徑(ClassPath)所指定的類，開發(fā)者可以直接使用該類加載器，如果應(yīng)用程序中沒有自定義過自己的類加載器，一般情況下這個就是程序中默認的類加載器。

應(yīng)用程序都是由這三種類加載器相互配合進行加載的，如果有必要，我們可以加入自定義的類加載器。因為JVM自帶的ClassLoader只是懂得從本地文件系統(tǒng)加載標準的java class文件，因此如果編寫自己的ClassLoader，便可以做到如下幾點：

1.在執(zhí)行非置信的代碼之前，自動驗證數(shù)字簽名。

2.動態(tài)地創(chuàng)建符合用戶特定需要的定制化構(gòu)建類。

3.從特定的場所取得java Class，例如數(shù)據(jù)庫中和網(wǎng)絡(luò)中。

四、Java類加載機制

全盤負責(zé)：當一個類加載器負責(zé)加載某個Class時，該Class所依賴的和引用的其他Class也將由該類加載器負責(zé)載入，除非顯示使用另外一個類加載器來載入。

父親委托：先讓父類加載器試圖加載該類，只有在父類加載器無法加載該類時才嘗試從自己的類路徑中加載該類。

緩存機制：緩存機制將會保證所有加載過的Class都會被緩存，當程序中需要使用某個Class時，類加載器先從緩存區(qū)尋找該Class，只有當緩存區(qū)不存在，系統(tǒng)才會讀取該類對應(yīng)的二進制數(shù)據(jù)，并將其轉(zhuǎn)換成Class對象，存入緩存區(qū)。這就是為什么修改了Class后，必須重啟JVM，程序的修改才會生效。

五、類的加載

類加載有三種方式：

1.命令行啟動應(yīng)用時候由JVM初始化加載

2.通過Class.forName()方法動態(tài)加載

3.通過ClassLodaer.loadClass()方法動態(tài)加載

測試的代碼如下：

package com.ys.classLoader;

public class LoadClassTest {
    public static void main(String[] args) throws Exception {
        ClassLoader classLoader = LoadClassTest.class.getClassLoader();
        System.out.println(classLoader);

        //使用ClassLoader.loadClass()來加載類，不會執(zhí)行初始化代碼
        //classLoader.loadClass("com.ys.classLoader.Test1");

        //使用Class.forName()來加載類，會默認執(zhí)行初始化代碼
        //Class.forName("com.ys.classLoader.Test1");

        //使用Class.forName()來加載類，并指定類加載器，不會執(zhí)行初始化代碼
        Class.forName("com.ys.classLoader.Test1", false, classLoader);
    }
}

package com.ys.classLoader;

public class Test1 {
    static {
        System.out.println("靜態(tài)初始化代碼執(zhí)行了....");
    }
}

Class.forName()和ClassLoader.loadClass()區(qū)別

Class.forName()：將類的.class文件加載到j(luò)vm中之外，還會對類進行解釋，執(zhí)行類中的static塊；

ClassLoader.loadClass()：只干一件事情，就是將.class文件加載到j(luò)vm中，不會執(zhí)行static中的內(nèi)容，只有在newInstance才會去執(zhí)行static塊。

Class.forName(name,initialize,loader)帶參函數(shù)也可控制是否加載static塊。并且只有調(diào)用了newInstance()方法采用調(diào)用構(gòu)造函數(shù)，創(chuàng)建類的對象。

六、雙親委派模型

雙親委派模型的工作流程是：如果一個類加載器收到了類加載的請求，它首先不會自己去嘗試加載這個類，而是把請求委托給父加載器去完成，依次向上，因此，所有的類加載請求最終都應(yīng)該被傳遞到頂層的啟動類加載器中，只有當父加載器在它搜索范圍中沒有找到所需的類時，即無法完成該加載，子加載器才會嘗試自己去加載該類。

具體的過程：

1.當AppClassLoader加載一個Class時，它首先不會自己去嘗試加載這個類，而是把類加載請求委托給父類加載器ExtClassLoader去完成。

2.當ExtClassLoader加載一個Class時，它首先也不會字節(jié)去嘗試加載這個類，而是把類加載請求委派給BootstrapClassLoader去完成。

3.如果BootstrapClassLoader加載失敗，會使用ExtClassLoader來嘗試加載

4.若ExtClassLoader也加載失敗，則會使用AppClassLoader來加載，如果AppClassLoader也加載失敗，則會報出異常ClassNotFoundException。

ClassLoader源碼分析：

public Class<?> loadClass(String name)throws ClassNotFoundException {
  return loadClass(name, false);
}
    
protected synchronized Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException {
  // 首先判斷該類型是否已經(jīng)被加載
  Class c = findLoadedClass(name);
  if (c == null) {
    //如果沒有被加載，就委托給父類加載或者委派給啟動類加載器加載
    try {
      if (parent != null) {
        //如果存在父類加載器，就委派給父類加載器加載
        c = parent.loadClass(name, false);
      } else {
        //如果不存在父類加載器，就檢查是否是由啟動類加載器加載的類，通過調(diào)用本地方法native Class findBootstrapClass(String name)
        c = findBootstrapClass0(name);
      }
    } catch (ClassNotFoundException e) {
      // 如果父類加載器和啟動類加載器都不能完成加載任務(wù)，才調(diào)用自身的加載功能
      c = findClass(name);
    }
  }
  if (resolve) {
    resolveClass(c);
  }
  return c;
}

雙親委派模型的意義：

• 系統(tǒng)類防止內(nèi)存中出現(xiàn)多份同樣的字節(jié)碼

• 保證java程序安全穩(wěn)定運行。

七、自定義加載器的應(yīng)用

7.1 熱部署

我們都知道JVM中有緩存的機制，所以這也會導(dǎo)致我們修改的類，必須重啟JVM虛擬機，才會加載新的類，從而達成修改的目的。那我們可不可以通過自己寫的類加載器，然后在類的修改的同時，我們讓自定義類加載來重新加載我們修改的類。

通過上面的源碼的閱讀和雙親委派的機制，我們這兒寫的自定義的類加載器，如果在不打破雙親委派機制的話，那么我們寫的自定義類加載器將不會工作。所以我們這兒要打破雙親委派機制。

我們先寫一個自定義的類加載器，具體的代碼如下：

package com.classloader;

import com.Application;
import com.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

public class MyClassLoader extends ClassLoader {

    //目的 讓緩存里面永遠能返回一個Class對象 這樣就不需要走父類加載器了
    //在構(gòu)造方法里面加載類  loadClass

    //項目的根路徑
    public String rootPath;

    //所有需要由我這個類加載器加載的類存在這個集合
    public List<String> clazzs;
    //兩個classloader  一個是負責(zé)加載 需要被熱部署的代碼的
    //一個是加載系統(tǒng)的一些類的

    //classPaths: 需要被熱部署的加載器去加載的目錄
    public MyClassLoader(String rootPath, String... classPaths) throws Exception {
        this.rootPath = rootPath;
        this.clazzs = new ArrayList<>();
        for (String classPath : classPaths) {
            scanClassPath(new File(classPath));
        }
    }


    //掃描項目里面?zhèn)鬟M來的一些class
    public void scanClassPath(File file) throws Exception {
        if (file.isDirectory()) {
            for (File file1 : file.listFiles()) {
                scanClassPath(file1);
            }
        } else {
            String fileName = file.getName();
            String filePath = file.getPath();
            String endName = fileName.substring(fileName.lastIndexOf(".") + 1);
            if (endName.equals("class")) {
                //現(xiàn)在我們加載到的是一個Class文件
                //如何吧一個Class文件 加載成一個Class對象？？？？
                InputStream inputStream = new FileInputStream(file);
                byte[] bytes = new byte[(int) file.length()];
                inputStream.read(bytes);

                //文件名轉(zhuǎn)類名
                String className = fileNameToClassName(filePath);

                //類名
                defineClass(className, bytes, 0, bytes.length);
                clazzs.add(className);
                //loadClass 是從當前ClassLoader里面去獲取一個Class對象
            }
        }

    }

    //文件名轉(zhuǎn)類名，這兒操作系統(tǒng)不同可能文件的分隔符不一樣，所以這兒需要注意，筆者用的Mac。Windows操作需要自行修改。
    public String fileNameToClassName(String filePath) {
        String className = filePath.replace(rootPath, "").replaceAll("/", ".");
        className = className.substring(1, className.lastIndexOf("."));
        return className;
    }

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        Class<?> loadClass = findLoadedClass(name);
        //第一情況 這個類 不需要由我們加載
        //第二種情況 這個類需要由我們加載 但是 確實加載不到
        if (loadClass == null) {
            if (!clazzs.contains(name)) {
                loadClass = getSystemClassLoader().loadClass(name);
            } else {
                throw new ClassNotFoundException("沒有加載到類");
            }
        }
        return loadClass;
    }

    //當文件被修改的時候再進行熱部署
    public static void main(String[] args) throws Exception {
        //雙親委派機制
        Application.run(MyClassLoader.class);
    }
}

Application類

package com;

import com.classloader.MyClassLoader;
import org.apache.commons.io.monitor.FileAlterationMonitor;
import org.apache.commons.io.monitor.FileAlterationObserver;

import java.io.File;

public class Application {

    public static String rootPath;

    public static void run(Class<?> clazz) throws Exception {
        String rootPath = MyClassLoader.class.getResource("/").getPath().replaceAll("%20", " ");
        rootPath = new File(rootPath).getPath();
        Application.rootPath = rootPath;
        MyClassLoader myClassLoader = new MyClassLoader(rootPath, rootPath + "/com");
        //用我們自己的類加載器加載程序入口
        startFileListener(rootPath);
        start0(myClassLoader);
    }

  //開啟文件監(jiān)聽器
    public static void startFileListener(String rootPath) throws Exception {
        FileAlterationObserver fileAlterationObserver = new FileAlterationObserver(rootPath);
        fileAlterationObserver.addListener(new FileListener());
        FileAlterationMonitor fileAlterationMonitor = new FileAlterationMonitor(500);
        fileAlterationMonitor.addObserver(fileAlterationObserver);
        fileAlterationMonitor.start();
        //要實現(xiàn)文件監(jiān)聽：  寫一個線程 去定時監(jiān)聽某個路徑下所有的文件
        //如果文件發(fā)生改動 就回調(diào)監(jiān)聽器
    }

    //新的classLoader
    public static void start() {
        System.out.println("啟動我們的應(yīng)用程序");
        new Test().test();
    }

    public static void stop() {
        System.out.println("程序退出");
        //告訴jvm需要gc了
        System.gc();
        //告訴jvm可以清除對象引用
        System.runFinalization();
    }

    public static void start0(MyClassLoader classLoader) throws Exception {
      //全盤委托的機制，通過自定義的類加載加載，然后start方法中的new Test()也會通過自定義的類加載器加載
        Class<?> aClass = classLoader.loadClass("com.Application");
        aClass.getMethod("start").invoke(aClass.newInstance());
    }

}

文件監(jiān)聽器代碼：

package com;

import com.classloader.MyClassLoader;
import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;

import java.io.File;

public class FileListener extends FileAlterationListenerAdaptor {

    @Override
    public void onFileChange(File file) {
        if (file.getName().indexOf(".class") != -1) {
            try {
                MyClassLoader myClassLoader = new MyClassLoader(Application.rootPath, Application.rootPath + "/com");
                Application.stop();
                Application.start0(myClassLoader);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Test類的代碼如下：

package com;

public class Test {

    public void test() {
        System.out.println("當前版本:version 1.0");
        System.out.println(this.getClass().getClassLoader());
    }
}

運行結(jié)果如下，當我們修改了Test的源碼，然后點擊一下編譯，就會打印修改后的信息，具體如下：7.2 網(wǎng)絡(luò)傳輸?shù)腃lass加密

通常情況下，我們都是直接使用系統(tǒng)類加載器。但是，有的時候，我們也需要自定義類加載器。比如應(yīng)用是通過網(wǎng)絡(luò)來傳輸 Java 類的字節(jié)碼，為保證安全性，這些字節(jié)碼經(jīng)過了加密處理，這時系統(tǒng)類加載器就無法對其進行加載，這樣則需要自定義類加載器來實現(xiàn)。自定義類加載器一般都是繼承自 ClassLoader 類，從上面對 loadClass 方法來分析來看，我們只需要重寫 findClass 方法即可。下面我們通過一個示例來演示自定義類加載器的流程：

package com.ys.classloader;

import java.io.*;


public class MyClassLoader extends ClassLoader {

    private String root;

    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }

    private byte[] loadClassData(String className) {
        String fileName = root + File.separatorChar
                + className.replace('.', File.separatorChar) + ".class";
        try {
            InputStream ins = new FileInputStream(fileName);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
            int length = 0;
            while ((length = ins.read(buffer)) != -1) {
                baos.write(buffer, 0, length);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public String getRoot() {
        return root;
    }

    public void setRoot(String root) {
        this.root = root;
    }

    public static void main(String[] args)  {

        MyClassLoader classLoader = new MyClassLoader();
        classLoader.setRoot("/User/king/temp");

        Class<?> testClass = null;
        try {
            testClass = classLoader.loadClass("com.ys.classloader.Test2");
            Object object = testClass.newInstance();
            System.out.println(object.getClass().getClassLoader());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

自定義類加載器的核心在于對字節(jié)碼文件的獲取，如果是加密的字節(jié)碼則需要在該類中對文件進行解密。由于這里只是演示，我并未對class文件進行加密，因此沒有解密的過程。

感謝你能夠認真閱讀完這篇文章，希望小編分享的“Java中類加載機制及熱部署的原理是什么”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關(guān)注億速云行業(yè)資訊頻道，更多相關(guān)知識等著你來學(xué)習(xí)!