1JVM类加载机制
 
JVM的ClassLoader通过Parent属性定义父子关系，可以形成树状结构。其中引导类、扩展类、系统类三个加载器是JVM内置的。
它们的作用分别是：
1）引导类加载器：使用native代码实现，在rt.jar等包中搜索运行JVM所需的类，例如java.lang等包下的类。
2）扩展类加载器：负责载入标准扩展目录中的类，例如Sun的JVM的扩展目录是/jdk/jre/lib/ext。
3）系统类加载器：默认的类加载器，搜索环境变量CLASSPATH中指明的路径。
 
 
2双亲委派模型
 
既然类加载器是树形结构，那加载类时就需要定义类到底由当前加载器还是父加载器去搜索加载。
JVM加载模型的工作过程是：
     如果一个类加载器收到了类加载的请求，它不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成。
     每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的引导类加载器中。
     只有父类加载无法完成这个请求时，子类加载器才会尝试自己去加载。
 
 
为什么要让父类加载器优先去加载呢？试想如果子类加载器先加载，那么我们可以写一些与java.lang包中基础类同名的类，
然后再定义一个子类加载器，这样整个应用使用的基础类就都变成我们自己定义的类了。这样就有很大的安全隐患！
所以自己编写类加载器时，如果没有特殊原因，一定要遵守类加载的双亲委派模型。
 
3Tomcat类加载器
 
Tomcat基本遵守了JVM的委派模型，但也在自定义的类加载器中做了细微的调整，以适应Tomcat自身的要求。
下面是Tomcat类加载器WebappClassLoader的核心方法loadClass()的源码。
它覆盖了父类URLClassLoader中的方法，改变了默认的类加载顺序。
 
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
88
89
90
91
92
93
94
95
96
97
98
99
100
    public synchronized Class loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
 
        Class clazz = null;
 
        // (0) Check our previously loaded local class cache
        clazz = findLoadedClass0(name);
        if (clazz != null) {
            if (log.isDebugEnabled())
                log.debug("  Returning class from cache");
            if (resolve)
                resolveClass(clazz);
            return (clazz);
        }
 
        // (0.1) Check our previously loaded class cache
        clazz = findLoadedClass(name);
        if (clazz != null) {
            if (log.isDebugEnabled())
                log.debug("  Returning class from cache");
            if (resolve)
                resolveClass(clazz);
            return (clazz);
        }
 
        // (0.2) Try loading the class with the system class loader, to prevent
        //       the webapp from overriding J2SE classes
        try {
            clazz = system.loadClass(name);
            if (clazz != null) {
                if (resolve)
                    resolveClass(clazz);
                return (clazz);
            }
        } catch (ClassNotFoundException e) {
            // Ignore
        }
 
        boolean delegateLoad = delegate || filter(name);
 
        // (1) Delegate to our parent if requested
        if (delegateLoad) {
            if (log.isDebugEnabled())
                log.debug("  Delegating to parent classloader1 " + 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) {
                ;
            }
        }
 
        // (2) Search local repositories
        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) {
            ;
        }
 
        // (3) Delegate to parent unconditionally
        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);
    }
 
具体分析一下：首先findLoadedClass0()和findLoadedClass()分别从本地和父类加载器的缓存中查找当前要加载的类是否已经加载过了。
之后为了避免上面提到的安全问题，Tomcat类加载器会将加载请求委派给系统类加载器。接下来根据delegate变量的设置，决定是先由自己加载，
还是先由父类加载器去加载。
 
这里介绍一下背景，上面的WebappClassLoader是对应一个Web应用的类加载器，其父亲是Tomcat的lib的加载器。所以delegate变量的值，
决定了Tomcat的类加载顺序。
 
4Tomcat6的加载顺序
 
所以在Tomcat 6中默认情况下，不是完全按照先Tomcat的lib再Web应用的lib这种顺序去加载类。
Jar包的加载顺序是：
1）JRE中的Java基础包
2）Web应用WEB-INF\lib下的包
3）Tomcat\lib下的包
 
如果想要在Web应用间共享一些Jar包，则不仅需要将公共包放在Tomcat的lib下，还要删掉Web应用lib中的包，
否则Tomcat启动时还是会优先加载Web应用lib下的包的。
 
ps：题外话，如果想要自己指定一个Tomcat\lib和Web应用lib之外的ClassPath，除了修改Tomcat启动脚本外，
可以为不同Web应用的Context指定一个VirtualWebappLoader，但源码注释中写到不推荐在生产环境中使用。
 
参考文章
 
《深入理解Java虚拟机》
 
 
 
------------------------------------------------------------------------------------------------------------------------------------------
 
 

如下是Tomcat6的类加载器结果图

写道
      [BootStrapClassLoader](实际没有这个类)
                      |
     ExtensionClassLoader(对于Sun JVM，是sun.misc.Launcher$ExtClassLoader)
                      |
     SystemClassLoader(对于Sun JVM，是sun.misc.Launcher$AppClassLoader)
                      |
     CommonClassLoader(对于Tomcat 6，是org.apache.catalina.loader.StandardClassLoader)
               /               \
CatalinaClassLoader           SharedClassLoader
                                             |
                          org.apache.catalina.loader.WebappClassLoader 
                                             |
                              org.apache.jasper.servlet.JasperLoader
  • CommonClassLoader：
    加载的类目录通过{tomcat}/conf/catalina.properties中的common.loader指定，以
    SystemClassLoader为parent(目前默认定义是
    common.loader=${catalina.base}/lib,${catalina.base}/lib/*.jar,${catalina.home}/lib,${catalina.home}/lib/*.jar)
  • CatalinaClassLoader  

    ：加载的类目录通过{tomcat}/conf/catalina.properties中server.loader指定，以
    CommonClassLoader为parent，如果server.loader配置为空，则ServerClassLoader
    与CommonClassLoader是同一个(默认server.loader配置为空)

  • SharedClassLoader：加载
    的类目录通过{tomcat}/conf/catalina.properties中share.loader指定，以
    CommonClassLoader为parent，如果server.loader配置为空，则CatalinaClassLoader
    与CommonClassLoader是同一个(默认share.loader配置为空)
  • WebappClassLoader：每个
    Context一个WebappClassLoader实例，负责加载context的/WEB-INF/lib和/WEB-INF/classes目
    录，context间的隔离就是通过不同的WebappClassLoader来做到的。由于类定义一旦加载就不可改变，因此要实现tomcat的
    context的reload功能，实际上是通过新建一个新的WebappClassLoader来做的，因此reload的做法实际上代价是很高昂的，
    需要注意的是，JVM内存的Perm区是只吃不拉的，因此抛弃掉的WebappClassLoader加载的类并不会被JVM释放，因此tomcat的
    reload功能如果应用定义的类比较多的话，reload几次就OutOfPermSpace异常了。（关于JVM的内存管理，可以参见之前的文章 ，后续对这一块重新做总结）
  • JasperLoader：
    每个JSP一个JasperLoader实例，与WebappClassLoader做法类似，JSP支持修改生效是通过丢弃旧的
    JasperLoader，建一个新的JasperLoader来做到的，同样的，存在轻微的PermSpace的内存泄露的情况

Tomcat类加载器的更多相关文章

  1. java类加载器-Tomcat类加载器

    在上文中,已经介绍了系统类加载器以及类加载器的相关机制,还自定制类加载器的方式.接下来就以tomcat6为例看看tomat是如何使用自定制类加载器的.(本介绍是基于tomcat6.0.41,不同版本可 ...

  2. Tomcat类加载器机制

    Tomcat为什么需要定制自己的ClassLoader: 1.定制特定的规则:隔离webapp,安全考虑,reload热插拔 2.缓存类 3.事先加载 要说Tomcat的Classloader机制,我 ...

  3. Tomcat类加载器破坏双亲委派

    转载:https://blog.csdn.net/qq_38182963/article/details/78660779 http://www.cnblogs.com/aspirant/p/8991 ...

  4. Tomcat类加载器体系结构

    <深入理解java虚拟机>——Tomcat类加载器体系结构 标签: java / 虚拟机 / tomcat Tomcat 等主流Web服务器为了实现下面的基本功能,都实现了不止一个自定义的 ...

  5. Tomcat 类加载器的实现

    Tomcat 内部定义了多个 ClassLoader,以便应用和容器访问不同存储库中的类和资源,同时达到应用间类隔离的目的.本文首发于公众号:顿悟源码. 1. Java 类加载机制 类加载就是把编译生 ...

  6. 深入理解JVM虚拟机7：JNDI，OSGI，Tomcat类加载器实现

    打破双亲委派模型 JNDI JNDI 的理解   JNDI是 Java 命名与文件夹接口(Java Naming and Directory Interface),在J2EE规范中是重要的规范之中的一 ...

  7. （转）《深入理解java虚拟机》学习笔记8——Tomcat类加载器体系结构

    Tomcat 等主流Web服务器为了实现下面的基本功能,都实现了不止一个自定义的类加载器: (1).部署在同一个服务器上的两个web应用程序所使用的java类库可以相互隔离. (2).部署在同一个服务 ...

  8. tomcat: 类加载器

    一.tomcat是个web容器,要解决以下问题 1. 一个web容器可能要部署两个或者多个应用程序,不同的应用程序,可能会依赖同一个第三方类库的不同版本,因此要保证每一个应用程序的类库都是独立.相互隔 ...

  9. Java类加载机制与Tomcat类加载器架构

    Java类加载机制 类加载器 虚拟机设计团队把类加载阶段中的“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作放到Java虚拟机外部去实现,以便让应用程序自己决定如何去获取所需要的类.实现这 ...

随机推荐

  1. VS中批量删除cs代码中的#region和#endregion

    Visual Studio中如何批量删除cs代码中的#region和#endregion,不删除它们中间的代码,只删除这两个标记及标记的注解的方法.Vs中提供了很强大的文本查找与替换功能,简单的替换只 ...

  2. Java基础知识强化27：Object类之toString()方法

    1. Object类的toString()方法: public  String  toString():返回该对象的字符串表示 2. 案例演示: (1)Student类: package cn.itc ...

  3. windows下配置两个或多个Tomcat启动的方法

    确保window的环境变量中找不到CATALINA_HOME和CATALINA_BASE 修改server.xml,用解压版的tomcat,不要用安装版的. 1.修改http访问端口 conf下的se ...

  4. Myeclipse笔记

    1.  自动提示:窗口->首选项->Java->编辑器->内容辅助->自动激活,在下面的“Java的自动激活触发器里面填上“.abcdefghijklmnopqrstuv ...

  5. 打开的IE网页不是最大化的解决方法

    方法一:先把所有的IE窗口关了;只打开一个IE窗口;最大化这个窗口;关了它;OK,以后的默认都是最大化的了 方法二:先关闭所有的IE浏览器窗口,用鼠标右键点击快速启动栏的IE浏览器图标,在出现的快捷菜 ...

  6. 常用hash函数

    常用的哈希函数   通用的哈希函数库有下面这些混合了加法和一位操作的字符串哈希算法.下面的这些算法在用法和功能方面各有不同,但是都可以作为学习哈希算法的实现的例子.   1.RS  从Robert S ...

  7. UML中聚合和组合的区别

    聚合 聚合其实是关联的一个特例,表示了两个对象之间“part of(部分-整体)”的关系,是一种弱关联,部分的生命周期可以超越整体.在UML中,用整体端有空心菱形箭头的双向关联修饰聚合.聚合的示例如下 ...

  8. jQuery1.9(辅助函数)学习之——.serializeArray();

    .serializeArray();返回一个Array 描述: 将用作提交的表单元素的值编译成拥有name和value对象组成的数组.例如[ { name: a value: 1 }, { name: ...

  9. angular 引入 component 报错

    每天抽出一些时间学习 Angular2 ,并准备把手头上的项目移植为 Angular2 , 不过今天又遇到了一些小问题. 准备写一个导航类适于管理后台常见的右边导航,如博客园的这种: ! 使用 g g ...

  10. 1.1HTML的基本概念

    1.WWW有3个基本的组成部分,分别是URL(统一资源定位器),HTTP(超文本传输协议),HTML(本文本标记语言). 2.一个HTML文件是由一系列的元素和标签组成的,元素不区分大小写. 3.&l ...