1、什么是類的加載
類的加載指的是將類的.class文件中的二進(jìn)制數(shù)據(jù)讀入到內(nèi)存中，將其放在運行時數(shù)據(jù)區(qū)的方法區(qū)內(nèi)，然后在堆區(qū)創(chuàng)建一個java.lang.Class對象，用來封裝類在方法區(qū)內(nèi)的數(shù)據(jù)結(jié)構(gòu)。類的加載的最終產(chǎn)品是位于堆區(qū)中的Class對象，Class對象封裝了類在方法區(qū)內(nèi)的數(shù)據(jù)結(jié)構(gòu)，并且向Java程序員提供了訪問方法區(qū)內(nèi)的數(shù)據(jù)結(jié)構(gòu)的接口。
類加載器并不需要等到某個類被“首次主動使用”時再加載它，JVM規(guī)范允許類加載器在預(yù)料某個類將要被使用時就預(yù)先加載它，如果在預(yù)先加載的過程中遇到了.class文件缺失或存在錯誤，類加載器必須在程序首次主動使用該類時才報告錯誤（錯誤）如果這個類一直沒有被程序主動使用，那么類加載器就不會報告錯誤
加載.class文件的方式
2、類的生命周期
其中類加載的過程包括了加載、驗證、準(zhǔn)備、解析、初始化五個階段。在這五個階段中，加載、驗證、準(zhǔn)備和初始化這四個階段發(fā)生的順序是確定的，而解析階段則不一定，它在某些情況下可以在初始化階段之后開始，這是為了支持Java語言的運行時綁定（也成為動態(tài)綁定或晚期綁定）。另外注意這里的幾個階段是按順序開始，而不是按順序進(jìn)行或完成c 應(yīng)用程序初始化失敗，因為這些階段通常都是互相交叉地混合進(jìn)行的，通常在一個階段執(zhí)行的過程中調(diào)用或激活另一個階段。
加載
查找并加載類的二進(jìn)制數(shù)據(jù)加載時類加載過程的第一個階段，在加載階段，虛擬機需要完成以下三件事情：
相對于類加載的其他階段而言，加載階段（準(zhǔn)確地說，是加載階段獲取類的二進(jìn)制字節(jié)流的動作）是可控性最強的階段，因為開發(fā)人員既可以使用系統(tǒng)提供的類加載器來完成加載，也可以自定義自己的類加載器來完成加載。
加載階段完成后，虛擬機外部的二進(jìn)制字節(jié)流就按照虛擬機所需的格式存儲在方法區(qū)之中，而且在Java堆中也創(chuàng)建一個java.lang.Class類的對象，這樣便可以通過該對象訪問方法區(qū)中的這些數(shù)據(jù)。
連接
驗證：確保被加載的類的正確性
驗證是連接階段的第一步，這一階段的目的是為了確保Class文件的字節(jié)流中包含的信息符合當(dāng)前虛擬機的要求，并且不會危害虛擬機自身的安全。驗證階段大致會完成4個階段的檢驗動作：
驗證階段是非常重要的，但不是必須的，它對程序運行期沒有影響，如果所引用的類經(jīng)過反復(fù)驗證，那么可以考慮采用-參數(shù)來關(guān)閉大部分的類驗證措施，以縮短虛擬機類加載的時間。
準(zhǔn)備：為類的靜態(tài)變量分配內(nèi)存，并將其初始化為默認(rèn)值
準(zhǔn)備階段是正式為類變量分配內(nèi)存并設(shè)置類變量初始值的階段，這些內(nèi)存都將在方法區(qū)中分配。對于該階段有以下幾點需要注意：
假設(shè)一個類變量的定義為：=3；
那么變量value在準(zhǔn)備階段過后的初始值為0，而不是3，因為這時候尚未開始執(zhí)行任何Java方法，而把value賦值為3的指令是在程序編譯后，存放于類構(gòu)造器（）方法之中的，所以把value賦值為3的動作將在初始化階段才會執(zhí)行。
這里還需要注意如下幾點：
假設(shè)上面的類變量value被定義為：value=3；
編譯時Javac將會為value生成屬性，在準(zhǔn)備階段虛擬機就會根據(jù)的設(shè)置將value賦值為3。我們可以理解為 final常量在編譯期就將其結(jié)果放入了調(diào)用它的類的常量池中
解析：把類中的符號引用轉(zhuǎn)換為直接引用
解析階段是虛擬機將常量池內(nèi)的符號引用替換為直接引用的過程，解析動作主要針對類或接口、字段、類方法、接口方法、方法類型、方法句柄和調(diào)用點限定符7類符號引用進(jìn)行。符號引用就是一組符號來描述目標(biāo)，可以是任何字面量。
直接引用就是直接指向目標(biāo)的指針、相對偏移量或一個間接定位到目標(biāo)的句柄。
初始化
初始化，為類的靜態(tài)變量賦予正確的初始值，JVM負(fù)責(zé)對類進(jìn)行初始化，主要對類變量進(jìn)行初始化。在Java中對類變量進(jìn)行初始值設(shè)定有兩種方式：
JVM初始化步驟
類初始化時機：只有當(dāng)對類的主動使用的時候才會導(dǎo)致類的初始化，類的主動使用包括以下六種：
結(jié)束生命周期
在如下幾種情況下，Java虛擬機將結(jié)束生命周期
3、類加載器
尋找類加載器，先來一個小例子
package com.neo.classloader;
public class ClassLoaderTest {
? ? public static void main(String[] args) {
? ? ? ?ClassLoader loader = Thread.currentThread().getContextClassLoader();
? ? ? ?System.out.println(loader);
? ? ? ?System.out.println(loader.getParent());
? ? ? ?System.out.println(loader.getParent().getParent());
? ?}
}
運行后，輸出結(jié)果：
sun.misc.Launcher$AppClassLoader@64fef26a
sun.misc.Launcher$ExtClassLoader@1ddd40f3
null
從上面的結(jié)果可以看出，并沒有獲取到的父，原因是（引導(dǎo)類加載器）是用C語言實現(xiàn)的，找不到一個確定的返回父的方式，于是就返回null。
這幾種類加載器的層次關(guān)系如下圖所示：
注意：這里父類加載器并不是通過繼承關(guān)系來實現(xiàn)的，而是采用組合實現(xiàn)的。
站在Java虛擬機的角度來講，只存在兩種不同的類加載器：啟動類加載器：它使用C++實現(xiàn)（這里僅限于，也就是JDK1.5之后默認(rèn)的虛擬機，有很多其他的虛擬機是用Java語言實現(xiàn)的），是虛擬機自身的一部分；所有其它的類加載器：這些類加載器都由Java語言實現(xiàn)，獨立于虛擬機之外，并且全部繼承自抽象類java.lang.，這些類加載器需要由啟動類加載器加載到內(nèi)存中之后才能去加載其他的類。
站在Java開發(fā)人員的角度來看，類加載器可以大致劃分為以下三類：
啟動類加載器：，負(fù)責(zé)加載存放在JDK\jre\lib(JDK代表JDK的安裝目錄，下同)下，或被-參數(shù)指定的路徑中的，并且能被虛擬機識別的類庫（如rt.jar，所有的java.開頭的類均被加載）。啟動類加載器是無法被Java程序直接引用的。
擴展類加載器：，該加載器由sun.misc.$實現(xiàn)，它負(fù)責(zé)加載JDK\jre\lib\ext目錄中，或者由java.ext.dirs系統(tǒng)變量指定的路徑中的所有類庫（如javax.開頭的類），開發(fā)者可以直接使用擴展類加載器。
應(yīng)用程序類加載器：er，該類加載器由sun.misc.$來實現(xiàn)，它負(fù)責(zé)加載用戶類路徑（）所指定的類，開發(fā)者可以直接使用該類加載器，如果應(yīng)用程序中沒有自定義過自己的類加載器，一般情況下這個就是程序中默認(rèn)的類加載器。
應(yīng)用程序都是由這三種類加載器互相配合進(jìn)行加載的，如果有必要，我們還可以加入自定義的類加載器。因為JVM自帶的只是懂得從本地文件系統(tǒng)加載標(biāo)準(zhǔn)的java class文件，因此如果編寫了自己的，便可以做到如下幾點：
JVM類加載機制
4、類的加載
類加載有三種方式：
例子：
package com.neo.classloader;
public class loaderTest {
? ? ? ?public static void main(String[] args) throws ClassNotFoundException {
? ? ? ? ? ? ? ?ClassLoader loader = HelloWorld.class.getClassLoader();
? ? ? ? ? ? ? ?System.out.println(loader);
? ? ? ? ? ? ? ?//使用ClassLoader.loadClass()來加載類，不會執(zhí)行初始化塊
? ? ? ? ? ? ? ?loader.loadClass("Test2");
? ? ? ? ? ? ? ?//使用Class.forName()來加載類，默認(rèn)會執(zhí)行初始化塊
? ? ? ? ? ? ? ?//Class.forName("Test2");
? ? ? ? ? ? ? ?//使用Class.forName()來加載類，并指定ClassLoader，初始化時不執(zhí)行靜態(tài)塊
? ? ? ? ? ? ? ?//Class.forName("Test2", false, loader);
? ? ? ?}
}
demo類
public class Test2 {
? ? ? ?static {
? ? ? ? ? ? ? ?System.out.println("靜態(tài)初始化塊執(zhí)行了！");
? ? ? ?}
}
分別切換加載方式，會有不同的輸出結(jié)果。
Class.()和.()區(qū)別
5、雙親委派模型
雙親委派模型的工作流程是：如果一個類加載器收到了類加載的請求，它首先不會自己去嘗試加載這個類c 應(yīng)用程序初始化失敗，而是把請求委托給父加載器去完成，依次向上，因此，所有的類加載請求最終都應(yīng)該被傳遞到頂層的啟動類加載器中，只有當(dāng)父加載器在它的搜索范圍中沒有找到所需的類時，即無法完成該加載，子加載器才會嘗試自己去加載該類。
雙親委派機制:
源碼分析：
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;
? ?}
雙親委派模型意義：
6、自定義類加載器
通常情況下，我們都是直接使用系統(tǒng)類加載器。但是，有的時候，我們也需要自定義類加載器。比如應(yīng)用是通過網(wǎng)絡(luò)來傳輸 Java類的字節(jié)碼，為保證安全性，這些字節(jié)碼經(jīng)過了加密處理，這時系統(tǒng)類加載器就無法對其進(jìn)行加載，這樣則需要自定義類加載器來實現(xiàn)。自定義類加載器一般都是繼承自類，從上面對方法來分析來看，我們只需要重寫 方法即可。下面我們通過一個示例來演示自定義類加載器的流程：
package com.neo.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("E:\\temp");
? ? ? ?Class testClass = null;
? ? ? ?try {
? ? ? ? ? ?testClass = classLoader.loadClass("com.neo.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é)碼則需要在該類中對文件進(jìn)行解密。由于這里只是演示，我并未對class文件進(jìn)行加密，因此沒有解密的過程。這里有幾點需要注意：
