眾所周知，Java中預設的類載入器是以父子關係存在的，實現了雙親委派機制進行類的載入，在前文中，我們提到了，雙親委派機制的設計是為了保證類的唯一性，這意味著在同一個JVM中是不能載入相同類庫的不同版本的類。
然而與許多伺服器應用程式一樣，Tomcat 允許容器的不同部分以及在容器上執行的不同Web應用程式可以存取的各種不同版本的類庫，這就要求Tomcat必須打破這種雙親委派機制，通過實現自定義的類載入器（即實現了java.lang.ClassLoader）進行類的載入。下面，就讓我們來看看Tomcat類載入原理是怎樣的。
Tomcat中有兩個最重要的類載入器，第一個便是負責Web應用程式類載入的WebappClassLoader，另一個便是JSP Servlet類載入器`JasperLoader。
上程式碼：
public class WebappClassLoader extends WebappClassLoaderBase {
public WebappClassLoader() {
super();
}
public WebappClassLoader(ClassLoader parent) {
super(parent);
}
...
}
我們來看看WebappClassLoader繼承的WebappClassLoaderBase中實現的類載入方法loadClass
public abstract class WebappClassLoaderBase extends URLClassLoader
implements Lifecycle, InstrumentableClassLoader, WebappProperties, PermissionCheck {
... 省略不需要關注的程式碼
protected WebappClassLoaderBase() {
super(new URL[0]);
// 獲取當前WebappClassLoader的父載入器系統類載入器
ClassLoader p = getParent();
if (p == null) {
p = getSystemClassLoader();
}
this.parent = p;
// javaseClassLoader變數經過以下程式碼的執行，
// 得到的是擴充套件類載入器（ExtClassLoader）
ClassLoader j = String.class.getClassLoader();
if (j == null) {
j = getSystemClassLoader();
while (j.getParent() != null) {
j = j.getParent();
}
}
this.javaseClassLoader = j;
securityManager = System.getSecurityManager();
if (securityManager != null) {
refreshPolicy();
}
}
...省略不需要關注的程式碼
@Override
public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
if (log.isDebugEnabled()) {
log.debug("loadClass(" + name + ", " + resolve + ")");
}
Class<?> clazz = null;
// Web應用程式停止狀態時，不允許載入新的類
checkStateForClassLoading(name);
// 如果之前載入過該類，就可以從Web應用程式類載入器本地類快取中查詢，
// 如果找到說明WebappClassLoader之前已經載入過這個類
clazz = findLoadedClass0(name);
if (clazz != null) {
if (log.isDebugEnabled()) {
log.debug(" Returning class from cache");
}
if (resolve) {
resolveClass(clazz);
}
return clazz;
}
// Web應用程式本地類快取中沒有，可以從系統類載入器快取中查詢，
// 如果找到說明AppClassLoader之前已經載入過這個類
clazz = findLoadedClass(name);
if (clazz != null) {
if (log.isDebugEnabled()) {
log.debug(" Returning class from cache");
}
if (resolve) {
resolveClass(clazz);
}
return clazz;
}
// 將類似java.lang.String這樣的類名這樣轉換成java/lang/String
// 這樣的資原始檔名
String resourceName = binaryNameToPath(name, false);
// 獲取引導類載入器（BootstrapClassLoader）
ClassLoader javaseLoader = getJavaseClassLoader();
boolean tryLoadingFromJavaseLoader;
try {
// 引導類載入器根據轉換後的類名獲取資源url，如果url不為空，就說明找到要載入的類
URL url;
if (securityManager != null) {
PrivilegedAction<URL> dp = new PrivilegedJavaseGetResource(resourceName);
url = AccessController.doPrivileged(dp);
} else {
url = javaseLoader.getResource(resourceName);
}
tryLoadingFromJavaseLoader = (url != null);
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
tryLoadingFromJavaseLoader = true;
}
// 首先，從擴充套件類載入器（ExtClassLoader）載入，防止Java核心API庫被Web應用程式類隨意篡改
if (tryLoadingFromJavaseLoader) {
try {
clazz = javaseLoader.loadClass(name);
if (clazz != null) {
if (resolve) {
resolveClass(clazz);
}
return clazz;
}
} catch (ClassNotFoundException e) {
// Ignore
}
}
// 當使用安全管理器時，允許存取這個類
if (securityManager != null) {
int i = name.lastIndexOf('.');
if (i >= 0) {
try {
securityManager.checkPackageAccess(name.substring(0,i));
} catch (SecurityException se) {
String error = sm.getString("webappClassLoader.restrictedPackage", name);
log.info(error, se);
throw new ClassNotFoundException(error, se);
}
}
}
/*
* 如果Web應用程式類載入器設定為，<Loader delegate="true"/> 或者滿足下列條件的類：
* 當前類屬於以下這些jar包中：
* annotations-api.jar — Common Annotations 1.2 類。
* catalina.jar — Tomcat 的 Catalina servlet 容器部分的實現。
* catalina-ant.jar — 可選。用於使用 Manager Web 應用程式的 Tomcat Catalina Ant 任務。
* catalina-ha.jar — 可選。提供基於 Tribes 構建的對談叢集功能的高可用性包。
* catalina-storeconfig.jar — 可選。從當前狀態生成 XML 組態檔。
* catalina-tribes.jar — 可選。高可用性包使用的組通訊包。
* ecj-*.jar — 可選。Eclipse JDT Java 編譯器用於將 JSP 編譯為 Servlet。
* el-api.jar — 可選。EL 3.0 API。
* jasper.jar — 可選。Tomcat Jasper JSP 編譯器和執行時。
* jasper-el.jar — 可選。Tomcat EL 實現。
* jaspic-api.jar — JASPIC 1.1 API。
* jsp-api.jar — 可選。JSP 2.3 API。
* servlet-api.jar — Java Servlet 3.1 API。
* tomcat-api.jar — Tomcat 定義的幾個介面。
* tomcat-coyote.jar — Tomcat 聯結器和實用程式類。
* tomcat-dbcp.jar — 可選。基於 Apache Commons Pool 2 和 Apache Commons DBCP 2 的
* 包重新命名副本的資料庫連線池實現。
* tomcat-i18n-**.jar — 包含其他語言資源包的可選 JAR。由於預設包也包含在每個單獨的JAR
* 中，如果不需要訊息國際化，可以安全地刪除它們。
* tomcat-jdbc.jar — 可選。另一種資料庫連線池實現，稱為 Tomcat JDBC 池。有關詳細資訊，請參閱 檔案。
* tomcat-jni.jar — 提供與 Tomcat Native 庫的整合。
* tomcat-util.jar — Apache Tomcat 的各種元件使用的通用類。
* tomcat-util-scan.jar — 提供 Tomcat 使用的類掃描功能。
* tomcat-websocket.jar — 可選。Java WebSocket 1.1 實現
* websocket-api.jar — 可選。Java WebSocket 1.1 API
*
* 此處的filter方法，實際上tomcat官方將filter類載入過濾條件，看作是一種類載入器，
* 將其取名為CommonClassLoader
*/
boolean delegateLoad = delegate || filter(name, true);
// 如果ExtClassLoader沒有獲取到，說明是非JRE核心類，那麼就從系統類載入器（也稱AppClassLoader
// 應用程式類載入器）載入
if (delegateLoad) {
if (log.isDebugEnabled()) {
log.debug(" Delegating to parent classloader1 " + parent);
}
try {
clazz = Class.forName(name, false, parent);
if (clazz != null) {
if (log.isDebugEnabled()) {
log.debug(" Loading class from parent");
}
if (resolve) {
resolveClass(clazz);
}
return clazz;
}
} catch (ClassNotFoundException e) {
// Ignore
}
}
// 從Web應用程式的類載入器（也就是WebappClassLoader)中載入類。Web應用程式的類載入器是
// 一個特殊的類載入器，它負責從Web應用程式的本地庫中載入類
if (log.isDebugEnabled()) {
log.debug(" Searching local repositories");
}
try {
clazz = findClass(name);
if (clazz != null) {
if (log.isDebugEnabled()) {
log.debug(" Loading class from local repository");
}
if (resolve) {
resolveClass(clazz);
}
return clazz;
}
} catch (ClassNotFoundException e) {
// Ignore
}
// 經過上面幾個步驟還未載入到類，則採用系統類載入器（也稱應用程式類載入器）進行載入
if (!delegateLoad) {
if (log.isDebugEnabled()) {
log.debug(" Delegating to parent classloader at end: " + parent);
}
try {
clazz = Class.forName(name, false, parent);
if (clazz != null) {
if (log.isDebugEnabled()) {
log.debug(" Loading class from parent");
}
if (resolve) {
resolveClass(clazz);
}
return clazz;
}
} catch (ClassNotFoundException e) {
// Ignore
}
}
}
// 最終，還未載入到類，報類未找到的異常
throw new ClassNotFoundException(name);
}
...省略不需要關注的程式碼
}
綜上所述，我們得出WebappClassLoader類載入器打破了雙親委派機制，自定義類載入類的順序：
如果Web應用程式類載入器設定為，，也就是WebappClassLoaderBase類的變數delegate=true時，則類載入順序變為：
上程式碼：
public class JasperLoader extends URLClassLoader {
private final PermissionCollection permissionCollection;
private final SecurityManager securityManager;
// JSP類載入器的父載入器是Web應用程式類載入器（WebappClassLoader）
public JasperLoader(URL[] urls, ClassLoader parent,
PermissionCollection permissionCollection) {
super(urls, parent);
this.permissionCollection = permissionCollection;
this.securityManager = System.getSecurityManager();
}
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
@Override
public synchronized Class<?> loadClass(final String name, boolean resolve)
throws ClassNotFoundException {
Class<?> clazz = null;
// 從JVM的類快取中查詢
clazz = findLoadedClass(name);
if (clazz != null) {
if (resolve) {
resolveClass(clazz);
}
return clazz;
}
// 當使用SecurityManager安全管理器時，允許存取訪類
if (securityManager != null) {
int dot = name.lastIndexOf('.');
if (dot >= 0) {
try {
// Do not call the security manager since by default, we grant that package.
if (!"org.apache.jasper.runtime".equalsIgnoreCase(name.substring(0,dot))){
securityManager.checkPackageAccess(name.substring(0,dot));
}
} catch (SecurityException se) {
String error = "Security Violation, attempt to use " +
"Restricted Class: " + name;
se.printStackTrace();
throw new ClassNotFoundException(error);
}
}
}
// 如果類名不是以org.apache.jsp包名開頭的，則採用WebappClassLoader載入
if( !name.startsWith(Constants.JSP_PACKAGE_NAME + '.') ) {
// Class is not in org.apache.jsp, therefore, have our
// parent load it
clazz = getParent().loadClass(name);
if( resolve ) {
resolveClass(clazz);
}
return clazz;
}
// 如果是org.apache.jsp包名開頭JSP類，就呼叫父類別URLClassLoader的findClass方法
// 動態載入類檔案，解析成Class類，返回給呼叫方
return findClass(name);
}
}
下面是URLClassLoader的findClass方法，具體實現：
protected Class<?> findClass(final String name)
throws ClassNotFoundException
{
final Class<?> result;
try {
result = AccessController.doPrivileged(
new PrivilegedExceptionAction<Class<?>>() {
public Class<?> run() throws ClassNotFoundException {
String path = name.replace('.', '/').concat(".class");
Resource res = ucp.getResource(path, false);
if (res != null) {
try {
// 解析類的位元組碼檔案生成Class類物件
return defineClass(name, res);
} catch (IOException e) {
throw new ClassNotFoundException(name, e);
}
} else {
return null;
}
}
}, acc);
} catch (java.security.PrivilegedActionException pae) {
throw (ClassNotFoundException) pae.getException();
}
if (result == null) {
throw new ClassNotFoundException(name);
}
return result;
}
從原始碼中我們可以看到，JSP類載入原理是，先從JVM類快取中（也就是Bootstrap類載入器載入的類）載入，如果不是核心類庫的類，就從Web應用程式類載入器WebappClassLoader中載入，如果還未找到，就說明是jsp類，則通過動態解析jsp類檔案獲得要載入的類。
經過上面兩個Tomcat核心類載入器的剖析，我們也就知道了Tomcat類的載入原理了。
下面我們來總結一下：Tomcat會為每個Web應用程式建立一個WebappClassLoader類載入器進行類的載入，不同的類載入器範例載入的類是會被認為是不同的類，即使它們的類名相同，這樣的話就可以實現在同一個JVM下，允許Tomcat容器的不同部分以及在容器上執行的不同Web應用程式可以存取的各種不同版本的類庫。
針對JSP類，會由專門的JSP類載入器（JasperLoader）進行載入，該載入器會針對JSP類在每次載入時都會解析類檔案，Tomcat容器會啟動一個後臺執行緒，定時檢測JSP類檔案的變化，及時更新類檔案，這樣就實現JSP檔案的熱載入功能。