关于java:Tomcat的ClassLoader打破双亲委派源码解读

java 加载类的时候须要应用类加载器，开发人员能够定制类的加载器，比方 tomcat 就扩大了本人的类加载器。这篇文章联合代码钻研一下 jdk 类的加载器和 tomcat 的类加载

先上图温习一下

来看一下 jdk 的 ClassLoader 的代码

 protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {synchronized (getClassLoadingLock(name)) {
            // 本类加载器从缓存外面拿取曾经加载过的 ClassLoader
            Class<?> c = findLoadedClass(name);
            if (c == null) {long t0 = System.nanoTime();
                try {
                    // 父类为 BootStrapClassLoader 的 classLoader 的 parent 变量为空
                    if (parent != null) {c = parent.loadClass(name, false);
                    } else {c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                ..........
    }

留神看一下外围代码，实际上 parent 只有不为空就由 parent 来加载，因而当类未加载的时候，总是由下级来优先加载。

首先来看一下 tomcat 的类加载器，tomcat 写了一个本人的类加载器，看下基类 WebappClassLoaderBase 的实现

@Override
    public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {synchronized (getClassLoadingLock(name)) {
           ................
            // 从缓存外面取，不影响加载程序，请着重疏忽
            clazz = findLoadedClass0(name);
            ..........

          
            clazz = findLoadedClass(name);
            .........

           /**
     * The bootstrap class loader used to load the JavaSE classes. In some
     * implementations this class loader is always <code>null</code> and in
     * those cases {@link ClassLoader#getParent()} will be called recursively on
     * the system class loader and the last non-null result used.
     */
            // 留神看正文，javaseLoader 是 bootstrap 加载的，所以 javaseLoader 是扩大类加载器
            ClassLoader javaseLoader = getJavaseClassLoader();
           
            
            clazz = javaseLoader.loadClass(name);
            

            boolean delegateLoad = delegate || filter(name, true);
            
            // (2) Search local repositories
            if (log.isDebugEnabled()) {log.debug("Searching local repositories");
            }
            try {
            // 重写了 findClass 办法，从我的项目中的 lib 和 class 里加载
                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) Delegate to parent unconditionally
            if (!delegateLoad) {if (log.isDebugEnabled()) {log.debug("Delegating to parent classloader at end:" + parent);
                }
                try {
//  继承于 SystemClassLoader 该类，所以这个 parent 是 SystemClassLoader，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);
    }

把程序相干外的代码省略了，留神看正文。
因而来梳理一下加载程序
1. 找 ext 加载器，ext 会优先走 BootStrap 加载器，加载 java 外围类库
2.ext 加载不到就去走重写的 findClass，走 web 我的项目的 lib 包和 class 目录，加载我的项目的 class
3. 重写的 findClass 找不到，就去零碎类加载器 SystemClassLoader 来加载。

1. 最重要的就是做隔离性，不同的 web 包引入不同的 jar 包版本，如果重写类的加载程序，对立走 SystemClassloader 加载，那么只会加载一个类在内存，另外一个版本的 class 永远也不会加载进内存。无奈实现 web 我的项目的隔离
2. 能够针对一个利用进行重新部署，一个利用一个加载器，须要重新部署，就把这个 classLoader 加载的类从新加载就能够了

所以看起来突破双亲委派这种大名头的常识，看一下源码就清晰了，养成浏览源码习惯就能够

jdk 类的加载

tomcat 的类加载

tomcat 为什么要重写这个 ClassLoader 呢