//參考 ： http://www.ibm.com/developerworks/cn/java/j-lo-classloader/

類載入器基本概念

類載入器是 Java 語言的一個創新，也是 Java 語言流行的重要原因之中的一個。它使得 Java 類能夠被動態載入到 Java 虛擬機中並運行。

類載入器從 JDK 1.0 就出現了。最初是為了滿足 Java Applet 的須要而開發出來的。Java Applet 須要從遠程下載 Java 類文件到瀏覽器中並運行。如今類載入器在 Web 容器和 OSGi 中得到了廣泛的使用。一般來說，Java 應用的開發者不須要直接同類載入器進行交互。Java 虛擬機默認的行為就已經足夠滿足大多數情況的需求了。只是假設遇到了須要與類載入器進行交互的情況，而對類載入器的機制又不是非常了解的話，就非常easy花大量的時間去調試ClassNotFoundException

類載入器（class loader）用來載入 Java 類到 Java 虛擬機中。

一般來說，Java 虛擬機使用 Java 類的方式例如以下：Java 源程序（.java 文件）在經過 Java 編譯器編譯之後就被轉換成 Java 字節代碼（.class 文件）。類載入器負責讀取 Java 字節代碼，並轉換成java.lang.Class類的一個實例。每一個這種實例用來表示一個 Java 類。通過此實例的newInstance()方法就能夠創建出該類的一個對象。實際的情況可能更加復雜，比方 Java 字節代碼可能是通過工具動態生成的。也可能是通過網絡下載的。

類載入器是負責載入類的對象。ClassLoader類是一個抽象類。假設給定類的二進制名稱，那麽類載入器會試圖查找或生成構成類定義的數據。一般策略是將名稱轉換為某個文件名稱，然後從文件系統讀取該名稱的“類文件”。

每一個 Class對象都包括一個對定義它的ClassLoader 的引用。應用程序須要實現 ClassLoader 的子類。以擴展 Java 虛擬機動態載入類的方式。

數組類的Class對象不是由類載入器創建的，而是由Java執行時依據須要自己主動創建。數組類的類載入器由Class.getClassLoader()返回，該載入器與其元素類型的類載入器是同樣的；假設該元素類型是基本類型。則該數組類沒有類載入器。

ClassLoader 類使用托付模型來搜索類和資源。

每一個ClassLoader 實例都有一個相關的父類載入器。須要查找類或資源時。ClassLoader 實例會在試圖親自查找類或資源之前，將搜索類或資源的任務托付給其父類載入器。

虛擬機的內置類載入器（稱為 "bootstrap classloader"）本身沒有父類載入器。可是能夠將它用作 ClassLoader 實例的父類載入器。

Java應用環境中不同的class分別由不同的ClassLoader負責載入。

一個jvm中默認的classloader有BootstrapClassLoader、Extension ClassLoader、App ClassLoader、CustomClassLoader，分別各司其職：

BootstrapClassLoader

負責載入java基礎類，主要是 %JRE_HOME/lib/ 文件夾下的rt.jar、resources.jar、charsets.jar和class等

ExtensionClassLoader

負責載入java擴展類，主要是%JRE_HOME/lib/ext 文件夾下的jar和class

AppClassLoader

負責載入當前java應用的classpath中的全部類。

Custom ClassLoader（自己定義ClassLoader）

因為一些特殊的需求，我們可能須要定制ClassLoader的載入行為。這時候就須要自己定義ClassLoader了.自己定義ClassLoader須要繼承ClassLoader抽象類，重寫findClass方法，這種方法定義了ClassLoader查找class的方式。

主要能夠擴展的方法有：

findClass 定義查找Class的方式

defineClass 將類文件字節碼載入為jvm中的class

findResource 定義查找資源的方式

當中Bootstrap ClassLoader是JVM級別的。由C++撰寫；ExtensionClassLoader、App ClassLoader都是java類。都繼承自URLClassLoader超類。

Bootstrap ClassLoader由JVM啟動，然後初始化sun.misc.Launcher 。sun.misc.Launcher初始化ExtensionClassLoader、App ClassLoader。

測試代碼：

public class ClassLoaderTest {
	
	public static void main(String[] args) {
		System.out.println("==========Bootstrap ClassLoader是Java類載入層次中最頂層的類載入器，負責載入JDK中的核心類庫==========");
		java.net.URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
		for (int i = 0; i < urls.length; i++) {
			System.out.println(urls[i].toExternalForm());
		}
		System.out.println("==========尋找程序所須要的類==========");
		System.out.println("Bootstrap ClassLoader所需的包能夠從sun.boot.class.path取得==" + System.getProperty("sun.boot.class.path"));
		System.out.println("Extension ClassLoader所需的包能夠從java.ext.dirs取得==" + System.getProperty("java.ext.dirs"));
		System.out.println("App ClassLoader所需的包能夠從java.class.path取得==" + System.getProperty("java.class.path"));
		
		System.out.println("==========查看父子關系==========");
		ClassLoader cl = Thread.currentThread().getContextClassLoader();
		System.out.println("App ClassLoader::getContextClassLoader==" + cl.toString());
		System.out.println("Extension ClassLoader：：getContextClassLoader.parent==" + cl.getParent().toString());
		System.out.println("Bootstrap ClassLoader::getContextClassLoader.parent.parent==" + cl.getParent().getParent());
	}
}

輸出結果

==========Bootstrap ClassLoader是Java類載入層次中最頂層的類載入器。負責載入JDK中的核心類庫==========
file:/D:/Java/jdk1.7.0_60/jre/lib/resources.jar
file:/D:/Java/jdk1.7.0_60/jre/lib/rt.jar
file:/D:/Java/jdk1.7.0_60/jre/lib/sunrsasign.jar
file:/D:/Java/jdk1.7.0_60/jre/lib/jsse.jar
file:/D:/Java/jdk1.7.0_60/jre/lib/jce.jar
file:/D:/Java/jdk1.7.0_60/jre/lib/charsets.jar
file:/D:/Java/jdk1.7.0_60/jre/lib/jfr.jar
file:/D:/Java/jdk1.7.0_60/jre/classes
==========尋找程序所須要的類==========
Bootstrap ClassLoader所需的包能夠從sun.boot.class.path取得==D:\Java\jdk1.7.0_60\jre\lib\resources.jar;D:\Java\jdk1.7.0_60\jre\lib\rt.jar;D:\Java\jdk1.7.0_60\jre\lib\sunrsasign.jar;D:\Java\jdk1.7.0_60\jre\lib\jsse.jar;D:\Java\jdk1.7.0_60\jre\lib\jce.jar;D:\Java\jdk1.7.0_60\jre\lib\charsets.jar;D:\Java\jdk1.7.0_60\jre\lib\jfr.jar;D:\Java\jdk1.7.0_60\jre\classes
Extension ClassLoader所需的包能夠從java.ext.dirs取得==D:\Java\jdk1.7.0_60\jre\lib\ext;C:\windows\Sun\Java\lib\ext
App ClassLoader所需的包能夠從java.class.path取得==D:\project\huabaocrm\huabaocrm\build\classes;D:\Java\apache-tomcat-7.0.64\lib\annotations-api.jar;D:\Java\apache-tomcat-7.0.64\lib\catalina-ant.jar;D:\Java\apache-tomcat-7.0.64\lib\catalina-ha.jar;D:\Java\apache-tomcat-7.0.64\lib\catalina-tribes.jar;D:\Java\apache-tomcat-7.0.64\lib\catalina.jar;D:\Java\apache-tomcat-7.0.64\lib\ecj-4.4.2.jar;D:\Java\apache-tomcat-7.0.64\lib\el-api.jar;D:\Java\apache-tomcat-7.0.64\lib\jasper-el.jar;D:\Java\apache-tomcat-7.0.64\lib\jasper.jar;D:\Java\apache-tomcat-7.0.64\lib\jsp-api.jar;D:\Java\apache-tomcat-7.0.64\lib\servlet-api.jar;D:\Java\apache-tomcat-7.0.64\lib\tomcat-api.jar;D:\Java\apache-tomcat-7.0.64\lib\tomcat-coyote.jar;D:\Java\apache-tomcat-7.0.64\lib\tomcat-dbcp.jar;D:\Java\apache-tomcat-7.0.64\lib\tomcat-i18n-es.jar;D:\Java\apache-tomcat-7.0.64\lib\tomcat-i18n-fr.jar;D:\Java\apache-tomcat-7.0.64\lib\tomcat-i18n-ja.jar;D:\Java\apache-tomcat-7.0.64\lib\tomcat-jdbc.jar;D:\Java\apache-tomcat-7.0.64\lib\tomcat-util.jar;D:\Java\apache-tomcat-7.0.64\lib\tomcat7-websocket.jar;D:\Java\apache-tomcat-7.0.64\lib\websocket-api.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\aopalliance-1.0.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\aspectjweaver-1.8.8.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\commons-beanutils-1.8.0.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\commons-codec-1.4.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\commons-collections-3.2.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\commons-collections-3.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\commons-digester-2.0.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\commons-fileupload-1.3.1.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\commons-io-1.4.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\commons-lang-2.4.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\commons-logging-1.1.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\dom4j-1.6.1.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\druid-1.0.16.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\ezmorph-0.9.1.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\ezmorph-1.0.6.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\gson-2.2.4.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\jackson-annotations-2.7.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\jackson-core-2.7.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\jackson-core-asl-1.9.13.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\jackson-databind-2.7.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\jackson-mapper-asl-1.9.13.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\json-lib-2.2.3-jdk15.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\json-lib-2.4-jdk15.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\jstl-1.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\log4j-1.2.16.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\mybatis-3.3.0.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\mybatis-generator-core-1.3.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\mybatis-spring-1.2.3.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\mysql-connector-java-5.1.34.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\poi-3.8-20120326.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\poi-ooxml-3.8-20120326.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\poi-ooxml-schemas-3.8-20120326.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\slf4j-api-1.6.4.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\slf4j-log4j12-1.6.4.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-aop-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-aspects-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-beans-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-context-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-context-support-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-core-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-expression-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-jdbc-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-oxm-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-test-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-tx-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-web-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\spring-webmvc-4.2.3.RELEASE.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\tiles-api-2.2.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\tiles-core-2.2.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\tiles-jsp-2.2.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\tiles-servlet-2.2.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\tiles-template-2.2.2.jar;D:\project\huabaocrm\huabaocrm\WebContent\WEB-INF\lib\xmlbeans-2.6.0.jar;D:\software\eclipse-jee-mars-1-win32-x86_64\eclipse\plugins\org.junit_4.12.0.v201504281640\junit.jar;D:\software\eclipse-jee-mars-1-win32-x86_64\eclipse\plugins\org.hamcrest.core_1.3.0.v201303031735.jar
==========查看父子關系==========
App ClassLoader::[email protected]
Extension ClassLoader：：[email protected]9ed5d6
Bootstrap ClassLoader::getContextClassLoader.parent.parent==null

ClassLoader 中與載入類相關的方法（具體查看API）

ClassLoader載入類的原理

1、原理介紹

ClassLoader使用的是雙親托付模型來搜索類的。每一個ClassLoader實例都有一個父類載入器的引用（不是繼承的關系，是一個包括的關系）。虛擬機內置的類載入器（Bootstrap ClassLoader）本身沒有父類載入器，但能夠用作其他ClassLoader實例的的父類載入器。當一個ClassLoader實例須要載入某個類時，它會試圖親自搜索某個類之前。先把這個任務托付給它的父類載入器，這個過程是由上至下依次檢查的。首先由最頂層的類載入器Bootstrap ClassLoader試圖載入，假設沒載入到，則把任務轉交給Extension ClassLoader試圖載入，假設也沒載入到，則轉交給App ClassLoader 進行載入，假設它也沒有載入得到的話，則返回給托付的發起者，由它到指定的文件系統或網絡等URL中載入該類。假設它們都沒有載入到這個類時，則拋出ClassNotFoundException異常。否則將這個找到的類生成一個類的定義。並將它載入到內存其中，最後返回這個類在內存中的Class實例對象。

2、為什麽要使用雙親托付這樣的模型呢？

由於這樣能夠避免反復載入，當父親已經載入了該類的時候，就沒有必要子ClassLoader再載入一次。考慮到安全因素。我們試想一下，假設不使用這樣的托付模式，那我們就能夠隨時使用自己定義的String來動態替代java核心api中定義的類型。這樣會存在很大的安全隱患，而雙親托付的方式，就能夠避免這樣的情況。由於String已經在啟動時就被引導類載入器（Bootstrcp ClassLoader）載入，所以用戶自己定義的ClassLoader永遠也無法載入一個自己寫的String。除非你改變JDK中ClassLoader搜索類的默認算法。

3、 可是JVM在搜索類的時候，又是怎樣判定兩個class是同樣的呢？

JVM在判定兩個class是否同樣時。不僅要推斷兩個類名是否同樣。並且要推斷是否由同一個類載入器實例載入的。僅僅有兩者同一時候滿足的情況下，JVM才覺得這兩個class是同樣的。

就算兩個class是同一份class字節碼，假設被兩個不同的ClassLoader實例所載入。JVM也會覺得它們是兩個不同class。比方網絡上的一個Java類org.classloader.simple.NetClassLoaderSimple，javac編譯之後生成字節碼文件NetClassLoaderSimple.class。ClassLoaderA和ClassLoaderB這兩個類載入器並讀取了NetClassLoaderSimple.class文件，並分別定義出了java.lang.Class實例來表示這個類，對於JVM來說，它們是兩個不同的實例對象，但它們確實是同一份字節碼文件，假設試圖將這個Class實例生成詳細的對象進行轉換時，就會拋執行時異常java.lang.ClassCaseException。提示這是兩個不同的類型。如今通過實例來驗證上述所描寫敘述的是否正確：

1）、在webserver上建一個org.classloader.simple.NetClassLoaderSimple.java類

package org.classloader.simple;  

public class NetClassLoaderSimple {  

    private NetClassLoaderSimple instance;  

    public void setNetClassLoaderSimple(Object obj) {  
        this.instance = (NetClassLoaderSimple)obj;  
    }  
}

org.classloader.simple.NetClassLoaderSimple類的setNetClassLoaderSimple方法接收一個Object類型參數，並將它強制轉換成org.classloader.simple.NetClassLoaderSimple類型。

2）、測試兩個class是否同樣（NetWorkClassLoader.java）

package classloader;  

public class NewworkClassLoaderTest {  

    public static void main(String[] args) {  
        try {  
            //測試載入網絡中的class文件  
            String rootUrl = "http://localhost:8080/httpweb/classes";  
            String className = "org.classloader.simple.NetClassLoaderSimple";  
            NetworkClassLoader ncl1 = new NetworkClassLoader(rootUrl);  
            NetworkClassLoader ncl2 = new NetworkClassLoader(rootUrl);  
            Class<?> clazz1 = ncl1.loadClass(className);  
            Class<?
> clazz2 = ncl2.loadClass(className);  
            Object obj1 = clazz1.newInstance();  
            Object obj2 = clazz2.newInstance();  
            clazz1.getMethod("setNetClassLoaderSimple", Object.class).invoke(obj1, obj2);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  

}

首先獲得網絡上一個class文件的二進制名稱，然後通過自己定義的類載入器NetworkClassLoader創建兩個實例，並依據網絡地址分別載入這份class，並得到這兩個ClassLoader實例載入後生成的Class實例clazz1和clazz2，最後將這兩個Class實例分別生成詳細的實例對象obj1和obj2，再通過反射調用clazz1中的setNetClassLoaderSimple方法。

3）、查看測試結果

結論：從結果中能夠看出。盡管是同一份class字節碼文件，可是因為被兩個不同的ClassLoader實例所載入，所以JVM覺得它們就是兩個不同的類。

4、ClassLoader的體系架構：

驗證ClassLoader載入類的原理：

測試1：打印ClassLoader類的層次結構，請看以下這段代碼：

ClassLoader loader = ClassLoaderTest.class.getClassLoader();    //獲得載入ClassLoaderTest.class這個類的類載入器  
while(loader != null) {  
    System.out.println(loader);  
    loader = loader.getParent();    //獲得父類載入器的引用  
}  
System.out.println(loader);

打印結果：

第一行結果說明：ClassLoaderTest的類載入器是AppClassLoader。

第二行結果說明：AppClassLoader的類加器是ExtClassLoader，即parent=ExtClassLoader。

第三行結果說明：ExtClassLoader的類加器是Bootstrap ClassLoader，由於Bootstrap ClassLoader不是一個普通的Java類，所以ExtClassLoader的parent=null，所以第三行的打印結果為null就是這個原因。

測試2：將ClassLoaderTest.class打包成ClassLoaderTest.jar，放到Extension ClassLoader的載入文件夾下（JAVA_HOME/jre/lib/ext），然後又一次執行這個程序，得到的結果會是什麽樣呢？

打印結果：

打印結果分析：

為什麽第一行的結果是ExtClassLoader呢？

由於ClassLoader的托付模型機制。當我們要用ClassLoaderTest.class這個類的時候，AppClassLoader在試圖載入之前，先托付給Bootstrcp ClassLoader，Bootstracp ClassLoader發現自己沒找到，它就告訴ExtClassLoader。兄弟，我這裏沒有這個類，你去載入看看，然後Extension ClassLoader拿著這個類去它指定的類路徑（JAVA_HOME/jre/lib/ext）試圖載入，唉，它發如今ClassLoaderTest.jar這樣一個文件裏包括ClassLoaderTest.class這種一個文件。然後它把找到的這個類載入到內存其中，並生成這個類的Class實例對象，最後把這個實例返回。所以ClassLoaderTest.class的類載入器是ExtClassLoader。

第二行的結果為null，是由於ExtClassLoader的父類載入器是Bootstrap ClassLoader。

測試3：用Bootstrcp ClassLoader來載入ClassLoaderTest.class，有兩種方式：

1、在jvm中加入-Xbootclasspath參數，指定Bootstrcp ClassLoader載入類的路徑。並追加我們自已的jar（ClassTestLoader.jar）

2、將class文件放到JAVA_HOME/jre/classes/文件夾下（上面有提到）

方式1：（我用的是Eclipse開發工具，用命令行是在java命令後面加入-Xbootclasspath參數）

打開Run配置對話框：

配置好如圖中所述的參數後，又一次執行程序，產的結果例如以下所看到的：（類載入的過程。僅僅摘下了一部份）

打印結果：

[Loaded java.io.FileReader from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded sun.nio.cs.StreamDecoder from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.ArrayList from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.lang.reflect.Array from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.Locale from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.ConcurrentMap from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.ConcurrentHashMap from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.locks.Lock from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.locks.ReentrantLock from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.ConcurrentHashMap$Segment from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.locks.AbstractOwnableSynchronizer from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.locks.AbstractQueuedSynchronizer from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.locks.ReentrantLock$Sync from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.locks.ReentrantLock$NonfairSync from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.locks.AbstractQueuedSynchronizer$Node from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.concurrent.ConcurrentHashMap$HashEntry from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.lang.CharacterDataLatin1 from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.io.ObjectStreamClass from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded sun.net.www.ParseUtil from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.BitSet from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.net.Parts from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.net.URLStreamHandler from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded sun.net.www.protocol.file.Handler from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.util.HashSet from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded sun.net.www.protocol.jar.Handler from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded sun.misc.Launcher$AppClassLoader from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded sun.misc.Launcher$AppClassLoader$1 from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.lang.SystemClassLoaderAction from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Path C:\Program Files\Java\jdk1.6.0_22\jre\classes]  
[Loaded classloader.ClassLoaderTest from C:\Program Files\Java\jdk1.6.0_22\jre\classes]  
null  //這是打印的結果  
C:\Program Files\Java\jdk1.6.0_22\jre\lib\resources.jar;C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar;  
C:\Program Files\Java\jdk1.6.0_22\jre\lib\sunrsasign.jar;C:\Program Files\Java\jdk1.6.0_22\jre\lib\jsse.jar;  
C:\Program Files\Java\jdk1.6.0_22\jre\lib\jce.jar;C:\Program Files\Java\jdk1.6.0_22\jre\lib\charsets.jar;  
C:\Program Files\Java\jdk1.6.0_22\jre\classes;c:\ClassLoaderTest.jar    
//這一段是System.out.println(System.getProperty("sun.boot.class.path"));打印出來的。這個路徑就是Bootstrcp ClassLoader默認搜索類的路徑  
[Loaded java.lang.Shutdown from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]  
[Loaded java.lang.Shutdown$Lock from C:\Program Files\Java\jdk1.6.0_22\jre\lib\rt.jar]

方式2：將ClassLoaderTest.jar解壓後。放到JAVA_HOME/jre/classes文件夾下。例如以下圖所看到的：

提示：jre文件夾下默認沒有classes文件夾。須要自己手動創建一個

打印結果：

從結果中能夠看出，兩種方式都實現了將ClassLoaderTest.class由Bootstrcp ClassLoader載入成功了。

定義自已的ClassLoader

既然JVM已經提供了默認的類載入器，為什麽還要定義自已的類載入器呢？

由於Java中提供的默認ClassLoader，僅僅載入指定文件夾下的jar和class，假設我們想載入其他位置的類或jar時，比方：我要載入網絡上的一個class文件，通過動態載入到內存之後，要調用這個類中的方法實現我的業務邏輯。

在這種情況下。默認的ClassLoader就不能滿足我們的需求了，所以須要定義自己的ClassLoader。

定義自已的類載入器分為兩步：

1、繼承java.lang.ClassLoader

2、重寫父類的findClass方法

讀者可能在這裏有疑問，父類有那麽多方法。為什麽偏偏僅僅重寫findClass方法？

由於JDK已經在loadClass方法中幫我們實現了ClassLoader搜索類的算法，當在loadClass方法中搜索不到類時，loadClass方法就會調用findClass方法來搜索類，所以我們僅僅需重寫該方法就可以。如沒有特殊的要求。一般不建議重寫loadClass搜索類的算法。下圖是API中ClassLoader的loadClass方法：

演示樣例：自己定義一個NetworkClassLoader，用於載入網絡上的class文件

package classloader;  

import java.io.ByteArrayOutputStream;  
import java.io.InputStream;  
import java.net.URL;  

/** 
 * 載入網絡class的ClassLoader 
 */  
public class NetworkClassLoader extends ClassLoader {  

    private String rootUrl;  

    public NetworkClassLoader(String rootUrl) {  
        this.rootUrl = rootUrl;  
    }  

    @Override  
    protected Class<?
> findClass(String name) throws ClassNotFoundException {  
        Class clazz = null;//this.findLoadedClass(name); // 父類已載入     
        //if (clazz == null) {  //檢查該類是否已被載入過  
            byte[] classData = getClassData(name);  //依據類的二進制名稱,獲得該class文件的字節碼數組  
            if (classData == null) {  
                throw new ClassNotFoundException();  
            }  
            clazz = defineClass(name, classData, 0, classData.length);  //將class的字節碼數組轉換成Class類的實例  
        //}   
        return clazz;  
    }  

    private byte[] getClassData(String name) {  
        InputStream is = null;  
        try {  
            String path = classNameToPath(name);  
            URL url = new URL(path);  
            byte[] buff = new byte[1024*4];  
            int len = -1;  
            is = url.openStream();  
            ByteArrayOutputStream baos = new ByteArrayOutputStream();  
            while((len = is.read(buff)) != -1) {  
                baos.write(buff,0,len);  
            }  
            return baos.toByteArray();  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            if (is != null) {  
               try {  
                  is.close();  
               } catch(IOException e) {  
                  e.printStackTrace();  
               }  
            }  
        }  
        return null;  
    }  

    private String classNameToPath(String name) {  
        return rootUrl + "/" + name.replace(".", "/") + ".class";  
    }  

}

測試類：

package classloader;  

public class ClassLoaderTest {  

    public static void main(String[] args) {  
        try {  
            /*ClassLoader loader = ClassLoaderTest.class.getClassLoader();  //獲得ClassLoaderTest這個類的類載入器 
            while(loader != null) { 
                System.out.println(loader); 
                loader = loader.getParent();    //獲得父載入器的引用 
            } 
            System.out.println(loader);*/  

            String rootUrl = "http://localhost:8080/httpweb/classes";  
            NetworkClassLoader networkClassLoader = new NetworkClassLoader(rootUrl);  
            String classname = "org.classloader.simple.NetClassLoaderTest";  
            Class clazz = networkClassLoader.loadClass(classname);  
            System.out.println(clazz.getClassLoader());  

        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  

}

打印結果：

下圖是我機器上webserver的文件夾結構：

眼下經常使用webserver中都定義了自己的類載入器，用於載入web應用指定文件夾下的類庫（jar或class）。如：Weblogic、Jboss、tomcat等，以下我以Tomcat為例，展示該web容器都定義了哪些個類載入器：

1、新建一個webprojecthttpweb

2、新建一個ClassLoaderServletTest，用於打印web容器中的ClassLoader層次結構

import java.io.IOException;  
import java.io.PrintWriter;  

import javax.servlet.ServletException;  
import javax.servlet.http.HttpServlet;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  

public class ClassLoaderServletTest extends HttpServlet {  

    public void doGet(HttpServletRequest request, HttpServletResponse response)  
            throws ServletException, IOException {  

        response.setContentType("text/html");  
        PrintWriter out = response.getWriter();  
        ClassLoader loader = this.getClass().getClassLoader();  
        while(loader != null) {  
            out.write(loader.getClass().getName()+"<br/>");  
            loader = loader.getParent();  
        }  
        out.write(String.valueOf(loader));  
        out.flush();  
        out.close();  
    }  

    public void doPost(HttpServletRequest request, HttpServletResponse response)  
            throws ServletException, IOException {  
        this.doGet(request, response);  
    }  

}

3、配置Servlet。並啟動服務

<?xml version="1.0" encoding="UTF-8"?>  
<web-app version="2.4"   
    xmlns="http://java.sun.com/xml/ns/j2ee"   
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee   

http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

  <servlet>  
    <servlet-name>ClassLoaderServletTest</servlet-name>  
    <servlet-class>ClassLoaderServletTest</servlet-class>  
  </servlet>  

  <servlet-mapping>  
    <servlet-name>ClassLoaderServletTest</servlet-name>  
    <url-pattern>/servlet/ClassLoaderServletTest</url-pattern>  
  </servlet-mapping>  
  <welcome-file-list>  
    <welcome-file>index.jsp</welcome-file>  
  </welcome-file-list>  
</web-app>

4、訪問Servlet，獲得顯示結果

類載入器與 Web 容器

對於執行在 Java EE容器中的 Web 應用來說，類載入器的實現方式與一般的 Java 應用有所不同。

不同的 Web 容器的實現方式也會有所不同。以 Apache Tomcat 來說，每一個 Web 應用都有一個相應的類載入器實例。該類載入器也使用代理模式，所不同的是它是首先嘗試去載入某個類，假設找不到再代理給父類載入器。這與一般類載入器的順序是相反的。

這是 Java Servlet 規範中的推薦做法。其目的是使得 Web 應用自己的類的優先級高於 Web 容器提供的類。

這樣的代理模式的一個例外是：Java 核心庫的類是不在查找範圍之內的。這也是為了保證 Java 核心庫的類型安全。

絕大多數情況下，Web 應用的開發者不須要考慮與類載入器相關的細節。以下給出幾條簡單的原則：

每一個 Web 應用自己的 Java 類文件和使用的庫的 jar 包。分別放在 WEB-INF/classes和 WEB-INF/lib文件夾以下。

多個應用共享的 Java 類文件和 jar 包，分別放在 Web 容器指定的由全部 Web 應用共享的文件夾以下。

當出現找不到類的錯誤時。檢查當前類的類載入器和當前線程的上下文類載入器是否正確。

Java類載入器 ClassLoader的解析