ClassLoader一個經常出現又讓很多人望而卻步的詞,本文將試圖以最淺顯易懂的方式來講解 ClassLoader,希望能對不瞭解該機制的朋友起到一點點作用。
要深入瞭解ClassLoader,首先就要知道ClassLoader是用來幹什麼的,顧名思義,它就是用來加載Class文件到JVM,以供程序使用的。我們知道,java程序可以動態加載類定義,而這個動態加載的機制就是通過ClassLoader來實現的,所以可想而知ClassLoader的重要性如何。
看到這裏,可能有的朋友會想到一個問題,那就是既然ClassLoader是用來加載類到JVM中的,那麼ClassLoader又是如何被加載呢?難道它不是java的類?
沒有錯,在這裏確實有一個ClassLoader不是用java語言所編寫的,而是JVM實現的一部分,這個ClassLoader就是bootstrap classloader(啓動類加載器),這個ClassLoader在JVM運行的時候加載java核心的API以滿足java程序最基本的需求,其中就包括用戶定義的ClassLoader,這裏所謂的用戶定義是指通過java程序實現的ClassLoader,一個是ExtClassLoader,這個ClassLoader是用來加載java的擴展API的,也就是/lib/ext中的類,一個是AppClassLoader,這個ClassLoader是用來加載用戶機器上CLASSPATH設置目錄中的Class的,通常在沒有指定ClassLoader的情況下,程序員自定義的類就由該ClassLoader進行加載。
當運行一個程序的時候,JVM啓動,運行bootstrap classloader,該ClassLoader加載java核心API(ExtClassLoader和AppClassLoader也在此時被加載),然後調用ExtClassLoader加載擴展API,最後AppClassLoader加載CLASSPATH目錄下定義的Class,這就是一個程序最基本的加載流程。
上面大概講解了一下ClassLoader的作用以及一個最基本的加載流程,接下來將講解一下ClassLoader加載的方式,這裏就不得不講一下ClassLoader在這裏使用了雙親委託模式進行類加載。
每一個自定義ClassLoader都必須繼承ClassLoader這個抽象類,而每個ClassLoader都會有一個parent ClassLoader,我們可以看一下ClassLoader這個抽象類中有一個getParent()方法,這個方法用來返回當前ClassLoader的parent,注意,這個parent不是指的被繼承的類,而是在實例化該ClassLoader時指定的一個ClassLoader,如果這個parent爲null,那麼就默認該ClassLoader的parent是bootstrap classloader,這個parent有什麼用呢?
我們可以考慮這樣一種情況,假設我們自定義了一個ClientDefClassLoader,我們使用這個自定義的ClassLoader加載java.lang.String,那麼這裏String是否會被這個ClassLoader加載呢?事實上java.lang.String這個類並不是被這個ClientDefClassLoader加載,而是由bootstrap classloader進行加載,爲什麼會這樣?實際上這就是雙親委託模式的原因,因爲在任何一個自定義ClassLoader加載一個類之前,它都會先委託它的父親ClassLoader進行加載,只有當父親ClassLoader無法加載成功後,纔會由自己加載,在上面這個例子裏,因爲java.lang.String是屬於java核心API的一個類,所以當使用ClientDefClassLoader加載它的時候,該ClassLoader會先委託它的父親ClassLoader進行加載,上面講過,當ClassLoader的parent爲null時,ClassLoader的parent就是bootstrap classloader,所以在ClassLoader的最頂層就是bootstrap classloader,因此最終委託到bootstrap classloader的時候,bootstrap classloader就會返回String的Class。
我們來看一下ClassLoader中的一段源代碼:
protectedsynchronized Class loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
// 首先檢查該name指定的class是否有被加載
Class c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
//如果parent不爲null,則調用parent的loadClass進行加載
= parent.loadClass(name, false);
} else {
//parent爲null,則調用BootstrapClassLoader進行加載
c = findBootstrapClass0(name);
}
} catch (ClassNotFoundException e) {
//如果仍然無法加載成功,則調用自身的findClass進行加載
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
從上面一段代碼中,我們可以看出一個類加載的大概過程與之前我所舉的例子是一樣的,而我們要實現一個自定義類的時候,只需要實現findClass方法即可。
爲什麼要使用這種雙親委託模式呢?
第一個原因就是因爲這樣可以避免重複加載,當父親已經加載了該類的時候,就沒有必要子ClassLoader再加載一次。
第二個原因就是考慮到安全因素,我們試想一下,如果不使用這種委託模式,那我們就可以隨時使用自定義的String來動態替代java核心api中定義類型,這樣會存在非常大的安全隱患,而雙親委託的方式,就可以避免這種情況,因爲String已經在啓動時被加載,所以用戶自定義類是無法加載一個自定義的ClassLoader。
上面對ClassLoader的加載機制進行了大概的介紹,接下來不得不在此講解一下另外一個和ClassLoader相關的類,那就是Class類,每個被ClassLoader加載的class文件,最終都會以Class類的實例被程序員引用,我們可以把Class類當作是普通類的一個模板,JVM根據這個模板生成對應的實例,最終被程序員所使用。
我們看到在Class類中有個靜態方法forName,這個方法和ClassLoader中的loadClass方法的目的一樣,都是用來加載class的,但是兩者在作用上卻有所區別。
Class<?> loadClass(String name)
Class<?> loadClass(String name, boolean resolve)
我們看到上面兩個方法聲明,第二個方法的第二個參數是用於設置加載類的時候是否連接該類,true就連接,否則就不連接。
說到連接,不得不在此做一下解釋,在JVM加載類的時候,需要經過三個步驟,裝載、連接、初始化。裝載就是找到相應的class文件,讀入JVM,初始化就不用說了,最主要就說說連接。
連接分三步,第一步是驗證class是否符合規格,第二步是準備,就是爲類變量分配內存同時設置默認初始值,第三步就是解釋,而這步就是可選的,根據上面loadClass方法的第二個參數來判定是否需要解釋,所謂的解釋根據《深入JVM》這本書的定義就是根據類中的符號引用查找相應的實體,再把符號引用替換成一個直接引用的過程。有點深奧吧,呵呵,在此就不多做解釋了,想具體瞭解就翻翻《深入JVM吧》,呵呵,再這樣一步步解釋下去,那就不知道什麼時候才能解釋得完了。
我們再來看看那個兩個參數的loadClass方法,在JAVA API 文檔中,該方法的定義是protected,那也就是說該方法是被保護的,而用戶真正應該使用的方法是一個參數的那個,一個參數的loadclass方法實際上就是調用了兩個參數的方法,而第二個參數默認爲false,因此在這裏可以看出通過loadClass加載類實際上就是加載的時候並不對該類進行解釋,因此也不會初始化該類。而Class類的forName方法則是相反,使用forName加載的時候就會將Class進行解釋和初始化,forName也有另外一個版本的方法,可以設置是否初始化以及設置ClassLoader,在此就不多講了。
不知道上面對這兩種加載方式的解釋是否足夠清楚,就在此舉個例子吧,例如JDBC DRIVER的加載,我們在加載JDBC驅動的時候都是使用的forName而非是ClassLoader的loadClass方法呢?我們知道,JDBC驅動是通過DriverManager,必須在DriverManager中註冊,如果驅動類沒有被初始化,則不能註冊到DriverManager中,因此必須使用forName而不能用loadClass。
通過ClassLoader我們可以自定義類加載器,定製自己所需要的加載方式,例如從網絡加載,從其他格式的文件加載等等都可以,其實ClassLoader還有很多地方沒有講到,例如ClassLoader內部的一些實現等等,本來希望能夠講得簡單易懂一點,可是結果自己看回頭好像感覺並不怎麼樣,鬱悶,看來自己的文筆還是差太多了,希望能夠給一些有需要的朋友一點幫助吧。
JVM在加載類的時候,都是通過ClassLoader的loadClass()方法來加載class的,loadClass(String name)方法:
使用的是雙親委託模式:
jvm啓動時,會啓動jre/rt.jar裏的類加載器:bootstrap classloader,用來加載java核心api;然後啓動擴展類加載器ExtClassLoader加載擴展類,並加載用戶程序加載器AppClassLoader,並指定ExtClassLoader爲他的父類;
當類被加載時,會先檢查在內存中是否已經被加載,如果是,則不再加載,如果沒有,再由AppClassLoader來加載,先從jar包裏找,沒有再從classpath裏找;
如果自定義loader類,就會存在這命名空間的情況,不同的加載器加載同一個類時,產生的實例其實是不同的;
Java代碼
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
loadClass(String name)方法再調用loadClass(String name, boolean resolve)方法:
◆ name - 類的二進制名稱
◆ resolve - 如果該參數爲 true,則分析這個類
Java代碼
protectedsynchronized Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
// First, check if the class has already been loaded
//JVM 規範規定ClassLoader可以在緩存保留它所加載的Class,如果一個Class已經被加載過,則直接從緩存中獲取
Class c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClass0(name);
}
} catch (ClassNotFoundException e) {
// If still not found, then invoke findClass in order
// to find the class.
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
protectedsynchronized Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
// First, check if the class has already been loaded
//JVM 規範規定ClassLoader可以在緩存保留它所加載的Class,如果一個Class已經被加載過,則直接從緩存中獲取
Class c = findLoadedClass(name);
if (c == null) {
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClass0(name);
}
} catch (ClassNotFoundException e) {
// If still not found, then invoke findClass in order
// to find the class.
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
如果ClassLoader並沒有加載這個class,則調用findBootstrapClass0:
Java代碼
private Class findBootstrapClass0(String name)
throws ClassNotFoundException
{
check();
if (!checkName(name))
thrownew ClassNotFoundException(name);
return findBootstrapClass(name);
}
private Class findBootstrapClass0(String name)
throws ClassNotFoundException
{
check();
if (!checkName(name))
thrownew ClassNotFoundException(name);
return findBootstrapClass(name);
}
該方法會調用check()方法來判斷這個類是否已經初始化,並且通過checkName(name)來判斷由name指定的這個類是否存在最後調用findBootstrapClass(name):
Java代碼
privatenative Class findBootstrapClass(String name)
throws ClassNotFoundException;
privatenative Class findBootstrapClass(String name)
throws ClassNotFoundException;
而這個findBootstrapClass方法是一個native方法,這是我們的root loader,這個載入方法並非是由JAVA所寫,而是C++寫的,它會最終調用JVM中的原生findBootstrapClass方法來完成類的加載。
如果上面兩個都找不到,則使用findClass(name)來查找指定類名的Class:
Java代碼
protected Class<?> findClass(String name) throws ClassNotFoundException {
thrownew ClassNotFoundException(name);
}
protected Class<?> findClass(String name) throws ClassNotFoundException {
thrownew ClassNotFoundException(name);
}
JDK5.0中的說明:
使用指定的二進制名稱查找類。此方法應該被類加載器的實現重寫,該實現按照委託模型來加載類。在通過父類加載器檢查所請求的類後,此方法將被 loadClass 方法調用。默認實現拋出一個ClassNotFoundException。
所以,我們在自定義類中,只需要重寫findClass()即可。
MyClassLoader類:
Java代碼
publicclass MyClassLoader extends ClassLoader {
private String fileName;
public MyClassLoader(String fileName) {
this.fileName = fileName;
}
protected Class<?> findClass(String className) throws ClassNotFoundException {
Class clazz = this.findLoadedClass(className);
if (null == clazz) {
try {
String classFile = getClassFile(className);
FileInputStream fis = new FileInputStream(classFile);
FileChannel fileC = fis.getChannel();
ByteArrayOutputStream baos = new
ByteArrayOutputStream();
WritableByteChannel outC = Channels.newChannel(baos);
ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
while (true) {
int i = fileC.read(buffer);
if (i == 0 || i == -1) {
break;
}
buffer.flip();
outC.write(buffer);
buffer.clear();
}
fis.close();
byte[] bytes = baos.toByteArray();
clazz = defineClass(className, bytes, 0, bytes.length);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
return clazz;
}
privatebyte[] loadClassBytes(String className) throws
ClassNotFoundException {
try {
String classFile = getClassFile(className);
FileInputStream fis = new FileInputStream(classFile);
FileChannel fileC = fis.getChannel();
ByteArrayOutputStream baos = new
ByteArrayOutputStream();
WritableByteChannel outC = Channels.newChannel(baos);
ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
while (true) {
int i = fileC.read(buffer);
if (i == 0 || i == -1) {
break;
}
buffer.flip();
outC.write(buffer);
buffer.clear();
}
fis.close();
return baos.toByteArray();
} catch (IOException fnfe) {
thrownew ClassNotFoundException(className);
}
}
private String getClassFile(String name) {
StringBuffer sb = new StringBuffer(fileName);
name = name.replace('.', File.separatorChar) + ".class";
sb.append(File.separator + name);
return sb.toString();
}
}
publicclass MyClassLoader extends ClassLoader {
private String fileName;
public MyClassLoader(String fileName) {
this.fileName = fileName;
}
protected Class<?> findClass(String className) throws ClassNotFoundException {
Class clazz = this.findLoadedClass(className);
if (null == clazz) {
try {
String classFile = getClassFile(className);
FileInputStream fis = new FileInputStream(classFile);
FileChannel fileC = fis.getChannel();
ByteArrayOutputStream baos = new
ByteArrayOutputStream();
WritableByteChannel outC = Channels.newChannel(baos);
ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
while (true) {
int i = fileC.read(buffer);
if (i == 0 || i == -1) {
break;
}
buffer.flip();
outC.write(buffer);
buffer.clear();
}
fis.close();
byte[] bytes = baos.toByteArray();
clazz = defineClass(className, bytes, 0, bytes.length);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
return clazz;
}
privatebyte[] loadClassBytes(String className) throws
ClassNotFoundException {
try {
String classFile = getClassFile(className);
FileInputStream fis = new FileInputStream(classFile);
FileChannel fileC = fis.getChannel();
ByteArrayOutputStream baos = new
ByteArrayOutputStream();
WritableByteChannel outC = Channels.newChannel(baos);
ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
while (true) {
int i = fileC.read(buffer);
if (i == 0 || i == -1) {
break;
}
buffer.flip();
outC.write(buffer);
buffer.clear();
}
fis.close();
return baos.toByteArray();
} catch (IOException fnfe) {
thrownew ClassNotFoundException(className);
}
}
private String getClassFile(String name) {
StringBuffer sb = new StringBuffer(fileName);
name = name.replace('.', File.separatorChar) + ".class";
sb.append(File.separator + name);
return sb.toString();
}
}
該類中通過調用defineClass(String name, byte[] b, int off, int len)方法來定義一個類:
Java代碼
protectedfinal Class<?> defineClass(String name, byte[] b, int off, int len)
throws ClassFormatError
{
return defineClass(name, b, off, len, null);
}
protectedfinal Class<?> defineClass(String name, byte[] b, int off, int len)
throws ClassFormatError
{
return defineClass(name, b, off, len, null);
}
注:MyClassLoader加載類時有一個侷限,必需指定.class文件,而不能指定.jar文件。該類中的大部分代碼是從網上搜索到的,是出自一牛人之筆,只是不知道原帖在哪,希望不會被隱藏。
MainClassLoader類:
Java代碼
publicclass MainClassLoader {
publicstaticvoid main(String[] args) {
try {
MyClassLoader tc = new MyClassLoader("F:\\OpenLib\\");
Class c = tc.findClass("Test");
c.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}
publicclass MainClassLoader {
publicstaticvoid main(String[] args) {
try {
MyClassLoader tc = new MyClassLoader("F:\\OpenLib\\");
Class c = tc.findClass("Test");
c.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}
最後是一個簡單的Test測試類:
Java代碼
publicclass Test
{
public Test() {
System.out.println("Test");
}
publicstaticvoid main(String[] args) {
System.out.println("Hello World");
}
}