三 tomcat启动源码分析（一）--入口代码Bootstrap初始化

上一章，我们分析了tomcat的启动和关闭脚本，发现最终java入口在org.apache.catalina.startup.Bootstrap类上，看下最后的启动脚本

#$_RUNJAVA通过setclasspath.sh获取了java路径
eval $_NOHUP "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS \
      -D$ENDORSED_PROP="\"$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 "&"

上一章节我们已经介绍过，通过一系列操作，配置完这种环境变量后，执行了org.apache.catalina.startup.Bootstrap类，看下上面命令翻译过来的语句

"/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.191.b12-1.el7_6.x86_64/jre/bin/java" 
"-Djava.util.logging.config.file=/mnt/jenkin-tomcat/conf/logging.properties"
 -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager 
 -Djdk.tls.ephemeralDHKeySize=2048        
 -Dignore.endorsed.dirs=""    
 -classpath "/mnt/jenkin-tomcat/bin/bootstrap.jar:/mnt/jenkin-tomcat/bin/tomcat-juli.jar"    
 -Dcatalina.base="/mnt/jenkin-tomcat"       
 -Dcatalina.home="/mnt/jenkin-tomcat"     
 -Djava.io.tmpdir="/mnt/jenkin-tomcat/temp"   
 org.apache.catalina.startup.Bootstrap start  >> "$CATALINA_OUT" 2>&1 "&"

这命令是不是就很熟悉了，显然通过java编译器，调用了org.apache.catalina.startup.Bootstrap类的main方法，传入了start作为命令参数，那我们就找到了启动的代码入口

   public static void main(String args[]) {

        //初始化Bootstrap类，tomcat的顶级loader
        if (daemon == null) {
            // Don't set daemon until init() has completed
            Bootstrap bootstrap = new Bootstrap();
            try {
                bootstrap.init();
            } catch (Throwable t) {
                handleThrowable(t);
                t.printStackTrace();
                return;
            }
            daemon = bootstrap;
        }

        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();
            } 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 t) {
            handleThrowable(t);
            // Unwrap the Exception for clearer error reporting
            if (t instanceof InvocationTargetException &&
                    t.getCause() != null) {
                t = t.getCause();
            }
            t.printStackTrace();
            System.exit(1);
        }

    }

看到，里边有两段启动核心
bootstrap.init();
daemon.setAwait(true); daemon.load(args); daemon.start();

让我们通过思维导图的方式看下bootstrap.init()干了什么

tomcat启动初始化，可以查看原图

导图中标注了初始化bootstrap.init()的工作说明，总结下主要干了一件事：
加载了/conf/catalina.properties中的common.loader、shared.loader、server.loader对应的jar包和properties等文件，最后初始化了Catalina类，这个类将是加载我们web的classloader。
所以我们自定义配置文件，比如应用的公共配置文件、日志文件等等，可以通过在common.loader后配置目录的形式加载，这样tomcat就会默认读取到你的配置，并且做到和你应用分离的需求
顺便学习下tomcat的异常处理写法

  try {
        ...
        } catch (Throwable t) {
            handleThrowable(t);
            log.error("Class loader creation threw exception", t);
            System.exit(1);
        }

初始化完init方法，赋值这两个属性

    private static Bootstrap daemon = null;
    private Object catalinaDaemon = null;

下面进行命令判断

else if (command.equals("start")) {
                daemon.setAwait(true);
                daemon.load(args);
                daemon.start();
            }

看下这三个方法setAwait、load和start

    public void setAwait(boolean await)
        throws Exception {

        Class<?> paramTypes[] = new Class[1];
        paramTypes[0] = Boolean.TYPE;
        Object paramValues[] = new Object[1];
        paramValues[0] = Boolean.valueOf(await);
        Method method =
            catalinaDaemon.getClass().getMethod("setAwait", paramTypes);
        method.invoke(catalinaDaemon, paramValues);

    }
    ....

实际都是调用的Catalina类的对应方法，这个我们将在下节学习。
好了到此为止tomcat的classloader的关系图是什么样子的呢？

classloader加载类图.png

根据jvm虚拟机classloader机制，commonloader的父类为系统classloader，此时就是AppClassLoader,而通过源代码可知

   String value = CatalinaProperties.getProperty(name + ".loader");
        if ((value == null) || (value.equals("")))
            return parent;

加载commonloader、calatinaLoader和sharedLoader时配置为空时，直接返回父加载器，所以默认calatinaLoader和sharedLoader都等于commonloader

好了，到此org.apache.catalina.startup.Bootstrap初始化，孵化出了calatina类，下面的工作就交给calatina进行应用启动了。我们一下节入口代码calatina启动应用介绍将会学习。

下一节---入口代码calatina启动应用介绍
目录---tomcat 源码学习系列

三 tomcat启动源码分析（一）--入口代码Bootstrap初始化

猜你喜欢