07.Tomcat源码分析——类加载体系-阿里云开发者社区

我们启动Tomcat的命令如下：

sh startup.sh

startup.sh的脚本代码如下：

# Better OS/400 detection: see Bugzilla 31132
os400=false
case "`uname`" in
OS400*) os400=true;;
esac

# resolve links - $0 may be a softlink
PRG="$0"

while [ -h "$PRG" ] ; do
  ls=`ls -ld "$PRG"`
  link=`expr "$ls" : '.*-> \(.*\)$'`
  if expr "$link" : '/.*' > /dev/null; then
    PRG="$link"
  else
    PRG=`dirname "{
   
   mathJaxContainer[1]}link"
  fi
done

PRGDIR=`dirname "$PRG"`
EXECUTABLE=catalina.sh

# Check that target executable exists
if $os400; then
  # -x will Only work on the os400 if the files are:
  # 1. owned by the user
  # 2. owned by the PRIMARY group of the user
  # this will not work if the user belongs in secondary groups
  eval
else
  if [ ! -x "{
   
   mathJaxContainer[2]}EXECUTABLE" ]; then
    echo "Cannot find {
   
   mathJaxContainer[3]}EXECUTABLE"
    echo "The file is absent or does not have execute permission"
    echo "This file is needed to run this program"
    exit 1
  fi
fi

exec "{
   
   mathJaxContainer[4]}EXECUTABLE" start "$@"

重点看最后一行代码：exec "$PRGDIR"/"$EXECUTABLE" start "$@"

这里有两个变量：

PRGDIR：当前shell脚本所在的路径；
EXECUTABLE：脚本catalina.sh。

通过以上变量的解释，我们知道了其实执行startup.sh就是在执行catalina.sh，并且传递了参数start。

catalina.sh中接收到start参数后的执行的脚本分支见代码如下：

elif [ "$1" = "start" ] ; then

# 此处省略参数校验的脚本

  shift
  touch "$CATALINA_OUT"
  if [ "$1" = "-security" ] ; then
    if [ $have_tty -eq 1 ]; then
      echo "Using Security Manager"
    fi
    shift
    eval "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" {
   
   mathJaxContainer[7]}JAVA_OPTS $CATALINA_OPTS \
      -Djava.endorsed.dirs="\"$JAVA_ENDORSED_DIRS\"" -classpath "\"$CLASSPATH\"" \
      -Djava.security.manager \
      -Djava.security.policy=="\"$CATALINA_BASE/conf/catalina.policy\"" \
      -Dcatalina.base="\"$CATALINA_BASE\"" \
      -Dcatalina.home="\"$CATALINA_HOME\"" \
      -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
      org.apache.catalina.startup.Bootstrap "$@" start \
      >> "$CATALINA_OUT" 2>&1 "&"

  else
    eval "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" {
   
   mathJaxContainer[10]}JAVA_OPTS $CATALINA_OPTS \
      -Djava.endorsed.dirs="\"$JAVA_ENDORSED_DIRS\"" -classpath "\"$CLASSPATH\"" \
      -Dcatalina.base="\"$CATALINA_BASE\"" \
      -Dcatalina.home="\"$CATALINA_HOME\"" \
      -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
      org.apache.catalina.startup.Bootstrap "$@" start \
      >> "$CATALINA_OUT" 2>&1 "&"

  fi

  if [ ! -z "$CATALINA_PID" ]; then
    echo {
   
   mathJaxContainer[12]}CATALINA_PID"
  fi

  echo "Tomcat started."

从以上代码片段可以看出，最终使用java命令执行了org.apache.catalina.startup.Bootstrap类中的main方法，参数也是start。Bootstrap的main方法的实现见代码如下：

public static void main(String[] args) {
   
   
        synchronized(daemonLock) {
   
   
            if (daemon == null) {
   
   
                Bootstrap bootstrap = new Bootstrap();

                try {
   
   
                    bootstrap.init();
                } catch (Throwable var5) {
   
   
                    handleThrowable(var5);
                    var5.printStackTrace();
                    return;
                }

                daemon = bootstrap;
            } else {
   
   
                Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
            }
        }

        try {
   
   
            String command = "start";
            if (args.length > 0) {
   
   
                command = args[args.length - 1];
            }

            if (command.equals("startd")) {
   
   
                args[args.length - 1] = "start";
                daemon.load(args);
                daemon.start();
            } else if (command.equals("stopd")) {
   
   
                args[args.length - 1] = "stop";
                daemon.stop();
            } else if (command.equals("start")) {
   
   
                daemon.setAwait(true);
                daemon.load(args);
                daemon.start();
                if (null == daemon.getServer()) {
   
   
                    System.exit(1);
                }
            } else if (command.equals("stop")) {
   
   
                daemon.stopServer(args);
            } else if (command.equals("configtest")) {
   
   
                daemon.load(args);
                if (null == daemon.getServer()) {
   
   
                    System.exit(1);
                }

                System.exit(0);
            } else {
   
   
                log.warn("Bootstrap: command \"" + command + "\" does not exist.");
            }
        } catch (Throwable var7) {
   
   
            Throwable t = var7;
            if (var7 instanceof InvocationTargetException && var7.getCause() != null) {
   
   
                t = var7.getCause();
            }

            handleThrowable(t);
            t.printStackTrace();
            System.exit(1);
        }

    }

可以很清晰的看到，一上来就调用了 bootstrap.init();方法进行初始化的操作，代码如下：

    public void init() throws Exception {
   
   
        this.initClassLoaders();
        Thread.currentThread().setContextClassLoader(this.catalinaLoader);
        SecurityClassLoad.securityClassLoad(this.catalinaLoader);
        if (log.isDebugEnabled()) {
   
   
            log.debug("Loading startup class");
        }

        Class<?> startupClass = this.catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
        Object startupInstance = startupClass.getConstructor().newInstance();
        if (log.isDebugEnabled()) {
   
   
            log.debug("Setting startup class properties");
        }

        String methodName = "setParentClassLoader";
        Class<?>[] paramTypes = new Class[]{
   
   Class.forName("java.lang.ClassLoader")};
        Object[] paramValues = new Object[]{
   
   this.sharedLoader};
        Method method = startupInstance.getClass().getMethod(methodName, paramTypes);
        method.invoke(startupInstance, paramValues);
        this.catalinaDaemon = startupInstance;
    }

而init方法一上来调用了这三行关键代码：

this.initClassLoaders();

Thread.currentThread().setContextClassLoader(this.catalinaLoader);

catalinaLoader会被设置为Tomcat主线程的线程上下文类加载器，并且使用catalinaLoader加载Tomcat容器自身容器下的class

SecurityClassLoad.securityClassLoad(this.catalinaLoader);

securityClassLoad方法主要加载Tomcat容器所需的class，包括：

Tomcat核心class，即org.apache.catalina.core路径下的class；
org.apache.catalina.loader.WebappClassLoader$PrivilegedFindResourceByName；
Tomcat有关session的class，即org.apache.catalina.session路径下的class；
Tomcat工具类的class，即org.apache.catalina.util路径下的class；
javax.servlet.http.Cookie；
Tomcat处理请求的class，即org.apache.catalina.connector路径下的class；
Tomcat其它工具类的class，也是org.apache.catalina.util路径下的class；

ok，Common/Catalina/Shared ClassLoader 已经创建好了，那么肯定是要被使用的，是在哪里使用的呢？它们之间同Webapp ClassLoader又是怎么联系起来的？我们继续看init方法：

    public void init() throws Exception {
   
   
        this.initClassLoaders();
        Thread.currentThread().setContextClassLoader(this.catalinaLoader);
        SecurityClassLoad.securityClassLoad(this.catalinaLoader);
        if (log.isDebugEnabled()) {
   
   
            log.debug("Loading startup class");
        }
        //1.先加载Catalina类
        Class<?> startupClass = this.catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
        //2.通过反射实例化对象
        Object startupInstance = startupClass.getConstructor().newInstance();
        if (log.isDebugEnabled()) {
   
   
            log.debug("Setting startup class properties");
        }
        //3.catalina的setParentClassLoader方法
        String methodName = "setParentClassLoader";
        Class<?>[] paramTypes = new Class[]{
   
   Class.forName("java.lang.ClassLoader")};
        Object[] paramValues = new Object[]{
   
   this.sharedLoader};\
        //4.将catalina设置为sharedLoader的上级加载器
        Method method = startupInstance.getClass().getMethod(methodName, paramTypes);
        method.invoke(startupInstance, paramValues);
        this.catalinaDaemon = startupInstance;
    }

在我们上面的securityClassLoad()方法中会执行 loadCorePackage方法，该方法源码如下：

    private static final void loadCorePackage(ClassLoader loader) throws Exception {
   
   
        String basePackage = "org.apache.catalina.core.";
        loader.loadClass("org.apache.catalina.core.AccessLogAdapter");
        loader.loadClass("org.apache.catalina.core.ApplicationContextFacade$PrivilegedExecuteMethod");
        loader.loadClass("org.apache.catalina.core.ApplicationDispatcher$PrivilegedForward");
        loader.loadClass("org.apache.catalina.core.ApplicationDispatcher$PrivilegedInclude");
        loader.loadClass("org.apache.catalina.core.ApplicationPushBuilder");
        loader.loadClass("org.apache.catalina.core.AsyncContextImpl");
        loader.loadClass("org.apache.catalina.core.AsyncContextImpl$AsyncRunnable");
        loader.loadClass("org.apache.catalina.core.AsyncContextImpl$DebugException");
        loader.loadClass("org.apache.catalina.core.AsyncListenerWrapper");
        loader.loadClass("org.apache.catalina.core.ContainerBase$PrivilegedAddChild");
        loader.loadClass("org.apache.catalina.core.DefaultInstanceManager$AnnotationCacheEntry");
        loader.loadClass("org.apache.catalina.core.DefaultInstanceManager$AnnotationCacheEntryType");
        loader.loadClass("org.apache.catalina.core.DefaultInstanceManager$PrivilegedGetField");
        loader.loadClass("org.apache.catalina.core.DefaultInstanceManager$PrivilegedGetMethod");
        loader.loadClass("org.apache.catalina.core.DefaultInstanceManager$PrivilegedLoadClass");
        loader.loadClass("org.apache.catalina.core.ApplicationHttpRequest$AttributeNamesEnumerator");
    }

其中 loader.loadClass("org.apache.catalina.core.ContainerBase$PrivilegedAddChild"); 会加载到 ContainerBase以及其子类，通过查看发现其子类有如下：

而StandardContext类就是一个核心的子类，因为在其 startInternal()方法中：

    /**
     * Start this component and implement the requirements
     * of {@link 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);
        }
       // 省略中间的代码 
       // Start our subordinate components, if any
       if ((loader != null) && (loader instanceof Lifecycle))
            ((Lifecycle) loader).start(); 
       // 省略后边的代码 
    }

我们发现了关键的 WebappLoader 的创建，并且将WebappLoader设置为了当前的类加载器。

同时创建WebappLoader 的时候，传递了一个参数 getParentClassLoader() ，我们可以看下 WebappLoader的构造函数：

    public WebappLoader(ClassLoader parent) {
   
   
        this.classLoader = null;
        this.context = null;
        this.delegate = false;
        this.loaderClass = ParallelWebappClassLoader.class.getName();
        this.parentClassLoader = null;
        this.reloadable = false;
        this.support = new PropertyChangeSupport(this);
        this.classpath = null;
        this.parentClassLoader = parent;
    }

ok，最后一行代码给webappLoader设置了对应的父级类加载器，getParentClassLoader() 这个方法会获取父容器parentClassLoader的属性，也就是找到ContainerBase中的setParentClassLoader方法被谁调用了就知道附的啥值了：

可以看到这个设置方法被CopyParentClassLoaderRule的begin方法中赋值了：

    public void begin(String namespace, String name, Attributes attributes)
        throws Exception {
   
   

        if (digester.getLogger().isDebugEnabled())
            digester.getLogger().debug("Copying parent class loader");
        Container child = (Container) digester.peek(0);
        Object parent = digester.peek(1);
        Method method =
            parent.getClass().getMethod("getParentClassLoader", new Class[0]);
        ClassLoader classLoader =
            (ClassLoader) method.invoke(parent, new Object[0]);
        child.setParentClassLoader(classLoader);

    }

这里的classLoader其实就是通过反射取出来的 SharedLoader，这里刚好就与我们的BootStrap中init刚开始的赋值匹配上了：

因此，我们也能彻底知道，WebAppLoader的父级类加载器就是我们的ShareClassLoader了。

代码阅读到这里，已经基本清楚了Tomcat中ClassLoader的总体结构，总结如下：

Tomcat存在common、catalina、shared三个公共的classloader，默认情况下，这三个classloader其实是同一个，都是common classloader，而针对每个webapp，也就是context（对应代码中的StandardContext类），都有自己的WebappClassLoader实例来加载每个应用自己的类，该类加载实例的parent即是Shared ClassLoader。

OK，在理解了整个类加载器结构后，我们再来看 WebAppLoader 是如何加载我们的类的，重点查看 loadClass 方法,由于代码过长，直接截取核心代码：

①从本地缓存中查找：

    protected Class<?> findLoadedClass0(String name) {
   
   
        String path = this.binaryNameToPath(name, true);
        ResourceEntry entry = (ResourceEntry)this.resourceEntries.get(path);
        return entry != null ? entry.loadedClass : null;
    }

②缓存中没有，则从JVM的引导类Bootstrap类加载器加载：

该类加载器包含 Java 虚拟机提供的基本运行时类，以及系统扩展目录 ( $JAVA_HOME/jre/lib/ext) 中存在的 JAR 文件中的任何类。

③再从系统类加载器进行查找：

System这个类加载器通常从CLASSPATH环境变量的内容中初始化。所有这些类对 Tomcat 内部类和 Web 应用程序都是可见的。但是，标准的 Tomcat 启动脚本（$CATALINA_HOME/bin/catalina.sh或 %CATALINA_HOME%\bin\catalina.bat）完全忽略了CLASSPATH环境变量本身的内容，而是从以下存储库构建 System 类加载器：

$CATALINA_HOME/bin/bootstrap.jar — 包含用于初始化 Tomcat 服务器的 main() 方法，以及它所依赖的类加载器实现类。
$CATALINA_BASE/bin/tomcat-juli.jar*或 *$CATALINA_HOME/bin/tomcat-juli.jar — 日志实现类。其中包括java.util.loggingAPI 的增强类，称为 Tomcat JULI，以及 Tomcat 内部使用的 Apache Commons Logging 库的包重命名副本。有关更多详细信息，请参阅日志记录文档。

如果tomcat-juli.jar存在于 $CATALINA_BASE/bin 中*，则使用它代替*$CATALINA_HOME/bin 中的那个。它在某些日志记录配置中很有用
$CATALINA_HOME/bin/commons-daemon.jar — 来自Apache Commons Daemon项目的类。这个 JAR 文件不存在于CLASSPATH构建者 catalina.bat| .sh脚本，但从bootstrap.jar的清单文件中引用。

④由当前类加载器进行加载：

⑤最后由父类加载器加载

总结：

Web应用类加载器默认的加载顺序是：

(1).先从缓存中加载；
(2).如果没有，则从JVM的Bootstrap类加载器查找；
(3).如果没有，则从当前类加载器加载查找（按照WEB-INF/classes、WEB-INF/lib的顺序）；
(4).如果没有，则从父类加载器加载，父类加载器采用默认的委派模式

tomcat提供了delegate属性用于控制是否启用java委派模式，默认false（不启用），当设置为true时，tomcat将使用java的默认委派模式，这时加载顺序如下：

(1).先从缓存中加载；
(2).如果没有，则从JVM的Bootstrap类加载器加载；
(3).如果没有，则从父类加载器加载，加载顺序是AppClassLoader、Common、Shared。
(4).如果没有，则从当前类加载器加载（按照WEB-INF/classes、WEB-INF/lib的顺序）；

思考题：

我们在使用 JDBC 时，都需要加载 Driver 驱动，不知道你注意到没有，不写

Class.forName("com.mysql.jdbc.Driver")

也是可以让 com.mysql.jdbc.Driver 正确加载的，你知道是怎么做的吗？

这个问题大家可以下来自己尝试阅读源码得到解决。

07.Tomcat源码分析——类加载体系

思考题：

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

07.Tomcat源码分析——类加载体系

思考题：

热门文章

最新文章

相关课程

相关电子书