轉載自:https://www.cnblogs.com/wxd0108/p/6681618.html
其實,雙親委派模型並不複雜。自定義類加載器也不難!隨便從網上搜一下就能搜出一大把結果,然後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)
函數即實現了雙親委派模型!整個大致過程如下:
- 首先,檢查一下指定名稱的類是否已經加載過,如果加載過了,就不需要再加載,直接返回。
- 如果此類沒有加載過,那麼,再判斷一下是否有父加載器;如果有父加載器,則由父加載器加載(即調用
parent.loadClass(name, false);
).或者是調用bootstrap
類加載器來加載。- 如果父加載器及
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 加載進來的
熬夜不易,點擊請老王喝杯烈酒!!!!!!!