类加载，再来一发。
研究完java提供的类加载机制，再来看看tomcat开出了那些花。
最近开始读tomcat的源码，主线路当然是类加载机制，在这个过程中有豁然开朗的感觉。这一篇主要是自己的体会，而不是从头到尾的详细解读。很显然，是因为我懒。有多懒呢，懒到把女朋友都弄丢了，哎。
言归正传，从tomcat的启动类Bootstrap开始叙述。
1、加载Bootstrap的类加载器是哪个呢？APPClassLoader，因为tomcat还是要依赖Java的基础，包括类加载器和双亲委派模型。
2、Bootstrap类启动的时候，会初始化类加载器。
ClassLoader commonLoader = null;
ClassLoader catalinaLoader = null;
ClassLoader sharedLoader = null;
// -------------------------------------------------------- Private Methods
private void initClassLoaders() {
try {
commonLoader = createClassLoader("common", null);
if( commonLoader == null ) {
// no config file, default to this loader - we might be in a ‘single‘ env.
commonLoader=this.getClass().getClassLoader();
}
catalinaLoader = createClassLoader("server", commonLoader);
sharedLoader = createClassLoader("shared", commonLoader);
} catch (Throwable t) {
handleThrowable(t);
log.error("Class loader creation threw exception", t);
System.exit(1);
}
}
这里有3个类加载器，catalinaLoader 和 sharedLoader 以 commonLoader 为父类加载器，那commonLoader的父类加载器呢？？？一路跟代码，发现最终是AppClassLoader，具体实现在Java.lang.ClassLoader类。
common加载的类：tomcat和web应用都可以访问；
catalina加载的类：tomcat内部实现用到的类；
shared加载的类：所有web应用可以共用。
与每个web应用单独对应的类加载器是WebappClassLoader，后面会具体分析。
3、common、catalina以及shared三个类加载器都是URLClassLoader
if (parent == null)
return new URLClassLoader(array);
else
return new URLClassLoader(array, parent);
这是tomcat7的代码，6包括之前的版本还在用StandardClassLoader
4、类加载器生成后，Thread.currentThread().setContextClassLoader(catalinaLoader); 将当前线程的上下文类加载器设置为catalinaLoader，在后面的逻辑里面会经常用到。
5、再之后的一段代码需要好好分析一下
// Load our startup class and call its process() method
if (log.isDebugEnabled())
log.debug("Loading startup class");
Class<?> startupClass =
catalinaLoader.loadClass
("org.apache.catalina.startup.Catalina");
Object startupInstance = startupClass.newInstance();
// Set the shared extensions class loader
if (log.isDebugEnabled())
log.debug("Setting startup class properties");
String methodName = "setParentClassLoader";
Class<?> paramTypes[] = new Class[1];
paramTypes[0] = Class.forName("java.lang.ClassLoader");
Object paramValues[] = new Object[1];
paramValues[0] = sharedLoader;
Method method =
startupInstance.getClass().getMethod(methodName, paramTypes);
method.invoke(startupInstance, paramValues);
这里通过catalinaLoader去加载了Catalina类，生成了一个实例，并且通过反射调用了这个实例的setParentClassLoader方法，将父类加载器设置为sharedLoader，后面也会经常用到。我刚看到这段代码时，有一个巨大的疑问，为什么要用反射呢？
说的这里，我想再延伸一下。使用不同的类加载器还有一个好处：类之间的相互隔离。再深入一点，初始加载器和定义加载器。比如：有A、B、C 3个类加载器，根据双亲委派，通过 A --> B --> C 这条路径去加载了一个类 X, 那么A、B、C都是X的初始加载器，只有C是X的定义加载器。有一个原则：X类型在A、B、C 的命名空间中共享，在别的类加载器的命名空间中不能访问，也就是隔离。这里要注意，A、B独自加载的类型，对C不共享，也就是说子共享父，反过来不行。
所以，现在能解释两个事情：
a）、我们平常的代码里处处是jdk的类，它们的类加载器是启动类加载器，为什么。因为我们的代码是在classpath里面，类加载器是AppClassLoader，可以共享jdk的类。
b)、我们这里必须用反射！！！路演一下，启动类Bootstrap的类加载器是AppClassLoader，然后Bootstrap类里面用catalinaLoader去加载Catalina类。catalina --> common --> AppClassLoader，所以顺序很重要，反过来不行。既然不能共享，但是必须要访问，那怎么办呢，还好有反射。也就是说，反射突破了类加载的隔离机制。
6、最后来解刨WebappClassLoader
先看它重写的loadClass方法，实现在父类WebappClassLoaderBase里面
public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLockInternal(name)) {
if (log.isDebugEnabled())
log.debug("loadClass(" + name + ", " + resolve + ")");
Class<?> clazz = null;
// Log access to stopped classloader
if (!started) {
try {
throw new IllegalStateException();
} catch (IllegalStateException e) {
log.info(sm.getString("webappClassLoader.stopped", name), e);
}
}
// (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 cache
clazz = 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 J2SE classes
try {
clazz = j2seClassLoader.loadClass(name);
if (clazz != null) {
if (resolve)
resolveClass(clazz);
return (clazz);
}
} catch (ClassNotFoundException e) {
// Ignore
}
// (0.5) Permission to access this class when using a SecurityManager
if (securityManager != null) {
int i = name.lastIndexOf(‘.‘);
if (i >= 0) {
try {
securityManager.checkPackageAccess(name.substring(0,i));
} catch (SecurityException se) {
String error = "Security Violation, attempt to use " +
"Restricted Class: " + name;
if (name.endsWith("BeanInfo")) {
// BZ 57906: suppress logging for calls from
// java.beans.Introspector.findExplicitBeanInfo()
log.debug(error, se);
} else {
log.info(error, se);
}
throw new ClassNotFoundException(error, se);
}
}
}
boolean delegateLoad = delegate || filter(name);
// (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
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
}
// (3) Delegate to parent unconditionally
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);
}
梳理一下流程，其实英文的注释已经很明白了。
（1）首先从Tomcat自己持有的缓存中去查找
（2）从JVM的缓存中找
（3）先用j2seClassLoader去加载，就是怕你把jdk的jar包放到了WEB-INF下面
ClassLoader j = String.class.getClassLoader();
if (j == null) {
j = getSystemClassLoader();
while (j.getParent() != null) {
j = j.getParent();
}
}
this.j2seClassLoader = j;
从这段代码中，你应该知道j2seClassLoader到底是哪个类加载器了。只是我不明白为什么要用这么复杂的方式得到，getSystemClassLoader().getParent() 不行吗，希望明白的读者告知。
（4）如果设置了代理，就代理给父类加载器去加载，父亲是谁呢？后面再说。
（5）终于轮到自己去加载了
（6）如果还是不好使，无条件的交给父亲去搞定。
现在看看，这个WebappClassLoader是怎么生成的:
启动StandardContext的时候会创建WebappLoader，WebappLoader持有WebappClassLoderBase，WebappLoader里面初生成它的代码
private String loaderClass =
"org.apache.catalina.loader.WebappClassLoader";
classLoader = createClassLoader();
private WebappClassLoaderBase createClassLoader()
throws Exception {
Class<?> clazz = Class.forName(loaderClass);
WebappClassLoaderBase classLoader = null;
if (parentClassLoader == null) {
parentClassLoader = container.getParentClassLoader();
}
Class<?>[] argTypes = { ClassLoader.class };
Object[] args = { parentClassLoader };
Constructor<?> constr = clazz.getConstructor(argTypes);
classLoader = (WebappClassLoaderBase) constr.newInstance(args);
return classLoader;
}
这里通过反射调用构造方法，生成一个WebappClassLoader，并强转成父类。
其中container.getParentClassLoader() 得到的类加载器，就是sharedLoader，去看Tomcat的源码。
至于这里为什么也要用反射，不明白，请读者指教。