Java自定義類加載器與雙親委派模型

其實，雙親委派模型並不復雜。自定義類加載器也不難！隨便從網上搜一下就能搜出一大把結果，然后copy一下就能用。但是，如果每次想自定義類加載器就必須搜一遍別人的文章，然后復制，這樣顯然不行。可是自定義類加載器又不經常用，時間久了容易忘記。相信你經常會記不太清loadClass、findClass、defineClass這些函數我到底應該重寫哪一個？它們主要是做什么的？本文大致分析了各個函數的流程，目的就是讓你看完之后，難以忘記！或者說，延長你對自定義類加載器的記憶時間！隨時隨地想自定義就自定義！

1. 雙親委派模型

關於雙親委派模型，網上的資料有很多。我這里只簡單的描述一下，就當是復習。

1.1 什么是雙親委派模型？

首先，先要知道什么是類加載器。簡單說，類加載器就是根據指定全限定名稱將class文件加載到JVM內存，轉為Class對象。如果站在JVM的角度來看，只存在兩種類加載器:

• 啟動類加載器（Bootstrap ClassLoader）：由C++語言實現（針對HotSpot）,負責將存放在<JAVA_HOME>\lib目錄或-Xbootclasspath參數指定的路徑中的類庫加載到內存中。

• 其他類加載器：由Java語言實現，繼承自抽象類ClassLoader。如：

  • 擴展類加載器（Extension ClassLoader）：負責加載<JAVA_HOME>\lib\ext目錄或java.ext.dirs系統變量指定的路徑中的所有類庫。
  • 應用程序類加載器（Application ClassLoader）。負責加載用戶類路徑（classpath）上的指定類庫，我們可以直接使用這個類加載器。一般情況，如果我們沒有自定義類加載器默認就是用這個加載器。

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

類加載器的雙親委派模型

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

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

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

而有了雙親委派模型，黑客自定義的java.lang.String類永遠都不會被加載進內存。因為首先是最頂端的類加載器加載系統的java.lang.String類，最終自定義的類加載器無法加載java.lang.String類。

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

舉個簡單例子：

ClassLoader1、ClassLoader2都加載java.lang.String類，對應Class1、Class2對象。那么Class1對象不屬於ClassLoad2對象加載的java.lang.String類型。

1.3 如何實現雙親委派模型？

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

2. 自定義類加載器

2. 1幾個重要函數

2.1.1 loadClass

loadClass默認實現如下：

public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
}

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

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)函數即實現了雙親委派模型！整個大致過程如下：

1. 首先，檢查一下指定名稱的類是否已經加載過，如果加載過了，就不需要再加載，直接返回。
2. 如果此類沒有加載過，那么，再判斷一下是否有父加載器；如果有父加載器，則由父加載器加載（即調用parent.loadClass(name, false);）.或者是調用bootstrap類加載器來加載。
3. 如果父加載器及bootstrap類加載器都沒有找到指定的類，那么調用當前類加載器的findClass方法來完成類加載。

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

2.1.1 find Class

findClass的默認實現如下：

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

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

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

2.1.1 defineClass

defineClass主要的功能是：

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

defineClass默認實現如下：

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

2.2 函數調用過程

上一節所提的函數調用過程如下：

自定義函數調用過程

2.3 簡單示例

首先，我們定義一個待加載的普通Java類:Test.java。放在com.huachao.cl包下:

package com.huachao.cl;

public class Test {
    public void hello() {
        System.out.println("恩，是的，我是由 " + getClass().getClassLoader().getClass()
                + " 加載進來的");
    }
}

注意：

如果你是直接在當前項目里面創建，待Test.java編譯后，請把Test.class文件拷貝走，再將Test.java刪除。因為如果Test.class存放在當前項目中，根據雙親委派模型可知，會通過sun.misc.Launcher$AppClassLoader 類加載器加載。為了讓我們自定義的類加載器加載，我們把Test.class文件放入到其他目錄。

在本例中，我們Test.class文件存放的目錄如下：

class文件目錄

接下來就是自定義我們的類加載器：

import java.io.FileInputStream;
import java.lang.reflect.Method;

public class Main {
    static class MyClassLoader extends ClassLoader {
        private String classPath;

        public MyClassLoader(String classPath) {
            this.classPath = classPath;
        }

        private byte[] loadByte(String name) throws Exception {
            name = name.replaceAll("\\.", "/");
            FileInputStream fis = new FileInputStream(classPath + "/" + name
                    + ".class");
            int len = fis.available();
            byte[] data = new byte[len];
            fis.read(data);
            fis.close();
            return data;

        }

        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

    };

    public static void main(String args[]) throws Exception {
        MyClassLoader classLoader = new MyClassLoader("D:/test");
        Class clazz = classLoader.loadClass("com.huachao.cl.Test");
        Object obj = clazz.newInstance();
        Method helloMethod = clazz.getDeclaredMethod("hello", null);
        helloMethod.invoke(obj, null);
    }
}

最后運行結果如下：

恩，是的，我是由 class Main$MyClassLoader 加載進來的