深刻分析Java ClassLoader原理

時間  2019-11-29
標籤 深刻 分析 java classloader 原理 欄目 Java 简体版
原文   原文鏈接

ImportNew

- 導航條 -<OPTION value=http://www.importnew.com/>首頁<OPTION value=http://www.importnew.com/all-posts>全部文章<OPTION value=http://www.importnew.com/cat/news>資訊<OPTION value=http://www.importnew.com/cat/web-development>Web<OPTION value=http://www.importnew.com/cat/architecture>架構<OPTION value=http://www.importnew.com/cat/basic>基礎技術<OPTION value=http://www.importnew.com/cat/books>書籍<OPTION value=http://www.importnew.com/cat/tutorial>教程<OPTION value=http://top.jobbole.com/>我要投稿<OPTION value=http://www.importnew.com/15362.html#>更多頻道 »<OPTION value=http://ios.jobbole.com/>- iOS<OPTION value=http://python.jobbole.com/>- Python<OPTION value=http://android.jobbole.com/>- Android<OPTION value=http://web.jobbole.com/>- Web前端

深刻分析Java ClassLoader原理

2015/03/19 | 分類： 基礎技術 | 3 條評論 | 標籤： CLASSLOAD

分享到：41

原文出處： CSDN-xyang81

1、什麼是ClassLoader?

你們都知道，當咱們寫好一個Java程序以後，不是管是CS仍是BS應用，都是由若干個.class文件組織而成的一個完整的Java應用程序，當程序在運行時，即會調用該程序的一個入口函數來調用系統的相關功能，而這些功能都被封裝在不一樣的class文件當中，因此常常要從這個class文件中要調用另一個class文件中的方法，若是另一個文件不存在的，則會引起系統異常。而程序在啓動的時候，並不會一次性加載程序所要用的全部class文件，而是根據程序的須要，經過Java的類加載機制（ClassLoader）來動態加載某個class文件到內存當中的，從而只有class文件被載入到了內存以後，才能被其它class所引用。因此ClassLoader就是用來動態加載class文件到內存當中用的。

2、Java默認提供的三個ClassLoader

  1. BootStrap ClassLoader：稱爲啓動類加載器，是Java類加載層次中最頂層的類加載器，負責加載JDK中的核心類庫，如：rt.jar、resources.jar、charsets.jar等，可經過以下程序得到該類加載器從哪些地方加載了相關的jar或class文件：

    1
    2
    3
    4
    URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs(); 
    for ( int i = 0 ; i < urls.length; i++) { 
         System.out.println(urls[i].toExternalForm()); 
    }

    如下內容是上述程序從本機JDK環境所得到的結果：
    file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/resources.jar
    file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/rt.jar
    file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/sunrsasign.jar
    file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/jsse.jar
    file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/jce.jar
    file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/lib/charsets.jar
    file:/C:/Program%20Files/Java/jdk1.6.0_22/jre/classes/
    其實上述結果也是經過查找sun.boot.class.path這個系統屬性所得知的。

    1
    System.out.println(System.getProperty( "sun.boot.class.path" ));

    打印結果：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

  2. Extension ClassLoader：稱爲擴展類加載器，負責加載Java的擴展類庫，默認加載JAVA_HOME/jre/lib/ext/目下的全部jar。

  3. App ClassLoader：稱爲系統類加載器，負責加載應用程序classpath目錄下的全部jar和class文件。

注意： 除了Java默認提供的三個ClassLoader以外，用戶還能夠根據須要定義自已的ClassLoader，而這些自定義的ClassLoader都必須繼承自java.lang.ClassLoader類，也包括Java提供的另外二個ClassLoader（Extension ClassLoader和App ClassLoader）在內，可是Bootstrap ClassLoader不繼承自ClassLoader，由於它不是一個普通的Java類，底層由C++編寫，已嵌入到了JVM內核當中，當JVM啓動後，Bootstrap ClassLoader也隨着啓動，負責加載完核心類庫後，並構造Extension ClassLoader和App ClassLoader類加載器。

3、ClassLoader加載類的原理

一、原理介紹

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

二、爲何要使用雙親委託這種模型呢？

由於這樣能夠避免重複加載，當父親已經加載了該類的時候，就沒有必要子ClassLoader再加載一次。考慮到安全因素，咱們試想一下，若是不使用這種委託模式，那咱們就能夠隨時使用自定義的String來動態替代java核心api中定義的類型，這樣會存在很是大的安全隱患，而雙親委託的方式，就能夠避免這種狀況，由於String已經在啓動時就被引導類加載器（Bootstrcp ClassLoader）加載，因此用戶自定義的ClassLoader永遠也沒法加載一個本身寫的String，除非你改變JDK中ClassLoader搜索類的默認算法。

 三、 可是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）、在web服務器上建一個org.classloader.simple.NetClassLoaderSimple.java類

1
2
3
4
5
6
7
8
9
10
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）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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認爲它們就是兩個不一樣的類。

四、ClassLoader的體系架構：

驗證ClassLoader加載類的原理：

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

1
2
3
4
5
6
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，有兩種方式：

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

二、將class文件放到JAVA_HOME/jre/classes/目錄下（上面有提到）

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

打開Run配置對話框：

配置好如圖中所述的參數後，從新運行程序，產的結果以下所示：（類加載的過程，只摘下了一部份）

打印結果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
[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加載成功了。

4、定義自已的ClassLoader

既然JVM已經提供了默認的類加載器，爲何還要定義自已的類加載器呢？

由於Java中提供的默認ClassLoader，只加載指定目錄下的jar和class，若是咱們想加載其它位置的類或jar時，好比：我要加載網絡上的一個class文件，經過動態加載到內存以後，要調用這個類中的方法實現個人業務邏輯。在這樣的狀況下，默認的ClassLoader就不能知足咱們的需求了，因此須要定義本身的ClassLoader。

定義自已的類加載器分爲兩步：

一、繼承java.lang.ClassLoader

二、重寫父類的findClass方法

讀者可能在這裏有疑問，父類有那麼多方法，爲何恰恰只重寫findClass方法？

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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" ; 
     } 
   
}

測試類：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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(); 
         } 
     } 
       
}

打印結果：

下圖是我機器上web服務器的目錄結構：

目前經常使用web服務器中都定義了本身的類加載器，用於加載web應用指定目錄下的類庫（jar或class），如：Weblogic、Jboss、tomcat等，下面我以Tomcat爲例，展現該web容器都定義了哪些個類加載器：

一、新建一個web工程httpweb

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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()+ "" ); 
             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); 
     } 
   
}

三、配置Servlet，並啓動服務

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?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>

四、訪問Servlet，得到顯示結果

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程