Tomcat启动类加载机制总结
1 背景知识：
（1） Tomcat和CataLina是什么关系？
Tomcat的前身为Catalina，Catalina又是一个轻量级的Servlet容器。
Tomcat的前身为Catalina，Catalina又是一个轻量级的Servlet容器。在美国，catalina是一个很美的小岛。所以Tomcat作者的寓意可能是想把Tomcat设计成一个优雅美丽且轻量级的web服务器。Tomcat从4.x版本开始除了作为支持Servlet的容器外，额外加入了很多的功能，比如：jsp、el、naming等等，所以说Tomcat不仅仅是Catalina。
（2） Servlet与Tomcat的逻辑？
所谓Servlet，其实就是Sun为了让Java能实现动态可交互的网页，从而进入Web编程领域而制定的一套标准。
在互联网兴起之初，当时的Sun公司（后面被Oracle收购）已然看到了这次机遇，于是设计出了Applet来对Web应用的支持。不过事实却并不是预期那么得好，Sun悲催地发现Applet并没有给业界带来多大的影响。经过反思，Sun就想既然机遇出现了，市场前景也非常不错，总不能白白放弃了呀，怎么办呢？于是又投入精力去搞一套规范出来，这时Servlet诞生了！
一个Servlet主要做下面三件事情：
- 创建并填充Request对象，包括：URI、参数、method、请求头信息、请求体信息等
- 创建Response对象
- 执行业务逻辑，将结果通过Response的输出流输出到客户端
Servlet没有main方法，所以，如果要执行，则需要在一个容器里面才能执行，这个容器就是为了支持Servlet的功能而存在，Tomcat其实就是一个Servlet容器的实现。
（3） Tomcat总体架构
从组件的角度看
-
Server: 表示服务器，它提供了一种优雅的方式来启动和停止整个系统，不必单独启停连接器和容器；它是Tomcat构成的顶级构成元素，所有一切均包含在Server中；
-
Service: 表示服务，Server可以运行多个服务。比如一个Tomcat里面可运行订单服务、支付服务、用户服务等等；Server的实现类StandardServer可以包含一个到多个Services, Service的实现类为StandardService调用了容器(Container)接口，其实是调用了Servlet Engine(引擎)，而且StandardService类中也指明了该Service归属的Server;
-
Container: 表示容器，可以看做Servlet容器；引擎(Engine)、主机(Host)、上下文(Context)和Wraper均继承自Container接口，所以它们都是容器。
- Engine -- 引擎
- Host -- 主机
- Context -- 上下文
- Wrapper -- 包装器
-
Connector: 表示连接器, 它将Service和Container连接起来，首先它需要注册到一个Service，它的作用就是把来自客户端的请求转发到Container(容器)，这就是它为什么称作连接器, 它支持的协议如下：
- 支持AJP协议
- 支持Http协议
- 支持Https协议
-
Service内部还有各种支撑组件，下面简单罗列一下这些组件
- Manager -- 管理器，用于管理会话Session
- Logger -- 日志器，用于管理日志
- Loader -- 加载器，和类加载有关，只会开放给Context所使用
- Pipeline -- 管道组件，配合Valve实现过滤器功能
- Valve -- 阀门组件，配合Pipeline实现过滤器功能
- Realm -- 认证授权组件
从源码的设计角度看
-
Jsper模: 这个子模块负责jsp页面的解析、jsp属性的验证，同时也负责将jsp页面动态转换为java代码并编译成class文件。在Tomcat源代码中，凡是属于org.apache.jasper包及其子包中的源代码都属于这个子模块;
-
Servlet和Jsp模块: 这个子模块的源代码属于javax.servlet包及其子包，如我们非常熟悉的javax.servlet.Servlet接口、javax.servet.http.HttpServlet类及javax.servlet.jsp.HttpJspPage就位于这个子模块中;
-
Catalina模块: 这个子模块包含了所有以org.apache.catalina开头的java源代码。该子模块的任务是规范了Tomcat的总体架构，定义了Server、Service、Host、Connector、Context、Session及Cluster等关键组件及这些组件的实现，这个子模块大量运用了Composite设计模式。同时也规范了Catalina的启动及停止等事件的执行流程。从代码阅读的角度看，这个子模块应该是我们阅读和学习的重点。
-
Connector模块: 如果说上面三个子模块实现了Tomcat应用服务器的话，那么这个子模块就是Web服务器的实现。所谓连接器(Connector)就是一个连接客户和应用服务器的桥梁，它接收用户的请求，并把用户请求包装成标准的Http请求(包含协议名称，请求头Head，请求方法是Get还是Post等等)。同时，这个子模块还按照标准的Http协议，负责给客户端发送响应页面，比如在请求页面未发现时，connector就会给客户端浏览器发送标准的Http 404错误响应页面。
-
Resource模块: 这个子模块包含一些资源文件，如Server.xml及Web.xml配置文件。严格说来，这个子模块不包含java源代码，但是它还是Tomcat编译运行所必需的。
从一个完整请求的角度来看
假设来自客户的请求为：http://localhost:8080/test/index.jsp 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector,然后
- Connector把该请求交给它所在的Service的Engine来处理，并等待Engine的回应
- Engine获得请求localhost:8080/test/index.jsp，匹配它所有虚拟主机Host
- Engine匹配到名为localhost的Host(即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机)
- localhost Host获得请求/test/index.jsp，匹配它所拥有的所有Context
- Host匹配到路径为/test的Context(如果匹配不到就把该请求交给路径名为""的Context去处理)
- path="/test"的Context获得请求/index.jsp，在它的mapping table中寻找对应的servlet
- Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类，构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
- Context把执行完了之后的HttpServletResponse对象返回给Host
- Host把HttpServletResponse对象返回给Engine
- Engine把HttpServletResponse对象返回给Connector
- Connector把HttpServletResponse对象返回给客户browser
2 Tomcat启动过程
直接看时序图：
我们可以看到，Tomcat启动就是从main方法开始。我们下载Tomcat的二进制源码文件，通过ant进行build生成源文件。我们把生成的源文件bootstrap.jar和cataline.jar进行解压可以看到源代码。
Tomcat的main方法在org.apache.catalina.startup.Bootstrap 里
首先我们来看bootstap的main方法：
1 public static void main(String[] args) { 2 synchronized(daemonLock) { 3 if (daemon == null) { 4 Bootstrap bootstrap = new Bootstrap(); 5 6 try { 7 bootstrap.init(); 8 } catch (Throwable var5) { 9 handleThrowable(var5); 10 var5.printStackTrace(); 11 return; 12 } 13 14 daemon = bootstrap; 15 } else { 16 Thread.currentThread().setContextClassLoader(daemon.catalinaLoader); 17 } 18 } 19 20 try { 21 String command = "start"; 22 if (args.length > 0) { 23 command = args[args.length - 1]; 24 } 25 26 if (command.equals("startd")) { 27 args[args.length - 1] = "start"; 28 daemon.load(args); 29 daemon.start(); 30 } else if (command.equals("stopd")) { 31 args[args.length - 1] = "stop"; 32 daemon.stop(); 33 } else if (command.equals("start")) { 34 daemon.setAwait(true); 35 daemon.load(args); 36 daemon.start(); 37 if (null == daemon.getServer()) { 38 System.exit(1); 39 } 40 } else if (command.equals("stop")) { 41 daemon.stopServer(args); 42 } else if (command.equals("configtest")) { 43 daemon.load(args); 44 if (null == daemon.getServer()) { 45 System.exit(1); 46 } 47 48 System.exit(0); 49 } else { 50 log.warn("Bootstrap: command \"" + command + "\" does not exist."); 51 } 52 } catch (Throwable var7) { 53 Throwable t = var7; 54 if (var7 instanceof InvocationTargetException && var7.getCause() != null) { 55 t = var7.getCause(); 56 } 57 58 handleThrowable(t); 59 t.printStackTrace(); 60 System.exit(1); 61 }
核心流程就是Bootstrap 对象，调用它的 init 方法初始化，然后根据启动参数，分别调用 Bootstrap 对象的不同方法。
那么Init()方法做了什么呢？
public void init() throws Exception {
//初始化classloader,这就是本文的重点 this.initClassLoaders();
//设置当前线程的contextClassLoader为catalinaLoader Thread.currentThread().setContextClassLoader(this.catalinaLoader); SecurityClassLoad.securityClassLoad(this.catalinaLoader); if (log.isDebugEnabled()) { log.debug("Loading startup class"); } //通过cataLinaLoader加载CataLina,并初始化startupInstance对象 Class<?> startupClass = this.catalinaLoader.loadClass("org.apache.catalina.startup.Catalina"); Object startupInstance = startupClass.getConstructor().newInstance(); if (log.isDebugEnabled()) { log.debug("Setting startup class properties"); } //通过反射调用setParentClassLoader方法 String methodName = "setParentClassLoader"; Class<?>[] paramTypes = new Class[]{Class.forName("java.lang.ClassLoader")}; Object[] paramValues = new Object[]{this.sharedLoader}; Method method = startupInstance.getClass().getMethod(methodName, paramTypes); method.invoke(startupInstance, paramValues); this.catalinaDaemon = startupInstance; }
我们首先看一下Tomcat到底初始化了哪些classLoader:
private Object catalinaDaemon = null; ClassLoader commonLoader = null; ClassLoader catalinaLoader = null; ClassLoader sharedLoader = null; public Bootstrap() { } private void initClassLoaders() { try { //初始化commomLoader this.commonLoader = this.createClassLoader("common", (ClassLoader)null); if (this.commonLoader == null) { this.commonLoader = this.getClass().getClassLoader(); } // catalinaLoader初始化, 父classloader是commonLoader this.catalinaLoader = this.createClassLoader("server", this.commonLoader); // sharedLoader初始化,父classloader是commonLoader this.sharedLoader = this.createClassLoader("shared", this.commonLoader); } catch (Throwable var2) { handleThrowable(var2); log.error("Class loader creation threw exception", var2); System.exit(1); } }
如何创建classLoader的？
private ClassLoader createClassLoader(String name, ClassLoader parent) throws Exception {
// 从 catalina.property文件里找 common.loader, shared.loader, server.loader 对应的值 String value = CatalinaProperties.getProperty(name + ".loader"); if (value != null && !value.equals("")) { value = this.replace(value);
//构造repositories列表 List<Repository> repositories = new ArrayList(); String[] repositoryPaths = getPaths(value); String[] var6 = repositoryPaths; int var7 = repositoryPaths.length; for(int var8 = 0; var8 < var7; ++var8) { String repository = var6[var8]; try { new URL(repository); repositories.add(new Repository(repository, RepositoryType.URL)); } catch (MalformedURLException var11) { if (repository.endsWith("*.jar")) { repository = repository.substring(0, repository.length() - "*.jar".length()); repositories.add(new Repository(repository, RepositoryType.GLOB)); } else if (repository.endsWith(".jar")) { repositories.add(new Repository(repository, RepositoryType.JAR)); } else { repositories.add(new Repository(repository, RepositoryType.DIR)); } } } //再将Repository 列表传入ClassLoaderFactory.createClassLoader 方法 return ClassLoaderFactory.createClassLoader(repositories, parent); } else { return parent; } }
我们再看一下ClassLoaderFactory.createClassLoader 方法做了什么：
public static ClassLoader createClassLoader(List<ClassLoaderFactory.Repository> repositories, final ClassLoader parent) throws Exception { if (log.isDebugEnabled()) { log.debug("Creating new class loader"); } Set<URL> set = new LinkedHashSet(); if (repositories != null) { Iterator var3 = repositories.iterator(); label93: while(true) { while(true) { if (!var3.hasNext()) { break label93; } ClassLoaderFactory.Repository repository = (ClassLoaderFactory.Repository)var3.next(); if (repository.getType() == ClassLoaderFactory.RepositoryType.URL) { URL url = buildClassLoaderUrl(repository.getLocation()); if (log.isDebugEnabled()) { log.debug(" Including URL " + url); } set.add(url); } else { File directory; URL url; if (repository.getType() == ClassLoaderFactory.RepositoryType.DIR) { directory = new File(repository.getLocation()); directory = directory.getCanonicalFile(); if (validateFile(directory, ClassLoaderFactory.RepositoryType.DIR)) { url = buildClassLoaderUrl(directory); if (log.isDebugEnabled()) { log.debug(" Including directory " + url); } set.add(url); } } else if (repository.getType() == ClassLoaderFactory.RepositoryType.JAR) { directory = new File(repository.getLocation()); directory = directory.getCanonicalFile(); if (validateFile(directory, ClassLoaderFactory.RepositoryType.JAR)) { url = buildClassLoaderUrl(directory); if (log.isDebugEnabled()) { log.debug(" Including jar file " + url); } set.add(url); } } else if (repository.getType() == ClassLoaderFactory.RepositoryType.GLOB) { directory = new File(repository.getLocation()); directory = directory.getCanonicalFile(); if (validateFile(directory, ClassLoaderFactory.RepositoryType.GLOB)) { if (log.isDebugEnabled()) { log.debug(" Including directory glob " + directory.getAbsolutePath()); } String[] filenames = directory.list(); if (filenames != null) { String[] var7 = filenames; int var8 = filenames.length; for(int var9 = 0; var9 < var8; ++var9) { String s = var7[var9]; String filename = s.toLowerCase(Locale.ENGLISH); if (filename.endsWith(".jar")) { File file = new File(directory, s); file = file.getCanonicalFile(); if (validateFile(file, ClassLoaderFactory.RepositoryType.JAR)) { if (log.isDebugEnabled()) { log.debug(" Including glob jar file " + file.getAbsolutePath()); } URL url = buildClassLoaderUrl(file); set.add(url); } } } } } } } } } } final URL[] array = (URL[])set.toArray(new URL[0]); if (log.isDebugEnabled()) { for(int i = 0; i < array.length; ++i) { log.debug(" location " + i + " is " + array[i]); } } return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<URLClassLoader>() { public URLClassLoader run() { return parent == null ? new URLClassLoader(array) : new URLClassLoader(array, parent); } });
去掉主要逻辑，此方法的Repository 列表就是这个URLClassLoader 可以加在的类的路径。我们直接看返回值，返回的是
new URLClassLoader(array)
也就是返回相应的类加载器：
public class URLClassLoader extends SecureClassLoader implements Closeable { ... public URLClassLoader(URL[] urls, ClassLoader parent) { super(parent); // this is to make the stack depth consistent with 1.1 SecurityManager security = System.getSecurityManager(); if (security != null) { security.checkCreateClassLoader(); } this.acc = AccessController.getContext(); ucp = new URLClassPath(urls, acc); } ... }
public URLClassLoader(URL[] urls) {
super();
// this is to make the stack depth consistent with 1.1
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkCreateClassLoader();
}
this.acc = AccessController.getContext();
ucp = new URLClassPath(urls, acc);
}
public class SecureClassLoader extends ClassLoader {...}
此时我们就分析到最底端了。我们回过头看三个类加载器，其实可以在catalina.property文件里找到相应的配置
common.loader="${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"
server.loader=
shared.loader=
其中 shared.loader, server.loader 是没有值的，createClassLoader 方法里如果没有值的话，就返回传入的 parent ClassLoader，也就是说，commonLoader,catalinaLoader,sharedLoader 其实是一个对象。
初始化完三个ClassLoader对象后，init() 方法就使用 catalinaClassLoader 加载了org.apache.catalina.startup.Catalina 类，并创建了一个对象，然后通过反射调用这个对象的 setParentClassLoader 方法，传入的参数是 sharedClassLoader。最后吧这个 Catania 对象复制给 catalinaDaemon 属性。
3 深入理解Tomcat类加载机制：
（1）什么是类加载器?
Java是一门面向对象的语言，而对象又必然依托于类。类要运行，必须首先被加载到内存,这就需要类加载器。类加载器又有多种，比如加载java自带的核心类，加载java支持的可扩展类，加载我们程序员自己编写的类。那么为什么要设计多个类加载器呢？主要是因为安全问题。如果自己编写的类也用一个加载器进行加载的话，那么它的实现可能有一定的危险性和隐藏的安全性。
假如我们自己编写一个类
为了保证java最基本的、最核心的功能不会被破坏，java采用双亲委派模型。java.util.Object，它的实现可能有一定的危险性或者隐藏的bug。而我们知道Java自带的核心类里面也有java.util.Object，如果JVM启动的时候先行加载的是我们自己编写的java.util.Object，那么就有可能出现安全问题！（2）双亲委派模型：
双亲委派模式对类加载器定义了层级，每个类加载器都有一个父类加载器。在一个类需要加载的时候，首先委派给父类加载器来加载，而父类加载器又委派给祖父类加载器来加载，以此类推。如果父类及上面的类加载器都加载不了，那么才会由当前类加载器来加载，并将被加载的类缓存起来。
所以上述类是这么加载的
- Java自带的核心类 -- 由启动类加载器加载
- Java支持的可扩展类 -- 由扩展类加载器加载
- 我们自己编写的类 -- 默认由应用程序类加载器或其子类加载。
但是双亲委派模型也有一定的问题，就是在java核心类中，有SPI（Service Provider Interface）接口，它需要第三方实现类进行支持。如果使用双亲委派模型，那么第三方实现类也需要放在Java核心类里面才可以，不然的话第三方实现类将不能被加载使用。这显然是不合理的。为此有了上下文加载器
public void setContextClassLoader(ClassLoader cl) public ClassLoader getContextClassLoader()
我们可以通过在SPI类里面调用getContextClassLoader来获取第三方实现类的类加载器。由第三方实现类通过调用setContextClassLoader来传入自己实现的类加载器, 这样就变相地解决了双亲委派模式遇到的问题。
（3）Tomcat的类加载器
Tomcat的类加载器和双亲委派模型有所差别，主要是因为在于一个Tomcat容器允许同时运行多个Web程序，每个Web程序依赖的类又必须是相互隔离的。因此，如果Tomcat使用双亲委派模式来加载类的话，将导致Web程序依赖的类变为共享的。我们看一下tomcat的类加载器：
有点想设计模式里面的装饰器思想，Tomcat类加载器是在原有的基础上增加了功能。
Common类加载器，负责加载Tomcat和Web应用都复用的类
总结：本文主要介绍tomcat整体架构并深入分析了Tomcat类加载机制和类隔离原理，即每个
- Catalina类加载器，负责加载Tomcat专用的类，而这些被加载的类在Web应用中将不可见
- Shared类加载器，负责加载Tomcat下所有的Web应用程序都复用的类，而这些被加载的类在Tomcat中将不可见
- WebApp类加载器，负责加载具体的某个Web应用程序所使用到的类，而这些被加载的类在Tomcat和其他的Web应用程序都将不可见
- Jsp类加载器，每个jsp页面一个类加载器，不同的jsp页面有不同的类加载器，方便实现jsp页面的热插拔
为什么要分别设计类加载器呢？其实就是为了隔离。
我们先来看一个例子
package solutions; import java.io.File; import java.lang.reflect.Method; import java.net.URL; import java.net.URLClassLoader; public class ClassLoaderDemo { public static void main(String[] args) throws Exception { MyClassLoader loader = new MyClassLoader(); //使用MyClassLoader加载cl.test.A Class aClazz = loader.loadClass("solutions.A"); Object a = aClazz.newInstance(); Method getB = aClazz.getMethod("getB", null); Object b = getB.invoke(a, null); System.out.println(a.getClass().getClassLoader()); System.out.println(b.getClass().getClassLoader()); } } class MyClassLoader extends URLClassLoader{ //该路径是一个非classpath路径 public static File file = new File("D:\\myproject\\demo\\testClass"); //MyClassLoader从上面的非classpath路径加载类 public MyClassLoader() throws Exception { super(new URL[] {file.toURL()}, null, null); } }
package solutions; public class A { B b = new B(); public B getB() { return b; } } class B { }
根据输出结果可以知道：
如果一个类由某个类加载器加载，那么因为使用该类（本例中A）而加载的类
（本例中B）也会使用加载同一个类加载器其实在Tomcat中，基本上一个Web App所有的操作都是由一个
Servlet启动的，我们在定义自己的Servlet时可能会使用其他的三方类库，比如MyBatis。结合着上面的例子可以知道，如果我们在加载Servlet时使用的是一个自定义的ClassLoader类实例，那么该Servlet中引用的三方类库，如：MyBatis也会由该ClassLoader加载。显然是不符合Tomcat的要求的。所以怎么解决隔离的要求呢？我们为每个Web App都专门实例化一个
ClassLoader实例，那么这样就做到了不同Web App的隔离。因为我们知道Java中一个类是由该类名称以及该类的defining loader定义的。
接下来我们来看Tomcat是如何加载web app目录里的web app的。
（4）StandardContext实例化
package org.apache.catalina.startup; public void start() { if (log.isDebugEnabled()) { log.debug(sm.getString("hostConfig.start")); } try { ObjectName hostON = this.host.getObjectName(); this.oname = new ObjectName(hostON.getDomain() + ":type=Deployer,host=" + this.host.getName()); Registry.getRegistry((Object)null, (Object)null).registerComponent(this, this.oname, this.getClass().getName()); } catch (Exception var2) { log.warn(sm.getString("hostConfig.jmx.register", new Object[]{this.oname}), var2); } if (!this.host.getAppBaseFile().isDirectory()) { log.error(sm.getString("hostConfig.appBase", new Object[]{this.host.getName(), this.host.getAppBaseFile().getPath()})); this.host.setDeployOnStartup(false); this.host.setAutoDeploy(false); } if (this.host.getDeployOnStartup()) { this.deployApps(); } }
protected void deployApps() {
File appBase = this.host.getAppBaseFile();
File configBase = this.host.getConfigBaseFile();
String[] filteredAppPaths = this.filterAppPaths(appBase.list());
//Deploy XML descriptors from configBase
this.deployDescriptors(configBase, configBase.list());
//Deploy wars
this.deployWARs(appBase, filteredAppPaths);
//Deploy expanded folders
//我们主要看如何部署webapps里面的应用
this.deployDirectories(appBase, filteredAppPaths);
}
protected void deployDirectories(File appBase, String[] files) { if (files != null) { ExecutorService es = this.host.getStartStopExecutor(); List<Future<?>> results = new ArrayList(); String[] var5 = files; int var6 = files.length; //对于webapps下面的所有目录，进行依次部署，一般一个目录表示一个单独的web app for(int var7 = 0; var7 < var6; ++var7) { String file = var5[var7]; if (!file.equalsIgnoreCase("META-INF") && !file.equalsIgnoreCase("WEB-INF")) { File dir = new File(appBase, file); if (dir.isDirectory()) { ContextName cn = new ContextName(file, false); if (!this.isServiced(cn.getName()) && !this.deploymentExists(cn.getName())) { //并行部署多个web app,DeployDirectory构造函数第一个参数为HostConfig，这里传的是this
results.add(es.submit(new HostConfig.DeployDirectory(this, cn, dir))); } } } } Iterator var12 = results.iterator(); while(var12.hasNext()) { Future result = (Future)var12.next(); try { result.get(); } catch (Exception var11) { log.error(sm.getString("hostConfig.deployDir.threaded.error"), var11); } } } }
我们再来看看DeployDirectory的定义：
private static class DeployDirectory implements Runnable { private HostConfig config; private ContextName cn; private File dir; public DeployDirectory(HostConfig config, ContextName cn, File dir) { this.config = config; this.cn = cn; this.dir = dir; } public void run() { //这里调用HostConfig的deployDirectory进行单个web app this.config.deployDirectory(this.cn, this.dir); } }
我们来看deployDirectioy()方法：
protected void deployDirectory(ContextName cn, File dir) { long startTime = 0L; if (log.isInfoEnabled()) {
startTime = System.currentTimeMillis(); log.info(sm.getString("hostConfig.deployDir", new Object[]{dir.getAbsolutePath()})); } Context context = null; File xml = new File(dir, "META-INF/context.xml"); File xmlCopy = new File(this.host.getConfigBaseFile(), cn.getBaseName() + ".xml"); boolean copyThisXml = this.isCopyXML(); boolean deployThisXML = this.isDeployThisXML(dir, cn); HostConfig.DeployedApplication deployedApp; try { if (deployThisXML && xml.exists()) { synchronized(this.digesterLock) { try {
//最主要的代码就是这里，这里会创建一个StandardContext类实例，也就是每个web app
//都会对应一个StandardContext实例 context = (Context)this.digester.parse(xml); } catch (Exception var26) { log.error(sm.getString("hostConfig.deployDescriptor.error", new Object[]{xml}), var26); context = new FailedContext(); } finally { this.digester.reset(); if (context == null) { context = new FailedContext(); } } } if (!copyThisXml && context instanceof StandardContext) { copyThisXml = ((StandardContext)context).getCopyXML(); } if (copyThisXml) { Files.copy(xml.toPath(), xmlCopy.toPath()); ((Context)context).setConfigFile(xmlCopy.toURI().toURL()); } else { ((Context)context).setConfigFile(xml.toURI().toURL()); } } else if (!deployThisXML && xml.exists()) { log.error(sm.getString("hostConfig.deployDescriptor.blocked", new Object[]{cn.getPath(), xml, xmlCopy})); context = new FailedContext(); } else {
//contextClass = org.apache.catalina.core.StandardContext
//同样是实例化一个StandardContext的实例
context = (Context)Class.forName(this.contextClass).getConstructor().newInstance(); } ... }
也就是说，每个web app都会对应一个StandardContext实例。
接下来我们可以看下StandardContext与类加载机制的StandardContext.startInternal（）方法。
package org.apache.catalina.core; protected synchronized void startInternal() throws LifecycleException { if (log.isDebugEnabled()) { log.debug("Starting " + this.getBaseName()); } //1.发布正在启动的JMX通知，这样可以通过NotificationListener来监听Web应用的启动。 if (this.getObjectName() != null) { Notification notification = new Notification("j2ee.state.starting", this.getObjectName(), this.sequenceNumber.getAndIncrement()); this.broadcaster.sendNotification(notification); } this.setConfigured(false); boolean ok = true;//2.启动当前维护的JNDI资源。(哼，不懂JNDI) if (this.namingResources != null) { this.namingResources.start(); } //3.初始化临时工作目录，即设置的workDir，默认为$CATALINA-BASE/work/<Engine名称>/<Host名称>/<Context名称>。 this.postWorkDirectory();
//4.初始化当前Context使用的WebResouceRoot并启动。
//WebResouceRoot维护了Web应用所以的资源集合（Class文件、Jar包以及其他资源文件），主要用于类加载器和按照路径查找资源文件。
if (this.getResources() == null) { if (log.isDebugEnabled()) { log.debug("Configuring default Resources"); } try { this.setResources(new StandardRoot(this)); } catch (IllegalArgumentException var21) { log.error(sm.getString("standardContext.resourcesInit"), var21); ok = false; } } if (ok) { this.resourcesStart(); } //5.创建Web应用类加载器webappLoader，webappLoader继承自LifecycleMBeanBase，
//在其启动后会去创建Web应用类加载器(ParallelWebappClassLoader)。
//每个StandardContext对象都持有一个WebappLoader对象，也就是自己的//类加载器，所有该StandardContext加载的三方类和其他StandardContext加载的三方类是隔离的
//getParentClassLoader返回的parentClassLoader是其父类加载器
//是由CopyParentClassLoaderRule.begin中配置的，通过digester
//注入的，实现share加载if (this.getLoader() == null) {
WebappLoader webappLoader = new WebappLoader(); webappLoader.setDelegate(this.getDelegate()); this.setLoader(webappLoader); } //6如果没有设置Cookie处理器，默认为Rfc6265CookieProcessor。 if (this.cookieProcessor == null) { this.cookieProcessor = new Rfc6265CookieProcessor(); } //7设置字符集映射，用于根据Locale获取字符集编码。 this.getCharsetMapper(); boolean dependencyCheck = true; //8web应用的依赖检测 try { dependencyCheck = ExtensionValidator.validateApplication(this.getResources(), this); } catch (IOException var20) { log.error(sm.getString("standardContext.extensionValidationError"), var20); dependencyCheck = false; } if (!dependencyCheck) { ok = false; } //9 NamingContextListener注册 String useNamingProperty = System.getProperty("catalina.useNaming"); if (useNamingProperty != null && useNamingProperty.equals("false")) { this.useNaming = false; } if (ok && this.isUseNaming() && this.getNamingContextListener() == null) { NamingContextListener ncl = new NamingContextListener(); ncl.setName(this.getNamingContextName()); ncl.setExceptionOnFailedWrite(this.getJndiExceptionOnFailedWrite()); this.addLifecycleListener(ncl); this.setNamingContextListener(ncl); } if (log.isDebugEnabled()) { log.debug("Processing standard container startup"); } ClassLoader oldCCL = this.bindThread(); //10启动Web应用类加载器，此时真正创建出ParallelWebappClassLoader实例 try { if (ok) { Loader loader = this.getLoader(); if (loader instanceof Lifecycle) { ((Lifecycle)loader).start(); } this.setClassLoaderProperty("clearReferencesRmiTargets", this.getClearReferencesRmiTargets()); this.setClassLoaderProperty("clearReferencesStopThreads", this.getClearReferencesStopThreads()); this.setClassLoaderProperty("clearReferencesStopTimerThreads", this.getClearReferencesStopTimerThreads()); this.setClassLoaderProperty("clearReferencesHttpClientKeepAliveThread", this.getClearReferencesHttpClientKeepAliveThread()); this.setClassLoaderProperty("clearReferencesObjectStreamClassCaches", this.getClearReferencesObjectStreamClassCaches()); this.setClassLoaderProperty("clearReferencesObjectStreamClassCaches", this.getClearReferencesObjectStreamClassCaches()); this.setClassLoaderProperty("clearReferencesThreadLocals", this.getClearReferencesThreadLocals()); this.unbindThread(oldCCL); oldCCL = this.bindThread(); this.logger = null; this.getLogger();
//11启动安全组件 Realm realm = this.getRealmInternal(); if (null != realm) { if (realm instanceof Lifecycle) { ((Lifecycle)realm).start(); } CredentialHandler safeHandler = new CredentialHandler() { public boolean matches(String inputCredentials, String storedCredentials) { return StandardContext.this.getRealmInternal().getCredentialHandler().matches(inputCredentials, storedCredentials); } public String mutate(String inputCredentials) { return StandardContext.this.getRealmInternal().getCredentialHandler().mutate(inputCredentials); } }; this.context.setAttribute("org.apache.catalina.CredentialHandler", safeHandler); } //12发布configure_start事件，ContextConfig监听该实践以完成Servlet的创建
this.fireLifecycleEvent("configure_start", (Object)null);
Container[] var31 = this.findChildren();
int var8 = var31.length;
//13.启动Context子节点Wrapper。
for(int var9 = 0; var9 < var8; ++var9) {
Container child = var31[var9];
if (!child.getState().isAvailable()) {
child.start();
}
}
//14启动Context的pipeline。
if (this.pipeline instanceof Lifecycle) {
((Lifecycle)this.pipeline).start();
}
//15创建会话管理器
Manager contextManager = null;
Manager manager = this.getManager();
if (manager == null) {
if (log.isDebugEnabled()) {
log.debug(sm.getString("standardContext.cluster.noManager", new Object[]{this.getCluster() != null, this.distributable}));
}
if (this.getCluster() != null && this.distributable) {
try {
contextManager = this.getCluster().createManager(this.getName());
} catch (Exception var19) {
log.error(sm.getString("standardContext.cluster.managerError"), var19);
ok = false;
}
} else {
contextManager = new StandardManager();
}
}
//16将Context的Web资源集合添加到ServletContext。
if (contextManager != null) {
if (log.isDebugEnabled()) {
log.debug(sm.getString("standardContext.manager", new Object[]{contextManager.getClass().getName()}));
}
this.setManager((Manager)contextManager);
}
if (manager != null && this.getCluster() != null && this.distributable) {
this.getCluster().registerManager(manager);
}
}
if (!this.getConfigured()) {
log.error(sm.getString("standardContext.configurationFail"));
ok = false;
}
//17创建实例管理器instanceManager，用于创建对象实例，如Servlet、Filter等。
if (ok) {
this.getServletContext().setAttribute("org.apache.catalina.resources", this.getResources());
if (this.getInstanceManager() == null) {
this.setInstanceManager(this.createInstanceManager());
}
//18将Jar包扫描器添加到ServletContext
this.getServletContext().setAttribute(InstanceManager.class.getName(), this.getInstanceManager());
InstanceManagerBindings.bind(this.getLoader().getClassLoader(), this.getInstanceManager());
this.getServletContext().setAttribute(JarScanner.class.getName(), this.getJarScanner());
this.getServletContext().setAttribute("org.apache.catalina.webappVersion", this.getWebappVersion());
}
//19合并参数
this.mergeParameters();
Iterator var27 = this.initializers.entrySet().iterator();
while(var27.hasNext()) {
Entry entry = (Entry)var27.next();
//20启动添加到Context的ServletContainerInitializer。
try {
((ServletContainerInitializer)entry.getKey()).onStartup((Set)entry.getValue(), this.getServletContext());
} catch (ServletException var22) {
log.error(sm.getString("standardContext.sciFail"), var22);
ok = false;
break;
}
}
//21实例化应用类监听器ApplicationListener。
if (ok && !this.listenerStart()) {
log.error(sm.getString("standardContext.listenerFail"));
ok = false;
}
if (ok) {
this.checkConstraintsForUncoveredMethods(this.findConstraints());
}
//22启动会话管理器
try {
Manager manager = this.getManager();
if (manager instanceof Lifecycle) {
((Lifecycle)manager).start();
}
} catch (Exception var18) {
log.error(sm.getString("standardContext.managerFail"), var18);
ok = false;
}
//23实例化FilterConfig、Filter并调用Filter.init()
if (ok && !this.filterStart()) {
log.error(sm.getString("standardContext.filterFail"));
ok = false;
}
//24对于loadOnStartup大于等于0的Wrapper，调用Wrapper.load()，该方法负责实例化Servlet，并调用Servlet.init()进行初始化
if (ok && !this.loadOnStartup(this.findChildren())) {
log.error(sm.getString("standardContext.servletFail"));
ok = false;
}
//25启动后台定时处理程序，只有backgroundProcessorDelay>0才启动，用于监控守护文件的变更。
super.threadStart();
} finally {
this.unbindThread(oldCCL);
}
if (ok) {
if (log.isDebugEnabled()) {
log.debug("Starting completed");
}
} else {
log.error(sm.getString("standardContext.startFailed", new Object[]{this.getName()}));
}
//26发布正在运行的JMX通知。
this.startTime = System.currentTimeMillis();
Notification notification;
if (ok && this.getObjectName() != null) {
notification = new Notification("j2ee.state.running", this.getObjectName(), this.sequenceNumber.getAndIncrement());
this.broadcaster.sendNotification(notification);
}
//27释放资源，如关闭jar文件
this.getResources().gc();
if (!ok) {//28设置Context状态
this.setState(LifecycleState.FAILED);
if (this.getObjectName() != null) {
notification = new Notification("j2ee.object.failed", this.getObjectName(), this.sequenceNumber.getAndIncrement());
this.broadcaster.sendNotification(notification);
}
} else {
this.setState(LifecycleState.STARTING);
}
//3.初始化临时工作目录，即设置的workDir，默认为$CATALINA-BASE/work/<Engine名称>/<Host名称>/<Context名称>。private void postWorkDirectory() {
String workDir = this.getWorkDir();
String engineName;
if (workDir == null || workDir.length() == 0) {
String hostName = null;
engineName = null;
String hostWorkDir = null;
Container parentHost = this.getParent();
if (parentHost != null) {
hostName = parentHost.getName();
if (parentHost instanceof StandardHost) {
hostWorkDir = ((StandardHost)parentHost).getWorkDir();
}
Container parentEngine = parentHost.getParent();
if (parentEngine != null) {
engineName = parentEngine.getName();
}
}
if (hostName == null || hostName.length() < 1) {
hostName = "_";
}
if (engineName == null || engineName.length() < 1) {
engineName = "_";
}
String temp = this.getBaseName();
if (temp.startsWith("/")) {
temp = temp.substring(1);
}
temp = temp.replace('/', '_');
temp = temp.replace('\\', '_');
if (temp.length() < 1) {
temp = "ROOT";
}
if (hostWorkDir != null) {
workDir = hostWorkDir + File.separator + temp;
} else {
workDir = "work" + File.separator + engineName + File.separator + hostName + File.separator + temp;
}
this.setWorkDir(workDir);
}
File dir = new File(workDir);
if (!dir.isAbsolute()) {
engineName = null;
try {
engineName = this.getCatalinaBase().getCanonicalPath();
dir = new File(engineName, workDir);
} catch (IOException var7) {
log.warn(sm.getString("standardContext.workCreateException", new Object[]{workDir, engineName, this.getName()}), var7);
}
}
if (!dir.mkdirs() && !dir.isDirectory()) {
log.warn(sm.getString("standardContext.workCreateFail", new Object[]{dir, this.getName()}));
}
if (this.context == null) {
this.getServletContext();
}
this.context.setAttribute("javax.servlet.context.tempdir", dir);
this.context.setAttributeReadOnly("javax.servlet.context.tempdir");
}
//5同时webappLoader提供了backgroundProcess方法，用于Context后台处理，
//当检测到Web应用的类文件、Jar包发生变化时，重新加载Context。
public void backgroundProcess() {
if (reloadable && modified()) {
try {
Thread.currentThread().setContextClassLoader
(WebappLoader.class.getClassLoader());
if (context != null) {
context.reload();
}
} finally {
if (context != null && context.getLoader() != null) {
Thread.currentThread().setContextClassLoader
(context.getLoader().getClassLoader());
}
}
}
}//7.设置字符集映射，用于根据Locale获取字符集编码。
public CharsetMapper getCharsetMapper() {
// Create a mapper the first time it is requested
if (this.charsetMapper == null) {
try {
Class<?> clazz = Class.forName(charsetMapperClass);
this.charsetMapper = (CharsetMapper) clazz.getConstructor().newInstance();
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
this.charsetMapper = new CharsetMapper();
}
}
return this.charsetMapper;
}//19合并参数
private void mergeParameters() {
Map<String, String> mergedParams = new HashMap();
String[] names = this.findParameters();
String[] var3 = names;
int var4 = names.length;
int var5;
for(var5 = 0; var5 < var4; ++var5) {
String s = var3[var5];
mergedParams.put(s, this.findParameter(s));
}
ApplicationParameter[] params = this.findApplicationParameters();
ApplicationParameter[] var9 = params;
var5 = params.length;
for(int var12 = 0; var12 < var5; ++var12) {
ApplicationParameter param = var9[var12];
if (param.getOverride()) {
if (mergedParams.get(param.getName()) == null) {
mergedParams.put(param.getName(), param.getValue());
}
} else {
mergedParams.put(param.getName(), param.getValue());
}
}
ServletContext sc = this.getServletContext();
Iterator var11 = mergedParams.entrySet().iterator();
while(var11.hasNext()) {
Entry<String, String> entry = (Entry)var11.next();
sc.setInitParameter((String)entry.getKey(), (String)entry.getValue());
}
}
(5)servlet加载：
要介绍Servlet加载首先要看下StandardWrapper类，StandardWrapper是Servlet的封装，在web.xml中配置的每个servlet-class都会对应一个StandardWrapper，StandardWrapper.servletClass(String类型，还未加载)对应其servlet-class具体配置。
不管是在启动时加载Servlet还是在第一个请求到来时加载Servlet都会调用StandardWrapper.load方法。
在介绍StandardWrapper.load方法之前，我们首先看下InstanceManager，每个StandardContext都会持有一个InstanceManager实例，StandardContext.InstanceManager会在StandardContext.startInternal中实例化，默认的InstanceManager实现是DefaultInstanceManager,DefaultInstanceManager会持有一个ClassLoader实例，该ClassLoader实例其实就是StandardContext持有的WebappLoader.classLoader。
public DefaultInstanceManager(Context context, Map<String, Map<String, String>> injectionMap, org.apache.catalina.Context catalinaContext, ClassLoader containerClassLoader) {
//获取standardContext持有的webapploader.classLoader
this.classLoader = catalinaContext.getLoader().getClassLoader(); this.privileged = catalinaContext.getPrivileged(); this.containerClassLoader = containerClassLoader;//是加载StandardContext类的类加载器 this.ignoreAnnotations = catalinaContext.getIgnoreAnnotations(); Log log = catalinaContext.getLogger(); Set<String> classNames = new HashSet(); loadProperties(classNames, "org/apache/catalina/core/RestrictedServlets.properties", "defaultInstanceManager.restrictedServletsResource", log); loadProperties(classNames, "org/apache/catalina/core/RestrictedListeners.properties", "defaultInstanceManager.restrictedListenersResource", log); loadProperties(classNames, "org/apache/catalina/core/RestrictedFilters.properties", "defaultInstanceManager.restrictedFiltersResource", log); this.restrictedClasses = Collections.unmodifiableSet(classNames); this.context = context; this.injectionMap = injectionMap; this.postConstructMethods = catalinaContext.findPostConstructMethods(); this.preDestroyMethods = catalinaContext.findPreDestroyMethods(); }
我们看一下StandardWrapper.load方法：
public synchronized void load() throws ServletException { this.instance = this.loadServlet(); if (!this.instanceInitialized) { this.initServlet(this.instance); } if (this.isJspServlet) { StringBuilder oname = new StringBuilder(this.getDomain()); oname.append(":type=JspMonitor"); oname.append(this.getWebModuleKeyProperties()); oname.append(",name="); oname.append(this.getName()); oname.append(this.getJ2EEKeyProperties()); try { this.jspMonitorON = new ObjectName(oname.toString()); Registry.getRegistry((Object)null, (Object)null).registerComponent(this.instance, this.jspMonitorON, (String)null); } catch (Exception var3) { this.log.warn(sm.getString("standardWrapper.jspMonitorError", new Object[]{this.instance})); } } } public synchronized Servlet loadServlet() throws ServletException { if (!this.singleThreadModel && this.instance != null) { return this.instance; } else { PrintStream out = System.out; if (this.swallowOutput) { SystemLogHandler.startCapture(); } boolean var12 = false; Servlet servlet; try { var12 = true; long t1 = System.currentTimeMillis(); if (this.servletClass == null) { this.unavailable((UnavailableException)null); throw new ServletException(sm.getString("standardWrapper.notClass", new Object[]{this.getName()})); } //获取StandardContext持有的InstanceManager对象实例 InstanceManager instanceManager = ((StandardContext)this.getParent()).getInstanceManager(); //加载servlet try { servlet = (Servlet)instanceManager.newInstance(this.servletClass); } catch (ClassCastException var13) { this.unavailable((UnavailableException)null); throw new ServletException(sm.getString("standardWrapper.notServlet", new Object[]{this.servletClass}), var13); } catch (Throwable var14) { .....}
下面看DefaultInstanceManager.newInstance是如何实例化类的：
public Object newInstance(String className) throws IllegalAccessException, InvocationTargetException, NamingException, InstantiationException, ClassNotFoundException, IllegalArgumentException, NoSuchMethodException, SecurityException { //首先根据类名加载Class对象 Class<?> clazz = this.loadClassMaybePrivileged(className, this.classLoader); return this.newInstance(clazz.getConstructor().newInstance(), clazz); } protected Class<?> loadClassMaybePrivileged(String className, ClassLoader classLoader) throws ClassNotFoundException { Class clazz; if (SecurityUtil.isPackageProtectionEnabled()) { try { clazz = (Class)AccessController.doPrivileged(new DefaultInstanceManager.PrivilegedLoadClass(className, classLoader)); } catch (PrivilegedActionException var6) { Throwable t = var6.getCause(); if (t instanceof ClassNotFoundException) { throw (ClassNotFoundException)t; } throw new RuntimeException(t); } } else { //实际调用loadClass方法 clazz = this.loadClass(className, classLoader); } this.checkAccess(clazz); return clazz; } protected Class<?> loadClass(String className, ClassLoader classLoader) throws ClassNotFoundException { //如果是Tomcat内部类，则只使用containerClassLoader尝试加载 //containerClassLoader是构造函数中传入的加载StandardContext类的加载器 //这是和其他StandardContext共用的加载器 if (className.startsWith("org.apache.catalina")) { return this.containerClassLoader.loadClass(className); } else { try { //如果不是Tomcat内部类，同样先使用containerClassLoader进行加载 //所以Servlet中引用的三方类会先使用share版本 Class<?> clazz = this.containerClassLoader.loadClass(className); if (ContainerServlet.class.isAssignableFrom(clazz)) { return clazz; } } catch (Throwable var4) { ExceptionUtils.handleThrowable(var4); } //如果不是上述情景，则使用该StandardContext自己的类加载器进行加载 return classLoader.loadClass(className); } }
StandardContext都持有一个自己的ClassLoader实例。参考文档：
2 https://www.jianshu.com/p/eba6d4227ddf
3 https://www.jianshu.com/p/bb943f64e4ba
