Tomcat 原始碼分析之ClassLoader

Tomcat 原始碼分析之ClassLoader

此系列文章皆為Tomcat 7.0代碼程式碼分析。

 

1. ClassLoader基礎知識1.1. Parent-Child委託模型

 

我們知道Java系統中，類載入器的預設載入方式是採用Parent-Child委託方式載入類的，即就是說，先嘗試使用父類載入器載入類，如果沒有找到，才自己載入該類，可以看到，這是一個遞迴的載入過程，核心代碼大致如下：

Java代碼

1. protected Class<?> loadClass(String name, boolean resolve)  
2.         throws ClassNotFoundException  
3.     {  
4.         synchronized (getClassLoadingLock(name)) {  
5.             // First, check if the class has already been loaded  
6.             Class c = findLoadedClass(name);  
7.             if (c == null) {  
8.                 ……  
9.                 try {  
10.                     if (parent != null) {  
11.                         c = parent.loadClass(name, false);  
12.                     } else {  
13.                         c = findBootstrapClassOrNull(name);  
14.                     }  
15.                 } catch (ClassNotFoundException e) {  
16.                     // ClassNotFoundException thrown if class not found  
17.                     // from the non-null parent class loader  
18.                 }  
19.   
20.                 if (c == null) {  
21.                     // If still not found, then invoke findClass in order  
22.                     // to find the class.  
23.                     …  
24.                     c = findClass(name);  
25.                     ……  
26.                 }  
27.             }  
28.             ……  
29.             return c;  
30.         }  
31.     }  

 很多ClassLoader的繼承類都預設了這種載入方式，其中用途比較廣泛的有URLClassLoader。1.2. 類載入器運行時模型：

 

當一個JVM啟動時，至少有三個ClassLoader會被啟動：

1. Bootstrap 類載入器

載入Java核心包，它們被置放在(<JAVA_HOME>/lib目錄下，這部分是JVM的一部分，往往使用native code完成

2. Extensions類載入器

載入Java擴充包，即位於<JAVA_HOME>/lib/ext下的包，這裡要注意的是，有些JVM的這個載入器和Bootstrap類載入器是同一個載入器，而Sun是把二者分開的，其實作類別為sun.misc.Launcher$ExtClassLoader。

3. System類載入器

這個類載入器載入CLASSPATH下的類，Sun的 預設實現是sun.misc.Launcher$ExtClassLoader。

這三者之間的父子關係是：Bootstrap類載入器是Extensions類載入器的父類載入器，而Extensions類載入器是System類載入器的父類載入器。

2. Tomcat Classloader模型

Tomcat 7.0的ClassLoader載入層次模型如所示：

 

 這個模型和之前Tomcat 5.5之前有些不同，因為之前的除過Common類載入器之外，還有Catalina類載入器和Shared類載入器，這個只能導致更多的配置和概念，已經不再使用了，雖然還可以進行配置。

1. Common類載入器：載入$CATALINA_HOME/lib和$CATALINA_BASE/lib下的class檔案和jar包以及旗下的資源檔，這些檔案將會被所有Web應用共有，也會被Tomcat運行時用到。其配置在catalina.properties下，如果沒有配置，則預設使用System類載入器，配置樣本：common.loader=${catalina.home}/lib,${catalina.home}/lib/*.jar2. App類載入器：Web 應用程式的類載入器，Web應用下的資源檔，class檔案盒jar包，按照Java Web規範的標準，它們位於Web應用的/WEB-INF/classes和/WEB-INF/lib檔案夾下。3. 類載入器的實現

 

Tomcat類載入器其實有三個類實現：StandardClassLoader，WebappClassLoader和JasperLoader，這三個類載入器都是URLClassLoader的子類。不同的是，StandardClassLoader並沒有客戶化URLClassLoader方法，即，它也是採用委託的方式載入類的。而其他都覆寫了loadClass()方法。

1. StandardClassLoader類載入器會建立Common類載入器的執行個體。

2. WebappClassLoader為每個應用建立類載入器執行個體，對於載入Web應用的類時，我們並非推薦使用父子委託模型，但是必須保證以java.*和javax.*開頭的包必須由System類載入器載入，即最終由Bootstrap載入器載入。

核心代碼如下：

Java代碼 

1. public Class loadClass(String name, boolean resolve)  
2.         throws ClassNotFoundException {  
3.   
4.        ……  
5.   
6.         // (0) Check our previously loaded local class cache  
7.         clazz = findLoadedClass0(name);  
8.         if (clazz != null) {  
9.             if (log.isDebugEnabled())  
10.                 log.debug("  Returning class from cache");  
11.             if (resolve)  
12.                 resolveClass(clazz);  
13.             return (clazz);  
14.         }  
15.   
16.         // (0.1) Check our previously loaded class cache  
17.         clazz = findLoadedClass(name);  
18.         if (clazz != null) {  
19.             if (log.isDebugEnabled())  
20.                 log.debug("  Returning class from cache");  
21.             if (resolve)  
22.                 resolveClass(clazz);  
23.             return (clazz);  
24.         }  
25.   
26.         // (0.2) Try loading the class with the system class loader, to prevent  
27.         //       the webapp from overriding J2SE classes  
28.        //保證以java.*和javax.*開頭的包必須由System類載入器載入  
29.         try {  
30.             clazz = system.loadClass(name);  
31.             if (clazz != null) {  
32.                 if (resolve)  
33.                     resolveClass(clazz);  
34.                 return (clazz);  
35.             }  
36.         } catch (ClassNotFoundException e) {  
37.             // Ignore  
38.         }  
39.   
40.         ……  
41.   
42.         boolean delegateLoad = delegate || filter(name);  
43.   
44.         // (1) Delegate to our parent if requested  
45.         //Mbeans載入時，是否採用delegate方式  
46.         if (delegateLoad) {  
47.             if (log.isDebugEnabled())  
48.                 log.debug("  Delegating to parent classloader1 " + parent);  
49.             ClassLoader loader = parent;  
50.             if (loader == null)  
51.                 loader = system;  
52.             try {  
53.                 clazz = loader.loadClass(name);  
54.                 if (clazz != null) {  
55.                     if (log.isDebugEnabled())  
56.                         log.debug("  Loading class from parent");  
57.                     if (resolve)  
58.                         resolveClass(clazz);  
59.                     return (clazz);  
60.                 }  
61.             } catch (ClassNotFoundException e) {  
62.                 ;  
63.             }  
64.         }  
65.   
66.         // (2) Search local repositories  
67.        //先本地載入，不委託父載入器載入  
68.         if (log.isDebugEnabled())  
69.             log.debug("  Searching local repositories");  
70.         try {  
71.             clazz = findClass(name);  
72.             if (clazz != null) {  
73.                 if (log.isDebugEnabled())  
74.                     log.debug("  Loading class from local repository");  
75.                 if (resolve)  
76.                     resolveClass(clazz);  
77.                 return (clazz);  
78.             }  
79.         } catch (ClassNotFoundException e) {  
80.             ;  
81.         }  
82.   
83.         // 最後使用父載入器載入  
84.         if (!delegateLoad) {  
85.             if (log.isDebugEnabled())  
86.                 log.debug("  Delegating to parent classloader at end: " + parent);  
87.             ClassLoader loader = parent;  
88.             if (loader == null)  
89.                 loader = system;  
90.             try {  
91.                 clazz = loader.loadClass(name);  
92.                 if (clazz != null) {  
93.                     if (log.isDebugEnabled())  
94.                         log.debug("  Loading class from parent");  
95.                     if (resolve)  
96.                         resolveClass(clazz);  
97.                     return (clazz);  
98.                 }  
99.             } catch (ClassNotFoundException e) {  
100.                 ;  
101.             }  
102.         }  
103.   
104.         throw new ClassNotFoundException(name);  
105.     }  

可以看到，並非簡單的父子委託方式載入類

3. JasperLoader是為了載入jsp編譯成的servlet而建立的類載入器，它覆寫了loadClass()方法，除過載入org.apache.jsp.*的檔案外，其他的均使用父載入器載入。

核心代碼如下：

Java代碼

1. public Class loadClass(final String name, boolean resolve)  
2.         throws ClassNotFoundException {  
3.   
4.         Class clazz = null;                  
5.                                              
6.         // (0) Check our previously loaded class cache  
7.         clazz = findLoadedClass(name);       
8.         if (clazz != null) {                 
9.             if (resolve)                     
10.                 resolveClass(clazz);         
11.             return (clazz);          
12.         }                            
13.                             
14.         // (.5) Permission to access this class when using a SecurityManager  
15.         ……  
16.   
17.     if( !name.startsWith(Constants.JSP_PACKAGE_NAME) ) {  
18.             // Class is not in org.apache.jsp, therefore, have our  
19.             // parent load it  
20.             clazz = parent.loadClass(name);              
21.         if( resolve )  
22.         resolveClass(clazz);  
23.         return clazz;  
24.     }  
25.         //所有的以org.apache.jsp.*開頭的檔案都由該類載入器載入。  
26.     return findClass(name);  
27.     }  

 

 

今天就講到這裡了。