一、什么是雙親委派

雙親委派模型工作過程是：如果一個類加載器收到類加載的請求，它首先不會自己去嘗試加載這個類，而是把這個 請求委派給父類加載器完成。每個類加載器都是如此，只有當(dāng)父加載器在自己的搜索范圍內(nèi)找不到指定的類時 （即 ClassNotFoundException ），子加載器才會嘗試自己去加載。

二、為什么需要雙親委派模型？

為什么需要雙親委派模型呢？假設(shè)沒有雙親委派模型，試想一個場景：

黑客自定義一個 java.lang.String 類，該 String 類具有系統(tǒng)的 String 類一樣的功能，只是在某個函數(shù) 稍作修改。比如 equals 函數(shù)，這個函數(shù)經(jīng)常使用，如果在這這個函數(shù)中，黑客加入一些“病毒代碼”。并且 通過自定義類加載器加入到 JVM 中。此時，如果沒有雙親委派模型，那么 JVM 就可能誤以為黑客自定義的 java.lang.String 類是系統(tǒng)的 String 類，導(dǎo)致“病毒代碼”被執(zhí)行。

而有了雙親委派模型，黑客自定義的 java.lang.String 類永遠(yuǎn)都不會被加載進(jìn)內(nèi)存。因為首先是最頂端的類加 載器加載系統(tǒng)的 java.lang.String 類，最終自定義的類加載器無法加載 java.lang.String 類。

或許你會想，我在自定義的類加載器里面強制加載自定義的 java.lang.String 類，不去通過調(diào)用父加載器不就 好了嗎?確實，這樣是可行。但是，在 JVM 中，判斷一個對象是否是某個類型時，如果該對象的實際類型與待比較 的類型的類加載器不同，那么會返回false。

舉個栗子：

ClassLoader1 、 ClassLoader2 都加載 java.lang.String 類，對應(yīng)Class1、Class2對象。那么 Class1 對象不屬于 ClassLoad2 對象加載的 java.lang.String 類型。

三、如何實現(xiàn)雙親委派模型

雙親委派模型的原理很簡單，實現(xiàn)也簡單。每次通過先委托父類加載器加載，當(dāng)父類加載器無法加載時，再自己加 載。其實 ClassLoader 類默認(rèn)的 loadClass 方法已經(jīng)幫我們寫好了，我們無需去寫。

幾個重要函數(shù)

loadClass 默認(rèn)實現(xiàn)如下：

public Class loadClass(String name) throws ClassNotFoundException {

return loadClass(name, false);

}

再看看 loadClass(String name, boolean resolve) 函數(shù)：

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
        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) {
                // 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();
                c = findClass(name);
                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

從上面代碼可以明顯看出， loadClass(String, boolean) 函數(shù)即實現(xiàn)了雙親委派模型！整個大致過程如下：

1. 首先，檢查一下指定名稱的類是否已經(jīng)加載過，如果加載過了，就不需要再加載，直接返回。

2. 如果此類沒有加載過，那么，再判斷一下是否有父加載器；如果有父加載器，則由父加載器加載（即 調(diào)用 parent.loadClass(name, false); ）.或者是調(diào)用 bootstrap 類加載器來加載。

3. 如果父加載器及 bootstrap 類加載器都沒有找到指定的類，那么調(diào)用當(dāng)前類加載器的 findClass 方 法來完成類加載。

換句話說，如果自定義類加載器，就必須重寫 findClass 方法！

findClass 的默認(rèn)實現(xiàn)如下：

protected Class findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}

可以看出，抽象類 ClassLoader 的 findClass 函數(shù)默認(rèn)是拋出異常的。而前面我們知道， loadClass 在父加載 器無法加載類的時候，就會調(diào)用我們自定義的類加載器中的 findeClass 函數(shù)，因此我們必須要在 loadClass 這 個函數(shù)里面實現(xiàn)將一個指定類名稱轉(zhuǎn)換為 Class 對象。

如果是讀取一個指定的名稱的類為字節(jié)數(shù)組的話，這很好辦。但是如何將字節(jié)數(shù)組轉(zhuǎn)為 Class 對象呢？很簡單， Java 提供了 defineClass 方法，通過這個方法，就可以把一個字節(jié)數(shù)組轉(zhuǎn)為Class對象。

defineClass 主要的功能是：

將一個字節(jié)數(shù)組轉(zhuǎn)為 Class 對象，這個字節(jié)數(shù)組是 class 文件讀取后最終的字節(jié)數(shù)組。如，假設(shè) class 文 件是加密過的，則需要解密后作為形參傳入 defineClass 函數(shù)。

defineClass 默認(rèn)實現(xiàn)如下：

protected final Class defineClass(String name, byte[] b, int off, int len) throws ClassFormatError {
return defineClass(name, b, off, len, null);