正文

Tomcat 类加载器的实现方法及实例代码

︶ㄣ速达网 メ
米米素材网V管理员 / 阅读
0806

这篇文章主要介绍了Tomcat 类加载器的实现方法及实例代码，本文给大家介绍的非常详细，具有一定的参考借鉴价值 ,需要的朋友可以参考下

tomcat 内部定义了多个 classloader，以便应用和容器访问不同存储库中的类和资源，同时达到应用间类隔离的目的。

1. java 类加载机制

类加载就是把编译生成的 class 文件，加载到 jvm 内存中（永久代/元空间）。

类加载器之所以能实现类隔离，是因为两个类相等的前提是它们由同一个类加载器加载，否则必定不相等。

jvm 在加载时，采用的是一种双亲委托机制，当类加载器要加载一个类时，加载顺序是：

首先将请求委托给父加载器，如果父加载器找不到要加载的类然后再查找自己的存储库尝试加载

这个机制的好处就是能够保证核心类库不被覆盖。

而按照 servlet 规范的建议，webapp 加载器略有不同，它首先会在自己的资源库中搜索，而不是向上委托，打破了标准的委托机制，来看下 tomcat 的设计和实现。

2. tomcat 类加载器设计

tomcat 整体类加载器结构如下：

Tomcat 类加载器的实现方法及实例代码

其中 jdk 内部提供的类加载器分别是：

bootstrap - 启动类加载器，属于 jvm 的一部分，加载 <java_home>/lib/ 目录下特定的文件extension - 扩展类加载器，加载 <java_home>/lib/ext/ 目录下的类库application - 应用程序类加载器，也叫系统类加载器，加载 classpath 指定的类库

tomcat 自定义实现的类加载器分别是：

common - 父加载器是 appclassloader，默认加载 ${catalina.home}/lib/ 目录下的类库catalina - 父加载器是 common 类加载器，加载 catalina.properties 配置文件中 server.loader 配置的资源，一般是 tomcat 内部使用的资源shared - 父加载器是 common 类加载器，加载 catalina.properties 配置文件中 shared.loader 配置的资源，一般是所有 web 应用共享的资源webappx - 父加载器是 shared 加载器，加载 /web-inf/classes 的 class 和 /web-inf/lib/ 中的 jar 包jasperloader - 父加载器是 webapp 加载器，加载 work 目录应用编译 jsp 生成的 class 文件

在实现时，上图不是继承关系，而是通过组合体现父子关系。tomcat 类加载器的源码类图：

Tomcat 类加载器的实现方法及实例代码

common、catalina 、shared 它们都是 standardclassloader 的实例，在默认情况下，它们引用的是同一个对象。其中 standardclassloader 与 urlclassloader 没有区别；webappclassloader 则按规范实现以下顺序的查找并加载：

从 jvm 内部的 bootstrap 仓库加载从应用程序加载器路径，即 classpath 下加载从 web 程序内的 /web-inf/classes 目录从 web 程序内的 /web-inf/lib 中的 jar 文件从容器 common 加载器仓库，即所有 web 程序共享的资源加载

接下来看下源码实现。

3. 自定义加载器的初始化

common 类加载器是在 bootstrap 的 initclassloaders 初始化的，源码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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();
 }
 // 指定仓库路径配置文件前缀和父加载器，创建 classloader 实例
 catalinaloader = createclassloader("server", commonloader);
 sharedloader = createclassloader("shared", commonloader);
 } catch (throwable t) {
 log.error("class loader creation threw exception", t);
 system.exit(1);
 }
}

可以看到分别创建了三个类加载器，createclassloader 就是根据配置获取资源仓库地址，最后返回一个 standardclassloader 实例，核心代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private classloader createclassloader(string name, classloader parent)
 throws exception {
 
 string value = catalinaproperties.getproperty(name + ".loader");
 if ((value == null) || (value.equals("")))
  return parent; // 如果没有配置，则返回传入的父加载器
 arraylist repositorylocations = new arraylist();
 arraylist repositorytypes = new arraylist();
 ...
 // 获取资源仓库路径
 string[] locations = (string[]) repositorylocations.toarray(new string[0]);
 integer[] types = (integer[]) repositorytypes.toarray(new integer[0]);
 // 创建一个 standardclassloader 对象
 classloader classloader = classloaderfactory.createclassloader
   (locations, types, parent);
 ...
 return classloader;
}

类加载器初始化完毕后，会创建一个 catalina 对象，最终会调用它的 load 方法，解析 server.xml 初始化容器内部组件。那么容器，比如 engine，又是怎么关联到这个设置的父加载器的呢？

catalina 对象有一个 parentclassloader 成员变量，它是所有组件的父加载器，默认是 appclassloader，在此对象创建完毕时，会反射调用它的 setparentclassloader 方法，将父加载器设为 sharedloader。

而 tomcat 内部顶级容器 engine 在初始化时，digester 有一个 setparentclassloaderrule 规则，会将 catalina 的 parentclassloader 通过 engine.setparentclassloader 方法关联起来。

4. 如何打破双亲委托机制

答案是使用 thread.getcontextclassloader() - 当前线程的上下文加载器，该加载器可通过 thread.setcontextclassloader() 在代码运行时动态设置。

默认情况下，thread 上下文加载器继承自父线程，也就是说所有线程默认上下文加载器都与第一个启动的线程相同，也就是 main 线程，它的上下文加载器是 appclassloader。

tomcat 就是在 standardcontext 启动时首先初始化一个 webappclassloader 然后设置为当前线程的上下文加载器，最后将其封装为 loader 对象，借助容器之间的父子关系，在加载 servlet 类时使用。

5. web 应用的类加载

web 应用的类加载是由 webappclassloader 的方法 loadclass(string, boolean) 完成，核心代码如下：

在防止覆盖 j2se

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
public synchronized class loadclass(string name, boolean resolve)
 throws classnotfoundexception {
 ...
 class clazz = null;
 // (0) 检查自身内部缓存中是否已经加载
 clazz = findloadedclass0(name);
 if (clazz != null) {
 if (log.isdebugenabled())
  log.debug(" returning class from cache");
 if (resolve) resolveclass(clazz);
 return (clazz);
 }
 // (0.1) 检查 jvm 的缓存中是否已经加载
 clazz = findloadedclass(name);
 if (clazz != null) {
 if (log.isdebugenabled())
  log.debug(" returning class from cache");
 if (resolve) resolveclass(clazz);
 return (clazz);
 }
 // (0.2) 尝试使用系统类加载加载，防止覆盖 j2se 类
 try {
 clazz = system.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 = "security violation, attempt to use " +
   "restricted class: " + name;
  log.info(error, se);
  throw new classnotfoundexception(error, se);
  }
 }
 }
 boolean delegateload = delegate || filter(name);
 // (1) 是否委托给父类，这里默认为 false
 if (delegateload) {
  ...
 }
 // (2) 尝试查找自己的存储库并加载
 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) {}
 // (3) 如果此时还加载失败，那么将加载请求委托给父加载器
 if (!delegateload) {
 if (log.isdebugenabled())
  log.debug(" delegating to parent classloader at end: " + parent);
 classloader loader = parent;
 if (loader == null)
  loader = system;
 try {
  clazz = loader.loadclass(name);
  if (clazz != null) {
  if (log.isdebugenabled())
   log.debug(" loading class from parent");
  if (resolve) resolveclass(clazz);
  return (clazz);
  }
 } catch (classnotfoundexception e) {}
 }
 // 最后加载失败，抛出异常
 throw new classnotfoundexception(name);
}
 
在防止覆盖 j2se 类的时候，版本 tomcat 6，使用的是 appclassloader，rt.jar 核心类库是由 bootstrap classloader 加载的，但是在 java 代码是获取不了这个加载器的，在高版本做了以下优化：
classloader j = string.class.getclassloader();
if (j == null) {
 j = getsystemclassloader();
 while (j.getparent() != null) {
 j = j.getparent();
 }
}
this.javaseclassloader = j;

类的时候，版本 tomcat 6，使用的是 appclassloader，rt.jar 核心类库是由 bootstrap classloader 加载的，但是在 java 代码是获取不了这个加载器的，在高版本做了以下优化：

?
1
2
3
4
5
6
7
8
classloader j = string.class.getclassloader();
if (j == null) {
 j = getsystemclassloader();
 while (j.getparent() != null) {
 j = j.getparent();
 }
}
this.javaseclassloader = j;

也就是使用尽可能接近 bootstrap 加载器的类加载器。

6. 小结

相信大部分人都遇到过 classnotfoundexception 这个异常，这背后就涉及到了类加载器，对加载的原理有一定的了解，有助于排查问题。

以上所述是小编给大家介绍的tomcat 类加载器的实现方法及实例代码,希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对’米米素材网’网站的支持！

如果你觉得本文对你有帮助，欢迎转载，烦请注明出处，谢谢！

原文链接：https://www.cnblogs.com/wskwbog/p/10827102.html