上篇博文主要从jdk源码角度讲解JVM的类加载委派机制，现在来看看tomcat是如何实现类加载的。
首先从大的方向上，Tomcat的类加载可配置成两种，一种是常说的“委派机制”，另外一种简单地说和“委派机制”有些不同。如何配置成“委派机制”？就是在想要配置的webapp <Context>节点下，内置 <Loader delegate="true"/>就可以了。先看看其“委派机制”。
先看一张图：
1. 启动初始化 ——涉及类加载部分
Bootstrap ClassLoader、ExtClassLoader、AppClassLoader指的jvm的那套委派关系图，这个已经很熟悉，就不说了。需要注意的是Tomcat如何设置AppClassLoader的“java.class.path”环境变量？以linux系统下为例，其会在$CATALINA_HOME\bin\catalina.sh中设置该环境变量。其实就是增加了两个jar：bootstrap.jar、tomcat-juli.jar，所以tomcat在启动的时候，是利用catalina.sh脚本设置"java.class.path"环境，依靠AppClassLoader加载org.apache.catalina.startup.Bootstrap.class来启动的。
// 为了说明重点，简化了main的源码，详细请看tomcat源码
public static void main(String args[]) {
Bootstrap bootstrap = new Bootstrap();
bootstrap.init();
if (command.equals("start")) {
daemon.setAwait(true);
daemon.load(args);
daemon.start();
}
}/** Initialize daemon.*/
public void init() throws Exception
{
// Set Catalina path
setCatalinaHome(); // 设置catalina.home环境变量
setCatalinaBase(); // 设置catalina.base环境变量
initClassLoaders(); // 初始化commonLoader、catalinaLoader、sharedLoader
Thread.currentThread().setContextClassLoader(catalinaLoader); // 设置main线程contextClassLoader
SecurityClassLoad.securityClassLoad(catalinaLoader);
// catalinaLoader加载Catalina.class
Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
Object startupInstance = startupClass.newInstance();
// 利用反射，设置Catalina实例parentClassLoader为sharedLoader
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);
catalinaDaemon = startupInstance;
}private void initClassLoaders() {
try {
commonLoader = createClassLoader("common", null);
if( commonLoader == null ) {
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);
}
}1）设置catalina.home、catalina.base环境变量，这主要是针对tomcat实例部署上的区别，可以网上了解多实例部署；
2）初始化commonLoader、catalinaLoader、sharedLoader，这三个ClassLoader在tomcat5.5版本及之前的类加载机制中是明显区分的，但是现在Tomcat6、7都已经不区分了。所以一般在catalina.home\conf\catalina.properties中采用默认配置：server.loader、shared.loader为空，配置common.loader，即：
common.loader=${catalina.base}/lib,${catalina.base}/lib/*.jar,${catalina.home}/lib,${catalina.home}/lib/*.jar
initClassLoaders()在创建commonLoader时，首先根据common.loader所配置的路径，获取URLs（这些URL的jar都是Tomcat自身源码打的jar），来创建commonLoader（注意commonLoader是继承于URLClassLoader的），所以commonLoader会加载common.loader下的class，也就是说Tomcat源码中类都是由commonLoader来加载的，当然，除了bootstrap.jar、tomcat-juli.jar。由于server.loader、shared.loader路径都为空，所以catalinaLoader、sharedLoader都与commonLoader指向同一个ClassLoader。在Tomcat的多实例部署中，可分别在每个实例的catalina.base/lib下面放置其下Webapp所公用的jar，在${catalina.home}/lib下放置所有Webapp所公用的jar。
另外这里需要留意一下Thread的contextClassLoader，这个ClassLoader的作用是什么？一般在“委派机制”中，低级委派层次的ClassLoader如果加载较高层次的class，如java.lang.String，是委派给较高委派层次的ClassLoader去加载，那反过来，如果较高委派层次的ClassLoader需要加载较低层次的class，这就需要用到Thread的contextClassLoader（当然，这种反过来的加载行为一般都是自行实现较高层次、较低层次的ClassLoader，因为jdk源码中Bootstrap ClassLoader、ExtClassLoader、AppClassLoader是严格遵守“委派机制”的，不会反过来去加载类的）。就是说，通过设置当前线程的contextClassLoader来反向加载：
Thread.currentThread().setContextClassLoader(lowerClassLoader); // lowerClassLoader为较低委派层次的ClassLoader下面举例说明Tomcat是加载Webapp下的conf\web.xml：
先说明：commonLoader为较高层次的ClassLoader，WebappClassLoader为较低层次的，commonLoader为WebappClassLoader的parent ClassLoader。commonLoader加载了org.apache.catalina.core.StandardContext，StandardContext在startInternal()中，需要加载conf\web.xml，这样会加载WEB-INF\classes、WEB-INF\lib下面的class，看看startInternal()中一段源码：
try {
...省略其他部分代码
oldCCL = bindThread();
// Initialize logger again. Other components might have used it
// too early, so it should be reset.
logger = null;
getLogger();
if ((cluster != null) && (cluster instanceof Lifecycle))
((Lifecycle) cluster).start();
Realm realm = getRealmInternal();
if ((realm != null) && (realm instanceof Lifecycle))
((Lifecycle) realm).start();
if ((resources != null) && (resources instanceof Lifecycle))
((Lifecycle) resources).start();
// Notify our interested LifecycleListeners，这里会触发加载conf\web.xml
fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null);
...省略其他部分代码
} finally {
// Unbinding thread
unbindThread(oldCCL);
}再看看bindThread()：
protected ClassLoader bindThread() {
ClassLoader oldContextClassLoader =
Thread.currentThread().getContextClassLoader();
if (getResources() == null)
return oldContextClassLoader;
if (getLoader() != null && getLoader().getClassLoader() != null) {
// 将当前Thread contextClassLoader设置为WebappClassLoader
// 这样WebappClassLoader就能加载Webapp路径WEB-INF\classes、WEB-INF\lib下的class
Thread.currentThread().setContextClassLoader
(getLoader().getClassLoader());
}
...省略其他部分代码
return oldContextClassLoader;
}2. WebappClassLoader加载class
WebappClassLoader的loadClass函数：
@Override
public synchronized Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException {
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);
}
}
// 检测WebappClassLoader的class缓存resourceEntries是否有待加载的name，
// 如果存在则说明WebappClassLoader已经加载过该class
clazz = findLoadedClass0(name);
if (clazz != null) {
if (log.isDebugEnabled())
log.debug(" Returning class from cache");
if (resolve)
resolveClass(clazz);
return (clazz);
}
// 检测JVM是否已经加载过该class
clazz = findLoadedClass(name);
if (clazz != null) {
if (log.isDebugEnabled())
log.debug(" Returning class from cache");
if (resolve)
resolveClass(clazz);
return (clazz);
}
// j2seClassLoader先加载，其中j2seClassLoader为ExtClassLoader，
// J2SE classes是需要j2seClassLoader加载的
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;
log.info(error, se);
throw new ClassNotFoundException(error, se);
}
}
}
boolean delegateLoad = delegate || filter(name);
// 如果配置了“委派机制”，先让WebappClassLoader的parent ClassLoader即commonLoader来加载
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
}
}
// WebappClassLoader自行加载，依次在WEB-INF\classes、WEB-INF\lib下搜寻
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
}
// 如果未配置“委派机制”，最后让WebappClassLoader的parent ClassLoader即commonLoader来加载
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);
}
548
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
