tomcat类加载体系

类加载，再来一发。

研究完java提供的类加载机制，再来看看tomcat开出了那些花。

最近开始读tomcat的源码，主线路当然是类加载机制，在这个过程中有豁然开朗的感觉。这一篇主要是自己的体会，而不是从头到尾的详细解读。很显然，是因为我懒。有多懒呢，懒到把女朋友都弄丢了，哎。

言归正传，从tomcat的启动类Bootstrap开始叙述。

1、加载Bootstrap的类加载器是哪个呢？APPClassLoader，因为tomcat还是要依赖Java的基础，包括类加载器和双亲委派模型。

2、Bootstrap类启动的时候，会初始化类加载器。

    ClassLoader commonLoader = null;
    ClassLoader catalinaLoader = null;
    ClassLoader sharedLoader = null;

    // -------------------------------------------------------- Private Methods

    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);
        }
    }

这里有3个类加载器，catalinaLoader 和 sharedLoader 以 commonLoader 为父类加载器，那commonLoader的父类加载器呢？？？一路跟代码，发现最终是AppClassLoader，具体实现在Java.lang.ClassLoader类。

common加载的类：tomcat和web应用都可以访问；

catalina加载的类：tomcat内部实现用到的类；

shared加载的类：所有web应用可以共用。

与每个web应用单独对应的类加载器是WebappClassLoader，后面会具体分析。

3、common、catalina以及shared三个类加载器都是URLClassLoader

    if (parent == null)
         return new URLClassLoader(array);
    else
         return new URLClassLoader(array, parent);

这是tomcat7的代码，6包括之前的版本还在用StandardClassLoader

4、类加载器生成后，Thread.currentThread().setContextClassLoader(catalinaLoader); 将当前线程的上下文类加载器设置为catalinaLoader，在后面的逻辑里面会经常用到。

5、再之后的一段代码需要好好分析一下

        // 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.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;
        Method method =
            startupInstance.getClass().getMethod(methodName, paramTypes);
        method.invoke(startupInstance, paramValues);

这里通过catalinaLoader去加载了Catalina类，生成了一个实例，并且通过反射调用了这个实例的setParentClassLoader方法，将父类加载器设置为sharedLoader，后面也会经常用到。我刚看到这段代码时，有一个巨大的疑问，为什么要用反射呢？

说的这里，我想再延伸一下。使用不同的类加载器还有一个好处：类之间的相互隔离。再深入一点，初始加载器和定义加载器。比如：有A、B、C 3个类加载器，根据双亲委派，通过 A --> B --> C 这条路径去加载了一个类 X, 那么A、B、C都是X的初始加载器，只有C是X的定义加载器。有一个原则：X类型在A、B、C 的命名空间中共享，在别的类加载器的命名空间中不能访问，也就是隔离。这里要注意，A、B独自加载的类型，对C不共享，也就是说子共享父，反过来不行。

所以，现在能解释两个事情：

a）、我们平常的代码里处处是jdk的类，它们的类加载器是启动类加载器，为什么。因为我们的代码是在classpath里面，类加载器是AppClassLoader，可以共享jdk的类。

b)、我们这里必须用反射！！！路演一下，启动类Bootstrap的类加载器是AppClassLoader，然后Bootstrap类里面用catalinaLoader去加载Catalina类。catalina --> common --> AppClassLoader，所以顺序很重要，反过来不行。既然不能共享，但是必须要访问，那怎么办呢，还好有反射。

其实在Tomcat的源码里面，Bootstrap类和Catalina类是在同一个package里。那，问题又来了。class文件既然在同一个路径下，为什么一个用AppClassLoader来加载，而另一个却用CatalinaLoader呢？？？

应该是出于安全的考虑，不信就去看看Bootstrap类的注释（重点是最后一句。翻译，我就不献丑了）：

 * Bootstrap loader for Catalina.  This application constructs a class loader
 * for use in loading the Catalina internal classes (by accumulating all of the
 * JAR files found in the "server" directory under "catalina.home"), and
 * starts the regular execution of the container.  The purpose of this
 * roundabout approach is to keep the Catalina internal classes (and any
 * other classes they depend on, such as an XML parser) out of the system
 * class path and therefore not visible to application level classes.

6、最后来解刨WebappClassLoader

先看它重写的loadClass方法，实现在父类WebappClassLoaderBase里面

public Class<?> loadClass(String name, boolean resolve) throws         ClassNotFoundException {

        synchronized (getClassLoadingLockInternal(name)) {
            if (log.isDebugEnabled())
                log.debug("loadClass(" + name + ", " + resolve + ")");
            Class<?> clazz = null;

            // Log access to stopped classloader
            if (!started) {
                try {
                    throw new IllegalStateException();
                } catch (IllegalStateException e) {
                    log.info(sm.getString("webappClassLoader.stopped", name), e);
                }
            }

            // (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 = j2seClassLoader.loadClass(name);
                if (clazz != null) {
                    if (resolve)
                        resolveClass(clazz);
                    return (clazz);
                }
            } catch (ClassNotFoundException e) {
                // Ignore
            }

            // (0.5) Permission to access this class when using a 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;
                        if (name.endsWith("BeanInfo")) {
                            // BZ 57906: suppress logging for calls from
                            // java.beans.Introspector.findExplicitBeanInfo()
                            log.debug(error, se);
                        } else {
                            log.info(error, se);
                        }
                        throw new ClassNotFoundException(error, se);
                    }
                }
            }

            boolean delegateLoad = delegate || filter(name);

            // (1) Delegate to our parent if requested
            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) 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) {
                // Ignore
            }

            // (3) Delegate to parent unconditionally
            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);
    }

梳理一下流程，其实英文的注释已经很明白了。

（1）首先从Tomcat自己持有的缓存中去查找

（2）从JVM的缓存中找

（3）先用j2seClassLoader去加载，就是怕你把jdk的jar包放到了WEB-INF下面

        ClassLoader j = String.class.getClassLoader();
        if (j == null) {
            j = getSystemClassLoader();
            while (j.getParent() != null) {
                j = j.getParent();
            }
        }
        this.j2seClassLoader = j;    

从这段代码中，你应该知道j2seClassLoader到底是哪个类加载器了。只是我不明白为什么要用这么复杂的方式得到，getSystemClassLoader().getParent() 不行吗，希望明白的读者告知。

（4）如果设置了代理，就代理给父类加载器去加载，父亲是谁呢？后面再说。

（5）终于轮到自己去加载了

（6）如果还是不好使，无条件的交给父亲去搞定。

现在看看，这个WebappClassLoader是怎么生成的:

启动StandardContext的时候会创建WebappLoader，WebappLoader持有WebappClassLoderBase，WebappLoader里面初生成它的代码

　　　　private String loaderClass =

"org.apache.catalina.loader.WebappClassLoader";

　　classLoader = createClassLoader();

    private WebappClassLoaderBase createClassLoader()
        throws Exception {

        Class<?> clazz = Class.forName(loaderClass);
        WebappClassLoaderBase classLoader = null;

        if (parentClassLoader == null) {
            parentClassLoader = container.getParentClassLoader();
        }
        Class<?>[] argTypes = { ClassLoader.class };
        Object[] args = { parentClassLoader };
        Constructor<?> constr = clazz.getConstructor(argTypes);
        classLoader = (WebappClassLoaderBase) constr.newInstance(args);

        return classLoader;

    }

这里通过反射调用构造方法，生成一个WebappClassLoader，并强转成父类。

其中container.getParentClassLoader() 得到的类加载器，就是sharedLoader，去看Tomcat的源码。

至于这里为什么也要用反射，不明白，请读者指教。