读Tomcat的源码也算是有一段时间了吧，感觉读的也是断断续续的，这次写一篇比较综合性的吧，来看看Tomcat的整体ClassLoader体系的设计。。。。
在具体的涉及到源码之前，先来一张图来整体的描述一下整体的结构吧：
这张图在以前的文章应该也出现过。。。首先整个Tomcat的classLoader分为了两条线，左边的一条线为catalinaLoader，这个是Tomcat服务器专用的，用于加载Tomcat服务器本身的class，右边的一条线则为web应用程序用的，每一个web应用程序都有自己专用的WebappClassLoader，用于加载属于自己应用程序的资源，例如/web-inf/lib下面的jar包，classes里面的class文件。。。
然后上面也体现了整体的classLoader的双亲继承关系。。。。
好啦，接下来来开始进入代码部分吧。。在整个tomcat的启动入口部分bootstrap对象的main函数中，代码如下：
Bootstrap bootstrap = new Bootstrap(); //这里创建当前Bootstarp类型的对象
try {
bootstrap.init(); //初始化,这里有创建classLoader，其实这里主要是创建org.apache.catalina.startup.Catalina对象并调用setParentClassLoader设置classLoader，用的是shareLoader
} catch (Throwable t) {
handleThrowable(t);
t.printStackTrace();
return;
}
daemon = bootstrap; //保存当前引用到静态变量
这里主要是对bootstrap的初始化，这里面就会涉及到commonLoader，catalinaLoader与sharedLoader的创建，来看代码吧：
//初始化当前的tomcat后台，主要是创建org.apache.catalina.startup.Catalina对象，并且设置它的classLoader为catalinaLoader
public void init() throws Exception {
initClassLoaders(); //先初始化classLoader，包括common，catalina以及shared
Thread.currentThread().setContextClassLoader(catalinaLoader); //设置当前线程classLoader
SecurityClassLoad.securityClassLoad(catalinaLoader); //安全classLoader？
// Load our startup class and call its process() method
if (log.isDebugEnabled())
log.debug("Loading startup class");
Class<?> startupClass =
catalinaLoader.loadClass //这里加载catalina类型是用catalinaloader来加载的
("org.apache.catalina.startup.Catalina"); //获取org.apache.catalina.startup.Catalina类型
Object startupInstance = startupClass.newInstance(); //创建org.apache.catalina.startup.Catalina对象
// 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; //传进这个classLoader
Method method =
startupInstance.getClass().getMethod(methodName, paramTypes);
method.invoke(startupInstance, paramValues); //调用刚刚创建的org.apache.catalina.startup.Catalina对象的setParentClassLoader设置classLoader，shareloader
catalinaDaemon = startupInstance; //将这个启动的实例保存起来，这里引用的是catalina的类型的对象
}
这里有几个比较重要的部分吧，首先调用了initClassLoader方法来创建了上面提到的三个classLoader，然后这里还要注意，将当前的线程classLoader设置为了catalinaLoader，这个待会会看到具体干嘛用。。。接着就是调用创建的catalina对象的setParent方法，将sharedLoader传进去，这个也很重要。。一会就知道了。。。
这里还有一个比较重要的地方，catalina的class是用catalinaLoader加载的。。。
好了，先暂时搁置catalina部分的内容，来看看initClassLoader方法做了啥吧：
//初始化classLoader，这里分别创建了3个classLoader，common，catalina和sharedLoader，其中common没有父亲，另外两个的父亲是common
private void initClassLoaders() {
try {
commonLoader = createClassLoader("common", null); //创建common的classloader java.net.URLClassLoader
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); //java.net.URLClassLoader
sharedLoader = createClassLoader("shared", commonLoader); //java.net.URLClassLoader
} catch (Throwable t) {
handleThrowable(t);
log.error("Class loader creation threw exception", t);
System.exit(1);
}
}
这里就可以看到创建了commonLoader，catalinaLoader与sharedLoader，而且可以很清楚的看到他们之间的双亲结构。。。这里我们来看看createClassLoader方法是怎么搞的吧：
//具体的创建classLoader的方法，第一个参数是当前要创建的ｌｏａｄｅｒ的名字，第二个是这个loader的双亲loader的父亲
private ClassLoader createClassLoader(String name, ClassLoader parent)
throws Exception {
//首先获取要载入的资源路径
String value = CatalinaProperties.getProperty(name + ".loader"); //"${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"
if ((value == null) || (value.equals(""))) //如果没有这个classLoader特定的资源，那么就用parent就好了
return parent;
value = replace(value); //这里主要是获取当前classLoader加载资源的路径
List<Repository> repositories = new ArrayList<>();
String[] repositoryPaths = getPaths(value); //将里面的路径区分开来
for (String repository : repositoryPaths) { //遍历所有的要载入的资源路径
// Check for a JAR URL repository
/*
* G:\work eclipse workspace\tomcat8/lib
G:\work eclipse workspace\tomcat8/lib/*.jar
G:\work eclipse workspace\tomcat8/lib
G:\work eclipse workspace\tomcat8/lib/*.jar
*/
try {
@SuppressWarnings("unused")
URL url = new URL(repository); // 创建路径的url引用
repositories.add(
new Repository(repository, RepositoryType.URL)); //将他们加入repositories
continue;
} catch (MalformedURLException e) {
// Ignore
}
// Local repository
if (repository.endsWith("*.jar")) { //如果是*.jar结尾的，那么只取前面的文件夹路径就好了
repository = repository.substring
(0, repository.length() - "*.jar".length());
repositories.add(
new Repository(repository, RepositoryType.GLOB));
} else if (repository.endsWith(".jar")) { //如果是jar结尾的，那么表示是个jar包
repositories.add(
new Repository(repository, RepositoryType.JAR));
} else {
repositories.add(
new Repository(repository, RepositoryType.DIR)); //其他的就是路径了
}
}
return ClassLoaderFactory.createClassLoader(repositories, parent); //创建classLoder
}
第一个参数是要创建的classLoader的名字，第二个是该classLoader的父亲，对于commonLoader，它的父亲为null，这里首先做的是获取指定要创建的classLoader的配置信息，其实这里也就是该classLoder要载入的资源。。
这里也可以看到，如果classLoader没有自己要特定载入的资源的话，那么将不会创建，直接用parent就好了。。。
有的时候，对于sharedLoader与catalinaLoader就没有特定要创建的。。。在这种情况下就catalina，sharedLoader与commonLoader就为同一个对象。。。
当然对于最顶层的commonLoader，它是由自己要载入的资源的，路径如下： //"${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"
这也就是commonLoader要载入的主要的资源路径，因此也可以知道主要就是载入Tomcat服务器根路径下lib文件夹里面的资源。。。。最后调用ClassLoaderFactory的createClassLoader方法的时候将要载入的资源的路径引用穿件去就好了。。最终创建的classLoader其实就是类库的URLClassLoader，也就是在创建URLClassLoader对象的时候，将刚刚提到的资源的url引用传入就好了。。。。
那么到这里为止，commonLoader，catalinaLoader与sharedLoader的创建就算是比较清楚了吧。。。
接到开始的话题，在bootStrap对象的初始化方法中将当前的线程classLoader设置为了catalinaLoader，然后将创建的catalina对象的parentClassLoader设置为了sharedLoader。。。嗯。。记住。。。
好啦，接下来进入catalina对象部分，我们知道bootstrap对象的启动，实际上是调用catalina对象的start方法来具体工作的。。那么接下来进入catalina对象的start方法吧：
//创建一个tomcatServer的实例，在bootstrap对象中的启动会调用catalina的start方法来启动tomcat
public void start() {
if (getServer() == null) {
load(); //加载server，这里其实主要是解析xml文件，读取里面的元素定义，用于生成server对象，并且初始化server对象
}
if (getServer() == null) {
log.fatal("Cannot start server. Server instance is not configured.");
return;
}
long t1 = System.nanoTime();
// Start the new server
try {
getServer().start(); //调用server的start，最终启动tomcat服务器，其实server要做的是启动里面的service
} catch (LifecycleException e) {
log.fatal(sm.getString("catalina.serverStartFail"), e);
try {
getServer().destroy();
} catch (LifecycleException e1) {
log.debug("destroy() failed for failed Server ", e1);
}
return;
}
long t2 = System.nanoTime();
if(log.isInfoEnabled()) {
log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms");
}
// Register shutdown hook
if (useShutdownHook) {
if (shutdownHook == null) {
shutdownHook = new CatalinaShutdownHook();
}
Runtime.getRuntime().addShutdownHook(shutdownHook);
// If JULI is being used, disable JULI's shutdown hook since
// shutdown hooks run in parallel and log messages may be lost
// if JULI's hook completes before the CatalinaShutdownHook()
LogManager logManager = LogManager.getLogManager();
if (logManager instanceof ClassLoaderLogManager) {
((ClassLoaderLogManager) logManager).setUseShutdownHook(
false);
}
}
if (await) {
await(); //阻塞当前线程
stop();
}
}
这部分要做的事情，其实是创建server对象，然后启动就好了。。。然后catalina对象将会阻塞当前线程。。
那么来看看具体是怎么创建Server对象的吧：
//用于创建server对象
public void load() {
long t1 = System.nanoTime();
initDirs(); //初始化一些目录参数
// Before digester - it may be needed
initNaming();
// Create and execute our Digester
Digester digester = createStartDigester(); //创建处理xml文件的对象，并会生成相应的处理规则，例如如何创建server对象，主要是处理server.xml
InputSource inputSource = null;
InputStream inputStream = null;
File file = null;
try {
file = configFile(); //获取server.xml
inputStream = new FileInputStream(file); //读取server.xml
inputSource = new InputSource(file.toURI().toURL().toString());
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug(sm.getString("catalina.configFail", file), e);
}
}
if (inputStream == null) {
try {
inputStream = getClass().getClassLoader()
.getResourceAsStream(getConfigFile());
inputSource = new InputSource
(getClass().getClassLoader()
.getResource(getConfigFile()).toString());
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug(sm.getString("catalina.configFail",
getConfigFile()), e);
}
}
}
// This should be included in catalina.jar
// Alternative: don't bother with xml, just create it manually.
if( inputStream==null ) {
try {
inputStream = getClass().getClassLoader()
.getResourceAsStream("server-embed.xml");
inputSource = new InputSource
(getClass().getClassLoader()
.getResource("server-embed.xml").toString());
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug(sm.getString("catalina.configFail",
"server-embed.xml"), e);
}
}
}
if (inputStream == null || inputSource == null) {
if (file == null) {
log.warn(sm.getString("catalina.configFail",
getConfigFile() + "] or [server-embed.xml]"));
} else {
log.warn(sm.getString("catalina.configFail",
file.getAbsolutePath()));
if (file.exists() && !file.canRead()) {
log.warn("Permissions incorrect, read permission is not allowed on the file.");
}
}
return;
}
try {
inputSource.setByteStream(inputStream);
digester.push(this); //这里先将当前对象放到Digester的栈底，但会server生成之后会调用当前对象的setServer方法来保存起来
digester.parse(inputSource);
} catch (SAXParseException spe) {
log.warn("Catalina.start using " + getConfigFile() + ": " +
spe.getMessage());
return;
} catch (Exception e) {
log.warn("Catalina.start using " + getConfigFile() + ": " , e);
return;
} finally {
try {
inputStream.close();
} catch (IOException e) {
// Ignore
}
}
getServer().setCatalina(this); //设置sever的catalina对象
getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile()); //设置server的目录
getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());
// Stream redirection
initStreams();
// Start the new server
try {
getServer().init(); //初始化创建的server对象，其实这里主要是初始化service
} catch (LifecycleException e) {
if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
throw new java.lang.Error(e);
} else {
log.error("Catalina.start", e);
}
}
long t2 = System.nanoTime();
if(log.isInfoEnabled()) {
log.info("Initialization processed in " + ((t2 - t1) / 1000000) + " ms");
}
}
这里其实主要就是创建Digester对象，然后用它来解析conf/server.xml文件，根据配置的信息来创建相应的对象，例如server对象，因此这个Digester就算是很重要的啦。。。来看看它的创建吧：
protected Digester createStartDigester() {
long t1=System.currentTimeMillis();
// Initialize the digester
Digester digester = new Digester(); //这个对象用于解析处理xml文件
digester.setValidating(false);
digester.setRulesValidation(true);
HashMap<Class<?>, List<String>> fakeAttributes = new HashMap<>();
ArrayList<String> attrs = new ArrayList<>();
attrs.add("className");
fakeAttributes.put(Object.class, attrs);
digester.setFakeAttributes(fakeAttributes);
digester.setUseContextClassLoader(true); //将useContextClassLoader参数设置为true，那么待会将会用预先保存的线程classLoader来载入class，这里其实就是catalinaloader
// Configure the actions we will be using
digester.addObjectCreate("Server",
"org.apache.catalina.core.StandardServer",
"className"); //创建一个创建server对象的规则
digester.addSetProperties("Server"); //创建一个设置属性的规则，那么创建完了server对象之后就会设置配置文件后面的属性
digester.addSetNext("Server",
"setServer",
"org.apache.catalina.Server"); //当server元素执行完了之后，执行的操作。。。这里其实是调用前面那个对象的方法，这里其实就是调用catalina对象的setServer方法
digester.addObjectCreate("Server/GlobalNamingResources",
"org.apache.catalina.deploy.NamingResourcesImpl"); //创建全局名字资源
digester.addSetProperties("Server/GlobalNamingResources");
digester.addSetNext("Server/GlobalNamingResources",
"setGlobalNamingResources",
"org.apache.catalina.deploy.NamingResourcesImpl"); //其实这里实在server对象上面设置resource
digester.addObjectCreate("Server/Listener",
null, // MUST be specified in the element
"className"); //根据xml文件配置来创建listener
digester.addSetProperties("Server/Listener"); //设置listener对象配置的属性
digester.addSetNext("Server/Listener",
"addLifecycleListener",
"org.apache.catalina.LifecycleListener"); //这里其实是在server对象上面添加lifecyclelistener
digester.addObjectCreate("Server/Service",
"org.apache.catalina.core.StandardService",
"className"); //创建service对象
digester.addSetProperties("Server/Service"); //设置service的属性
digester.addSetNext("Server/Service",
"addService", //在server对象上面调用addService方法
"org.apache.catalina.Service"); //在server上面添加调用addService方法
//为service创建listener，不一定有
digester.addObjectCreate("Server/Service/Listener",
null, // MUST be specified in the element
"className"); //根据配置文件参数来创建service的listener
digester.addSetProperties("Server/Service/Listener");
digester.addSetNext("Server/Service/Listener",
"addLifecycleListener",
"org.apache.catalina.LifecycleListener");
//Executor
//创建service的executor，这个不一定有
digester.addObjectCreate("Server/Service/Executor",
"org.apache.catalina.core.StandardThreadExecutor",
"className");
digester.addSetProperties("Server/Service/Executor");
digester.addSetNext("Server/Service/Executor",
"addExecutor",
"org.apache.catalina.Executor");
//为servie添加connector规则
digester.addRule("Server/Service/Connector",
new ConnectorCreateRule()); //这个规则会创建connector，而且如果有属性执行executor的话，还会设置connector的executor
digester.addRule("Server/Service/Connector", //<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443"/>
new SetAllPropertiesRule(new String[]{"executor"})); //这里会将所有的属性都设置，除了executor
digester.addSetNext("Server/Service/Connector",
"addConnector",
"org.apache.catalina.connector.Connector"); //在service上面添加这个connector
//这里是设置connector的listener
digester.addObjectCreate("Server/Service/Connector/Listener",
null, // MUST be specified in the element
"className");
digester.addSetProperties("Server/Service/Connector/Listener");
digester.addSetNext("Server/Service/Connector/Listener",
"addLifecycleListener",
"org.apache.catalina.LifecycleListener");
// Add RuleSets for nested elements
digester.addRuleSet(new NamingRuleSet("Server/GlobalNamingResources/"));
digester.addRuleSet(new EngineRuleSet("Server/Service/")); //engine元素的定义的处理，这里主要是创建eingie
digester.addRuleSet(new HostRuleSet("Server/Service/Engine/")); //engine里面host的定义
digester.addRuleSet(new ContextRuleSet("Server/Service/Engine/Host/")); //一些context的配置处理
addClusterRuleSet(digester, "Server/Service/Engine/Host/Cluster/");
digester.addRuleSet(new NamingRuleSet("Server/Service/Engine/Host/Context/"));
// When the 'engine' is found, set the parentClassLoader.
digester.addRule("Server/Service/Engine",
new SetParentClassLoaderRule(parentClassLoader)); //如果有发现engine，那么设置container(Engine对象)的parentClassloader，shareloader
addClusterRuleSet(digester, "Server/Service/Engine/Cluster/");
long t2=System.currentTimeMillis();
if (log.isDebugEnabled()) {
log.debug("Digester for server.xml created " + ( t2-t1 ));
}
return (digester);
}
这里可以其实主要就是对于server.xml文件的处理规则，有几点需要搞清楚：
（1） digester.setUseContextClassLoader(true);这句代码，将会对Digester进行设置，待会创建对象的时候加载class的时候将会用到当前线程的classLoader，这个在前面已经强调，当前线程classLoader被设置为了catalinaLoader
（2）来看看是如何创建对象的吧，这里对于对象的创建将会创建一个ObjectCreateRule规则，这里来看看这个规则是怎么处理的吧：
//当遇到需要创建元素的element的时候要做的事情
@Override
public void begin(String namespace, String name, Attributes attributes)
throws Exception {
// Identify the name of the class to instantiate
String realClassName = className;
if (attributeName != null) {
String value = attributes.getValue(attributeName); //看是否有指定的属性
if (value != null) {
realClassName = value;
}
}
if (digester.log.isDebugEnabled()) {
digester.log.debug("[ObjectCreateRule]{" + digester.match +
"}New " + realClassName);
}
if (realClassName == null) {
throw new NullPointerException("No class name specified for " +
namespace + " " + name);
}
// Instantiate the new object and push it on the context stack
Class<?> clazz = digester.getClassLoader().loadClass(realClassName); //用classloader来载入class
Object instance = clazz.newInstance(); //创建这个对象
digester.push(instance); //放入digester
}
这里其实主要就是调用classLoader的loadClass方法来加载class，然后创建对象。。。那么这里用的是什么classLoader呢。。？来看看：
public ClassLoader getClassLoader() {
if (this.classLoader != null) {
return (this.classLoader);
}
if (this.useContextClassLoader) { //这里一般都是用这里，线程classLoader，在bootstarp里面设置为catalinaLoader
ClassLoader classLoader =
Thread.currentThread().getContextClassLoader();
if (classLoader != null) {
return (classLoader);
}
}
return (this.getClass().getClassLoader());
}
到这里就很清楚了吧，前面已经提到了，这里将会采用当前线程classLoader，也就是catalinaLoader，这里也就可以知道，对于Server对象所有东西的创建，其class的都是用的catalinaLoader。。
嗯。。。这也就是为啥说catalinaLoader是Tomcat服务器专用的了，整个Tomcat服务器的重要对象创建用到的loader都是它。。。
（3）注意一句代码： digester.addRule("Server/Service/Engine",
new SetParentClassLoaderRule(parentClassLoader)); //如果有发现engine，那么设置container(Engine对象)的parentClassloader，shareloader
它创建的规则将会将创建的engine对象的parentClassLoader设置为当前catalina对象的parentClassLoader，前面就已经说过了，当前catalina对象的parentClassLoader被设置为了sharedLoader，那么表示engine对象的parentClassLoader也会是sharedLoader。。。
（4）我们来看看创建host对象的用到的规则：
//创建host对象
digester.addObjectCreate(prefix + "Host",
"org.apache.catalina.core.StandardHost", //创建host对象的配置
"className");
digester.addSetProperties(prefix + "Host");
digester.addRule(prefix + "Host",
new CopyParentClassLoaderRule()); //会将host的parentClassloader设置为engine的，engine被设置为sharedloader
这里可以看到在host的创建中加了一个CopyParentClassLoaderRule规则，它的作用是将当前对象的parentClassLoader设置为上一层对象的parentClassLoader，host外面就是engine，那么可以知道将会将host的parentClassLoader也设置为sharedLoader。。。
好了，到这里catalina部分对classLoader的处理就差不多了。。。
到现在位置,我们知道在tomcat的启动的时候,载入tomcat系统相关的额class都是采用的catalinaLoader
然后还有在catalina对象中将parentClassLoader设置为了sharedLoader，然后engine的parentClassLoader也被设置为了sharedLoader，然后host对象的parentClassLoader也被设置为了sharedLoader，嗯，这个为以后context部分的内容埋下了伏笔。。。
好了，接下来就开始进入Context部分吧，我们知道一个Context基本上就代表了web应用程序，前面提到，每一个web应用程序都有自己专有的classLoader，那么接下来就来看看这个是如何创建的吧。。。在StandardContext的startInternal方法中，我们可以看到如下的代码：
//loader部分
if (getLoader() == null) { //这一步用于创建loader对象
WebappLoader webappLoader = new WebappLoader(getParentClassLoader()); //这里用于创建当前context用的classLoader，这里会将parent设置为sharedclassLoader
webappLoader.setDelegate(getDelegate());
setLoader(webappLoader); //保存创建的loader
}
这里是创建了WebappLoader对象，然后注意看这里传入了当前context对象的parentClassLoader，那么我们来看看这个方法：
public ClassLoader getParentClassLoader() {
if (parentClassLoader != null) {
return (parentClassLoader);
} if (getPrivileged()) {
return this.getClass().getClassLoader();
} else if (parent != null) { //一般都是使用parent的parentClassLoader，也就是host的，host将会设置为与engine一样，也就是sharedLoader
return (parent.getParentClassLoader());
}
return (ClassLoader.getSystemClassLoader());
}
由于在创建context对象的时候并没有指定parentClassLoader，所以这里返回的将是context对象的parent的parentClassLoader，。我们知道context的parent是host对象，而host对象的parentclassLoader已经被设置为了sharedLoader，所以在这里创建webapploader的时候穿进去的构造参数其实也就是sharedLoader。。。
来看看WebappLoader的构造函数吧：
public WebappLoader(ClassLoader parent) {
super();
this.parentClassLoader = parent; //parentClassLoader，一般都是sharedLoader
}
嗯，这里好像也就是主要将传进来的sharedLoader保存起来。。那么在来看看Webapploader对象是如何启动的吧：
//启动webapploader
protected void startInternal() throws LifecycleException {
if (log.isDebugEnabled())
log.debug(sm.getString("webappLoader.starting"));
if (context.getResources() == null) {
log.info("No resources for " + context);
setState(LifecycleState.STARTING);
return;
}
// Construct a class loader based on our current repositories list
try {
classLoader = createClassLoader(); //创建classLoader org.apache.catalina.loader.WebappClassLoader
classLoader.setResources(context.getResources()); //设置资源目录
classLoader.setDelegate(this.delegate);
// Configure our repositories
setClassPath(); //设置classPath
setPermissions();
((Lifecycle) classLoader).start(); //启动classLoader，里面主要是加载classes以及lib下的代码
String contextName = context.getName(); //获取当前context的名字
if (!contextName.startsWith("/")) {
contextName = "/" + contextName;
}
ObjectName cloname = new ObjectName(context.getDomain() +
":type=WebappClassLoader,host=" + context.getParent().getName() +
",context=" + contextName);
Registry.getRegistry(null, null)
.registerComponent(classLoader, cloname, null); //在jmx上面注册
} catch (Throwable t) {
t = ExceptionUtils.unwrapInvocationTargetException(t);
ExceptionUtils.handleThrowable(t);
log.error( "LifecycleException ", t );
throw new LifecycleException("start: ", t);
}
setState(LifecycleState.STARTING);
}
这里可以知道WebappLoader有一个classLoader的属性，将会在启动的时候创建，创建完了之后还会涉及到为这个classLoader设置资源，然后启动这个classLoader。。。
好啦，那就先来看看是如何创建的吧：
//创建webappclassLoader，这里会将sharedLoader设置为parent
private WebappClassLoader createClassLoader()
throws Exception {
Class<?> clazz = Class.forName(loaderClass); //获取要创建的classLoader的class引用 org.apache.catalina.loader.WebappClassLoader
WebappClassLoader classLoader = null;
if (parentClassLoader == null) {
parentClassLoader = context.getParentClassLoader(); //获取context的parentClassLoader，这里是sharedLoader
}
Class<?>[] argTypes = { ClassLoader.class };
Object[] args = { parentClassLoader };
Constructor<?> constr = clazz.getConstructor(argTypes); //获取构造函数，这里需要传递一个parentClassLoader，其实这里的双亲loader就是sharedLoader
classLoader = (WebappClassLoader) constr.newInstance(args);
return classLoader;
}
这里就很明白了，创建了一个WebappClassLoader对象，并且将其的双亲loader设置为了sharedLoader。。。。
其实到这里整个tomcat的整体的classLoader就算了解的差不多了。。
最后再来看看WebappClassLoader是怎么启动的吧：
//其实主要是加载classes与lib下的代码，jar啥的
public void start() throws LifecycleException {
WebResource classes = resources.getResource("/WEB-INF/classes"); //获取/WEB-INF/classes目录的资源引用
if (classes.isDirectory() && classes.canRead()) {
addURL(classes.getURL()); //将该资源添加到当前classLoader的资源库
}
WebResource[] jars = resources.listResources("/WEB-INF/lib"); //这里是获取lib文件夹
for (WebResource jar : jars) { //遍历所有的资源
if (jar.getName().endsWith(".jar") && jar.isFile() && jar.canRead()) {
addURL(jar.getURL()); // 将资源加入到classLoader的资源库
jarModificationTimes.put(
jar.getName(), Long.valueOf(jar.getLastModified()));
}
}
started = true;
String encoding = null;
try {
encoding = System.getProperty("file.encoding");
} catch (SecurityException e) {
return;
}
if (encoding.indexOf("EBCDIC")!=-1) {
needConvert = true;
}
}
这个代码看起来应该就很熟悉吧，加载/WEB-INF/classes以及/WEB-INF/lib下面的资源。。。
好啦。。classLoader部分就算完事了。。。可以看出tomcat8中对classLoader的处理比jetty6中还是要细致一些的。。。