Tomcat9中类加载体系是怎么样的
小编给大家分享一下Tomcat9中类加载体系是怎么样的，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！
创新互联拥有一支富有激情的企业网站制作团队，在互联网网站建设行业深耕十年，专业且经验丰富。十年网站优化营销经验，我们已为成百上千中小企业提供了成都网站制作、网站设计解决方案，按需开发网站，设计满意，售后服务无忧。所有客户皆提供一年免费网站维护!
1.概要
Tomcat作为Web容器，支持多个应用程序的部署运行，所以会涉及应用程序间类库的隔离和共享，例如：不同应用程序既可以使用某个工具类库的不同版本但互不影响，亦可以共享使用某个类库。
2.JVM双亲委派模型
在JVM中有3种系统提供的类加载器：
启动类加载器Bootstrap ClassLoader：这负载加载存放在
/lib目录中的类库，启动类加载器无法被Java程序直接引用 扩展类加载器Extension ClassLoader：负载加载
/lib/ext目录中的类库 应用程序类加载器 Application ClassLoader：负载加载用户类路径CLASSPATH上所指定的类库，ClassLoader.getSysteClassLoader()方法的返回值就是此加载器，一般情况下这个就是程序中默认的类加载器
我们的应用程序都是由这3种类加载器互相配合进行加载的，还可以加入自己定义的类加载器，他们之间的关系如图所示：
图中展示的类加载器之间的层次关系，成为类加载器的双亲委派模型（Parents Delegation Model），双亲委派模型要求除了顶层的启动类加载器之外，其余的类加载器都应该有父类加载器。这里类加载器之间的父子关系一般不会继承（Inheritance）的强耦合关系来实现，而是使用组合（Composition）的弱耦合关系来复用父加载器的代码。
类加载器的双亲委派模型在JDK1.2期间被引入并被广泛应用于之后的所有Java程序中，但它并不是一个强制的约束模型，而是Java设计者推荐给开发者的一种类加载器实现方式，在之后章节中会看到，在Apache Tomcat中就打破了此模型。
双亲委派模型的工作过程是：如果一个类加载器收到加载类的请求，他首先不会自己去加载这个类，而是把这个请求委派给父加载器去完成，每个层次的类加载器都是如此处理，所有的加载请求最终都会传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求时（没有找类），子加载器才会尝试自己加载。
双亲委派模型本质上就是委托代理，虽然简单，却使Java类随着类加载器一起具备了优先级层次，例如类java.lang.Object，它存放在rt.jar之中，无论哪一个类加载器加载这个类，最终都是委派给启动类加载器进行加载，最终Object类在程序中的各种类加载器环境中都是同一个类。也就是说，如果你尝试编写一个与rJDK基础类库中已有类重名的Java类，类似java.lang.Object，你会发现，虽然可以正常编译，但永远无法被加载运行。
3.Tomcat9类加载体系
功能健全的Web容器的类加载器需要支持以下几点：
服务器的类库要与Web应用程序类库互相隔离，互不影响
同一个服务器上两个Web程序所使用的Java类库实现互相独立隔离
同一个服务器上了两个Web应用程序所使用的Java类库可以被共享
支持JSP的热替换（HotSwap），修改JSP文件不需要重启服务器
基于以上需求，下图为Tomcat类加载器的委派关系：
Common ClassLoader：Tomcat的基本类加载器，加载路径中的class可以被Tomcat容器本身以及各个Webapp应用程序访问
Catalina ClassLoader：Tomcat容器私有的类加载器，加载路径中的class仅对Tomcat容器本身可见，Webapp应用程序不可访问
Shared ClassLoader：各个Webapp应用程序共享的类加载器，加载路径中的class对于所有的webapp可见
Webapp ClassLoader:各个 Webapp私有的类加载器，加载路径中的class仅对当前webapp可见
JasperLoader：记载方位仅为JSP文件所编译出的一个.class文件，当容器检测到JSP文件被修改时，互替换掉目前的JasperLoader实例，通过新建一个JSP类加载器来实现JSP文件的HotSwap功能
4.源码分析
org.apache.catalina.startup.Bootstrap.init()
/**
* Initialize daemon.
* @throws Exception Fatal initialization error
*/
public void init() throws Exception {
initClassLoaders(); //初始化类加载器
Thread.currentThread().setContextClassLoader(catalinaLoader); //设置当前线程类加载器为catalinaLoader
SecurityClassLoad.securityClassLoad(catalinaLoader); //使用Java SecurityManager初始化
// 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.getConstructor().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; //WebappLoader的parentLoader
Method method =
startupInstance.getClass().getMethod(methodName, paramTypes);
method.invoke(startupInstance, paramValues);
catalinaDaemon = startupInstance;
}commLoader、catalinaLoader和sharedLoader的初始化是在Tomcat容器运行的最初进行的，调用的方法为org.apache.catalina.startup.Bootstrap.init()
initClassLoaders初始化commLoader、catalinaLoader和sharedLoader
设置当前线程的类加载器为catalinaLoader，实现catalinaLoader为容器自身的私有类加载的目的
当使用Java SecurityManager时进行一些初始化工作
将sharedLoader向后传递，以作为webappLoader的parent
org.apache.catalina.startup.Bootstrap.initClassLoaders()
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);
}
}initClassLoaders方法中，对commLoader、catalinaLoader和sharedLoader进行初始化
commLoader、catalinaLoader和sharedLoader均通过createClassLoader创建
createClassLoader方法的第二参数为父类加载器，所以catalinaLoader、sharedLoader的父类加载器为commLoader
org.apache.catalina.startup.Bootstrap.createClassLoader()
private ClassLoader createClassLoader(String name, ClassLoader parent)
throws Exception {
String value = CatalinaProperties.getProperty(name + ".loader");
if ((value == null) || (value.equals("")))
return parent;
value = replace(value);
List repositories = new ArrayList<>();
String[] repositoryPaths = getPaths(value);
for (String repository : repositoryPaths) {
// Check for a JAR URL repository
try {
@SuppressWarnings("unused")
URL url = new URL(repository);
repositories.add(new Repository(repository, RepositoryType.URL));
continue;
} catch (MalformedURLException e) {
// Ignore
}
// Local repository
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));
}
}
return ClassLoaderFactory.createClassLoader(repositories, parent);
} 获取类加载器相应的加载路径，路径的配置信息默认在conf/catalina.properties中，也可以通过环境变量catalina.config指定配置文件
类加载路径支持：.jar、*.jar和目录三种形式
当没有配置类加载器对应的加载路径时，则直接返回父类加载器。Tomcat9中catalinaLoader和sharedLoader均没有进行配置，故这两个加载器均为commonLoader
以下为Tomat9的conf/catalina.properties默认的加载路径配置：common.loader="${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar" server.loader= shared.loader=org.apache.catalina.core.StandardContext.startInternal()
/**
* Start this component and implement the requirements
* of {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
*
* @exception LifecycleException if this component detects a fatal error
* that prevents this component from being used
*/
@Override
protected synchronized void startInternal() throws LifecycleException {
...省略其他代码...
if (getLoader() == null) {
WebappLoader webappLoader = new WebappLoader(getParentClassLoader());
webappLoader.setDelegate(getDelegate());
setLoader(webappLoader);
}
...省略其他代码...
}webappLoader的初始化在StandardContext中进行，这里创建WebappLoader
org.apache.catalina.loader.WebappLoader
//重新实现ClassLoader
private String loaderClass = ParallelWebappClassLoader.class.getName();
@Override
protected void startInternal() throws LifecycleException {
...省略其他代码...
// Construct a class loader based on our current repositories list
try {
classLoader = createClassLoader(); //创建webappLoader
classLoader.setResources(context.getResources());
classLoader.setDelegate(this.delegate); //是否双亲委派
...省略其他代码...
}
/**
* Create associated classLoader.
*/
private WebappClassLoaderBase createClassLoader()
throws Exception {
Class clazz = Class.forName(loaderClass);
WebappClassLoaderBase classLoader = null;
if (parentClassLoader == null) {
parentClassLoader = context.getParentClassLoader();
}
Class[] argTypes = { ClassLoader.class };
Object[] args = { parentClassLoader };
Constructor constr = clazz.getConstructor(argTypes);
classLoader = (WebappClassLoaderBase) constr.newInstance(args); //反射创建类加载器
return classLoader;
}在WebappLoader的startInternal()方法调用createClassLoader()创建webappLoader
createClassLoader()通过反射创建ParallelWebappClassLoader
org.apache.catalina.loader.ParallelWebappClassLoader
public class ParallelWebappClassLoader extends WebappClassLoaderBase{
...省略其他代码...
}
public abstract class WebappClassLoaderBase extends URLClassLoader
implements Lifecycle, InstrumentableClassLoader, WebappProperties, PermissionCheck {
...省略其他代码...
@Override
public Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
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);
// (0)检查之前加载过的本地缓存，如果缓存存在，则取缓存中的类
clazz = findLoadedClass0(name);
if (clazz != null) {
if (log.isDebugEnabled())
log.debug(" Returning class from cache");
if (resolve)
resolveClass(clazz);
return clazz;
}
// (0.1)检查之前加载过的本地缓存，如果缓存存在，则取缓存中的类
// GraalVM直接返回null，查询缓存时，会校验name的合法性
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) 通过系统加载器加载类，放置webapp中覆写Java SE的基础类
//此处的类加载器应为Bootstrap ClassLoader
String resourceName = binaryNameToPath(name, false);
ClassLoader javaseLoader = getJavaseClassLoader();
boolean tryLoadingFromJavaseLoader;
try {
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
}
}
// (0.5) SecurityManager安全检查
if (securityManager != null) {
int i = name.lastIndexOf('.');
if (i >= 0) {
try {
securityManager.checkPackageAccess(name.substring(0,i));
} catch (SecurityException se) {
String error = sm.getString("webappClassLoader.restrictedPackage", name);
log.info(error, se);
throw new ClassNotFoundException(error, se);
}
}
}
boolean delegateLoad = delegate || filter(name, true);
// (1) 当设置双亲委派或者加载类的名称为Tomcat容器内部的类，则委托给父类加载器加载
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) 在应用类加载路径进行加载
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) 委托父类加载器加载
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);
}
...省略其他代码...
} ParallelWebappClassLoader继承了WebappClassLoaderBase，而WebappClassLoaderBase继承了URLClassLoader，并覆写了loadClass()方法，相当于实现了自己的类加载器
loadClass()方法显示，Tomcat类加载体系打破了双亲委派模型，其加载过程为
从缓存中查询，如果已加载过，则直接返回缓存中的class
通过系统类加载器加载(Bootstrap ClassLoader)，已避免应用程序中覆写JavaSE基础类
判断是否设置为双亲委派，或者classname为特定路径下的，则委托给父类加载器夹杂
通过应用程序类加载路径加载，加载通过WebResourceRoot进行
当双亲委派标记为假时，最终委托给父类加载器加载
其中必须通过父类加载加载的类名称通过filter()方法判断：
protected boolean filter(String name, boolean isClassName) {
if (name == null)
return false;
char ch;
if (name.startsWith("javax")) {
/* 5 == length("javax") */
if (name.length() == 5) {
return false;
}
ch = name.charAt(5);
if (isClassName && ch == '.') {
/* 6 == length("javax.") */
if (name.startsWith("servlet.jsp.jstl.", 6)) {
return false;
}
if (name.startsWith("el.", 6) ||
name.startsWith("servlet.", 6) ||
name.startsWith("websocket.", 6) ||
name.startsWith("security.auth.message.", 6)) {
return true;
}
} else if (!isClassName && ch == '/') {
/* 6 == length("javax/") */
if (name.startsWith("servlet/jsp/jstl/", 6)) {
return false;
}
if (name.startsWith("el/", 6) ||
name.startsWith("servlet/", 6) ||
name.startsWith("websocket/", 6) ||
name.startsWith("security/auth/message/", 6)) {
return true;
}
}
} else if (name.startsWith("org")) {
/* 3 == length("org") */
if (name.length() == 3) {
return false;
}
ch = name.charAt(3);
if (isClassName && ch == '.') {
/* 4 == length("org.") */
if (name.startsWith("apache.", 4)) {
/* 11 == length("org.apache.") */
if (name.startsWith("tomcat.jdbc.", 11)) {
return false;
}
if (name.startsWith("el.", 11) ||
name.startsWith("catalina.", 11) ||
name.startsWith("jasper.", 11) ||
name.startsWith("juli.", 11) ||
name.startsWith("tomcat.", 11) ||
name.startsWith("naming.", 11) ||
name.startsWith("coyote.", 11)) {
return true;
}
}
} else if (!isClassName && ch == '/') {
/* 4 == length("org/") */
if (name.startsWith("apache/", 4)) {
/* 11 == length("org/apache/") */
if (name.startsWith("tomcat/jdbc/", 11)) {
return false;
}
if (name.startsWith("el/", 11) ||
name.startsWith("catalina/", 11) ||
name.startsWith("jasper/", 11) ||
name.startsWith("juli/", 11) ||
name.startsWith("tomcat/", 11) ||
name.startsWith("naming/", 11) ||
name.startsWith("coyote/", 11)) {
return true;
}
}
}
}
return false;
}org.apache.catalina.webresources.StandardRoot
public class StandardRoot extends LifecycleMBeanBase implements WebResourceRoot {
...省略其他代码...
private final List preResources = new ArrayList<>();
private WebResourceSet main;
private final List classResources = new ArrayList<>();
private final List jarResources = new ArrayList<>(); //对应WEB-INF/lib
private final List postResources = new ArrayList<>();
private final List mainResources = new ArrayList<>(); //对应应用webapp路径
private final List> allResources = new ArrayList<>();
{
allResources.add(preResources);
allResources.add(mainResources);
allResources.add(classResources);
allResources.add(jarResources);
allResources.add(postResources);
}
...省略其他代码...
} StandardRoot 在容器创建时进行初始化，其实现了接口WebResourceRoot ，用于加载Webapp类库。
以上代码可以看出，在Tomcat中Webapp类加载顺序为：
preResources->mainResources->classResources->jarResources->postResources
其中主要用到的资源路径为：
mainResources：对应应用目录下WEB-INF/classes
classResources：对应应用目录下WEB-INF/lib
所以在开发时，可以在src目录下覆盖lib包中的类，因为WEB-INF/classes会有限WEB-INF/lib进行加载。通常我们可以将依赖的第三方类库的源代码复制到src目录经，通过Tomcat运行进行debug，这对于排查第三方类库的问题很有帮助。
org.apache.jasper.JspCompilationContext
public ClassLoader getJspLoader() {
if( jspLoader == null ) {
jspLoader = new JasperLoader
(new URL[] {baseUrl},
getClassLoader(),
rctxt.getPermissionCollection());
}
return jspLoader;
}
public void clearJspLoader() {
jspLoader = null;
}在Tomcat的conf/web.xml中，指定了处理JSP的Servlet：org.apache.jasper.servlet.JspServlet，在处理JSP页面的请求时，Tomcat会检测相应的JSP文件是否发生的修改，如果修改则会清理JSP的编译文件，然后先生成java文件，在编译为class文件
jspLoader为加载JSP的转化成的Servlet的类加载器，在Tomcat检测到jsp文件发生变化时都会重新生成
jspLoader的父类加载器为webapp的classloader，父类加载器的初始在org.apache.jasper.compiler.JspRuntimeContext的构造方法中，详见如下代码
public JspRuntimeContext(ServletContext context, Options options) { ..省略其他代码 // Get the parent class loader ClassLoader loader = Thread.currentThread().getContextClassLoader(); if (loader == null) { loader = this.getClass().getClassLoader(); } parentClassLoader = loader; ...省略其他代码... }
以上是“Tomcat9中类加载体系是怎么样的”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联行业资讯频道！
当前标题：Tomcat9中类加载体系是怎么样的
当前地址：http://azwzsj.com/article/pidjjc.html
