上篇分析了Tomcat的WebappClassloader是怎么来的，以及怎么用来加载我们自定义的class的，现在我们开始分析具体是怎么加载。
WebappClassloader 继承jdk的URLClassLoader，重写了两个基本方法，loadClass方法和findClass方法，loadClass决定了加载顺序，findClass方法决定tomcat去哪里找class，下面先看loadClass方法，是打破了双亲委派模型的关键。
public Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
//加锁，保证一个class同时只要一个线程在加载。
synchronized (JreCompat.isGraalAvailable() ? this : getClassLoadingLock(name)) {
if (log.isDebugEnabled())
log.debug("loadClass(" + name + ", " + resolve + ")");
Class clazz = null;
// Log access to stopped class loader
checkStateForClassLoading(name);
//第一步： 先检查是否已经加载，加载过则不再加载，直接返回缓存的对象，
//这里的缓存是tomcat自己的缓存，缓存的是我们自己实现的class
// (0) Check our previously loaded local class cache
clazz = findLoadedClass0(name);
if (clazz != null) {
if (log.isDebugEnabled())
log.debug(" Returning class from cache");
if (resolve)
resolveClass(clazz);
return clazz;
}
// (0.1) Check our previously loaded class cache2
//第二步： 从系统类加载器的cache的查找，看系统加载器是否加载过。
clazz = JreCompat.isGraalAvailable() ? null : findLoadedClass(name);
if (clazz != null) {
if (log.isDebugEnabled())
log.debug(" Returning class from cache");
if (resolve)
resolveClass(clazz);
return clazz;
}
// (0.2) Try loading the class with the system class loader, to prevent
// the webapp from overriding Java SE classes. This implements
// SRV.10.7.2
String resourceName = binaryNameToPath(name, false);
//第三步： 如果tomcat和系统都没有加载过，则用ExtClassLoader加载，这里为啥不直接用系统类加载呢？
ClassLoader javaseLoader = getJavaseClassLoader();
boolean tryLoadingFromJavaseLoader;
try {
// Use getResource as it won't trigger an expensive
// ClassNotFoundException if the resource is not available from
// the Java SE class loader. However (see
// https://bz.apache.org/bugzilla/show_bug.cgi?id=58125 for
// details) when running under a security manager in rare cases
// this call may trigger a ClassCircularityError.
// See https://bz.apache.org/bugzilla/show_bug.cgi?id=61424 for
// details of how this may trigger a StackOverflowError
// Given these reported errors, catch Throwable to ensure any
// other edge cases are also caught
URL url;
if (securityManager != null) {
PrivilegedAction dp = new PrivilegedJavaseGetResource(resourceName);
url = AccessController.doPrivileged(dp);
} else {
url = javaseLoader.getResource(resourceName);
}
tryLoadingFromJavaseLoader = (url != null);
} catch (Throwable t) {
// Swallow all exceptions apart from those that must be re-thrown
ExceptionUtils.handleThrowable(t);
// The getResource() trick won't work for this class. We have to
// try loading it directly and accept that we might get a
// ClassNotFoundException.
tryLoadingFromJavaseLoader = true;
}
if (tryLoadingFromJavaseLoader) {
try {
clazz = javaseLoader.loadClass(name);
if (clazz != null) {
if (resolve)
resolveClass(clazz);
return clazz;
}
} catch (ClassNotFoundException e) {
// Ignore
}
}
//4
.
.
boolean delegateLoad = delegate || filter(name, true);
// 这里是坚持要加载的class是否是tomcat下面的一些类
// (1) Delegate to our parent if requested
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
}
}
// (2) Search local repositories
//第五步： 尝试从本地目录加载即Class即我们自己实现的类和依赖的第三方的jar
if (log.isDebugEnabled())
log.debug(" Searching local repositories");
try {
//这里就是tomcat查找class的地方
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
}
// (3) Delegate to parent unconditionally
//第六步： 加载Class path 目录下的类
if (!delegateLoad) {
if (log.isDebugEnabled())
log.debug(" Delegating to parent classloader at end: " + parent);
try {
//加载Class path 目录下的类
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);
}
tomcat 的WebappClassloader加载规则很复杂，关键是第三步，如果缓存都没有，则说明是第一次加载，而第一次是用ExtClassLoader加载的，即jdk自己的类，这是为了防止我们自己实现的类覆盖了jdk官方的类，如果直接用系统类加载器Appclassload的话，那就不是我们web/classes目录下的类优先加载了，就达不到多个应用隔离的目的，只有用ExtClassLoader即解决了类安全的问题，又能不加载classpath下面的类
如果是我们自己实现的类，比如我们写的servlet，就需要通过第四步来加载，如果在我们自定义的class目前下也找不到，这时就从classpath
下面加载。
下面我们看findClass的实现，我们知道我们的class除来我们自己写的代码在Web/classes目录下，我们还要依赖很多第三方的jar，这些jar包在Web/lib目录下，那tomcat是先加载那个呢，请接着往下看
类的缓存集合
tomcat 把本地的资源分为几类，有一个list在决定了他们的访问顺序
- mainResources 是Web/class 目录下的class的位置，只是路径
- classResources 是Web/lib 目录下的jar包路径缓存的资源
- jarResources /WEB-INF/classes/META-INF/resources 这个目录下的jar
各个位置的资源添加到allResources的顺序为：
allResources.add(preResources);
allResources.add(mainResources);
allResources.add(classResources);
allResources.add(jarResources);
allResources.add(postResources);
tomcat从自己本地加载class时，按顺序迭代allResources的resources
因为Web/classes 目录下的class在web/lib这个目录的前面，则tomcat会优先加载Web/classes的class，这也是我们能重写jar报里的代码的原因。
总结
- 1 先从本地cache加载,注意只要本地的class才会缓存在这里
- 2 本地缓存没有，则从ExtClassLoad的缓存里加载，jdk的jre目录
- 3 则从ExtClassLoad的缓存里加载
- 4 从本地web目录下的WEB-INF/classes加载
- 5 从本地web目录下的WEB-INF/lib加载
- 6 从本地web目录下的/WEB-INF/classes/META-INF/resources加载
- 7 从classpath下加载