Tomcat组件梳理—Bootstrap启动器

一开始是直接从Server开始做梳理的，但是发现有很多东西是从Catalina传输过来的，Catalina又是从Bootstrap启动的，所以还是回过头来从Bootstrap开始梳理吧。

1.定义和功能

Bootstrap是Tomcat的入口类，main方法也在这个类中，脚本启动往往也是直接调用这个类。

该类作为启动整个Tomcat的启动器，有自己的一些特点，该类主要操作对象是Catalina类，但是这两个又是解耦的，解耦的方法是通过反射去获取Catalina的实例和方法，并调用。这样，Bootstrap和Catalina是隔离开的，因此如果有需要，也是可以自己实现一个启动器的。

Bootstrap是Catalina的装载器，并负责创建Tomcat自用的类加载器。

2.启动器的属性

先看Bootstrap的属性有哪些，属性是一个类的基本特征，一个类的具体实现就是由属性和功能方法来实现的。

public final class Bootstrap {

  /**

     * main使用的守护对象

     */

  private static Bootstrap daemon = null;

  //CatalinaBase的File对象

  private static final File catalinaBaseFile;

  //CatalinaHome的File对象

  private static final File catalinaHomeFile;

}

需要解释一下CatalinaBase和CatalinaHome

我们先提出一个需求：如果要在一台机器上部署多个Tomcat，必须要在一个台机器上安装多个tomcat吗？虽然直接解压就能用，但是tomcat有很多压缩包和公用的目录文件，都不能公用吗？

答案是：能。

那怎么实现呢？就是先确认tomcat的哪些目录能被共享，哪些目录不能被共享，然后共享的所有tomcat实例都能访问，不被共享的只能被自己访问。那现在来看看哪些能被共享吧。

tomcat解压后，除了一些文件，有以下目录：

bin —运行脚本
conf —配置文件
lib —核心库文件
logs --日志目录
temp --临时目录
webapps —自动装载的应用程序目录
work --JVM临时文件目录(java.io.tmpdir)

在这些目录中，只有bin和lib目录能被多个tomcat实例公用，于是我们把这两个目录的父级目录叫做安装目录，并用catalina.home来表示。

在目录中，被tomcat实例所私有的目录为：conf，logs，temp，webapps，work。于是我们把这些目录的父级目录叫做工作目录，并用catalina.base来表示。

到这里，我们应该已经明白了catalina.home和catalina.base两个参数的作用了。这两个参数只在用这种方法来做单机器多实例的时候才有用，但是现在微服务即使部署多个实例，也会直接放多个tomcat，因为磁盘的价格已经很便宜了，可以不用复杂度来换区空间。

所以，如果是一个tomcat，这两个属性指向的是相同位置，即都是这些目录的父级目录。

到这里，上面我们提出的问题，基本就被解决。

参考了文章：https://blog.csdn.net/duqian94/article/details/52460703

3.启动器的功能

3.1.Main方法解析

还是先看Main方法的代码吧

/**

 * main方法，整个程序的主入口。

 */

public static void main(String args[]) {

  if (daemon == null) {

    //1.new过程中主要执行static中的设置Catalina.home和Catalina.base的值

    Bootstrap bootstrap = new Bootstrap();

    try {

      //2.主要完成类加载器的初始化，包括common，catalina，share三个类加载器，

      // 并设置catalina的父类加载器。

      bootstrap.init();

    } catch (Throwable t) {

      handleThrowable(t);

      t.printStackTrace();

      return;

    }

    daemon = bootstrap;

  } else {

    // When running as a service the call to stop will be on a new

    // thread so make sure the correct class loader is used to prevent

    // a range of class not found exceptions.

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

  }

  try {

    String command = "start";

    if (args.length > 0) {

      command = args[args.length - 1];

    }

    //3.判断shell传入的值，执行对应的动作

    if (command.equals("startd")) {

      //执行start方法的内容，主要为执行Catalina的load()和start()方法

      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 t) {

    handleThrowable(t);

    t.printStackTrace();

    System.exit(1);

  }

}

Bootstrap中的main()方法时tomcat软件的入口方法，不管用什么方法启动tomcat，都是在调用这个方法。

该方法的业务逻辑比较简单，只有三个点：

1.new一个Bootstrap实例，在new的过程中有一段static的代码段会一起初始化，该代码段主要解决catalina.home和catalina.base参数的值，因为代码中会遇到这些变量，所以要去这些变量一定是在的。
2.执行init()方法，该方法主要用来创建common，shared，catalinaLoader三个类加载器，并将对应的jar包加载进来。
3.判断传入的参数是什么，然后通过反射调用Catalina中对应的方法。

3.2.new方法执行静态代码块

这里的代码就是在new时，需要初始化的代码。这里的代码逻辑没啥好说的，就是在检查参数，然后重新设值。放一下代码看看。

static {

        //该段主要设置Catalina.home路径和Catalina.base路径

        // Will always be non-null

        String userDir = System.getProperty("user.dir");

        // Home first

        String home = System.getProperty(Globals.CATALINA_HOME_PROP);

        File homeFile = null;

        if (home != null) {

            File f = new File(home);

            try {

                homeFile = f.getCanonicalFile();

            } catch (IOException ioe) {

                homeFile = f.getAbsoluteFile();

            }

        }

        if (homeFile == null) {

            // First fall-back. See if current directory is a bin directory

            // in a normal Tomcat install

            File bootstrapJar = new File(userDir, "bootstrap.jar");

            if (bootstrapJar.exists()) {

                File f = new File(userDir, "..");

                try {

                    homeFile = f.getCanonicalFile();

                } catch (IOException ioe) {

                    homeFile = f.getAbsoluteFile();

                }

            }

        }

        if (homeFile == null) {

            // Second fall-back. Use current directory

            File f = new File(userDir);

            try {

                homeFile = f.getCanonicalFile();

            } catch (IOException ioe) {

                homeFile = f.getAbsoluteFile();

            }

        }

        catalinaHomeFile = homeFile;

        System.setProperty(

                Globals.CATALINA_HOME_PROP, catalinaHomeFile.getPath());

        // Then base

        String base = System.getProperty(Globals.CATALINA_BASE_PROP);

        if (base == null) {

            catalinaBaseFile = catalinaHomeFile;

        } else {

            File baseFile = new File(base);

            try {

                baseFile = baseFile.getCanonicalFile();

            } catch (IOException ioe) {

                baseFile = baseFile.getAbsoluteFile();

            }

            catalinaBaseFile = baseFile;

        }

        System.setProperty(

                Globals.CATALINA_BASE_PROP, catalinaBaseFile.getPath());

    }

3.3.init方法创建类加载器

init()方法主要用来创建三个类加载器，并指定catalina的parent类加载器，看下代码中的处理逻辑。

public void init() throws Exception {

  //1.初始化类加载器：commonLoader，catalinaLoader，sharedLoader

  initClassLoaders();

  //2.设置当前线程的类加载器

  Thread.currentThread().setContextClassLoader(catalinaLoader);

  //3.设置Java SecutityManager，目前看没啥用？

  SecurityClassLoad.securityClassLoad(catalinaLoader);

  //4.加载Catalina类，并为Catalina设置父类加载器

  Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");

  Object startupInstance = startupClass.getConstructor().newInstance();

  //通过反射调用catalina.setParentClassLoader(ClassLoader classloader)方法，

  // 目的是设置Catalina的父类加载器为sharedLoader类加载器

  String methodName = "setParentClassLoader";

  Class<?> paramTypes[] = new Class[1];

  paramTypes[0] = Class.forName("java.lang.ClassLoader");

  Object paramValues[] = new Object[1];

  paramValues[0] = sharedLoader;

  //反射找到对应的方法时，需要指明两个参数：1.方法名称，2.方法对应的参数类型的列表，数组形式

  Method method =

    startupInstance.getClass().getMethod(methodName, paramTypes);

  method.invoke(startupInstance, paramValues);

  //5.把catalinaDaemon的值设置为org.apache.catalina.startup.Catalina

  catalinaDaemon = startupInstance;

}

先梳理此处的逻辑：

1.创建三个类加载器：commonLoader，catalinaLoader，shareLoader，这三个类加载器的目的不一样。
- commonLoader：Tomcat最基本的类加载器，直接继承systemLoader，加载路径中的class可以被tomcat容器本身以及各个webapp访问。加载路径为：common.loader，默认执行${catalina.home}/lib下的包。
- catalinaLoader：tomcat容器私有的类加载器，加载路径中的class对webapp不可见。加载路径为server.loader，默认为空。
- sharedLoader：各个webapp共享的类加载器，加载路劲中的class对于多有webapp可见，但是对于tomcat容器不可见。加载路径为shared.loader，默认为空。
2.把当前线程的类加载器设置为catalinaLoader.即当前线程只会加载tomcat私有的jar包。当前线程启动所有的组件，然后后面又会被阻塞，用来等待shutdown命令。
3.设置Java 的SecutityManager，这个东西讲不清楚是干嘛，可以先不管。
4.通过反射实例化Catalina类，并调用setParentClassLoader方法，为catalina设置ParentClassLoader属性。

其实从上面和代码中都可以看到，最重要的是就是第一步，创建三个类加载器了。

3.4.反射调用catalina的方法

在main方法的第三步中，根据传入的参数，选择对应的方法，此处虽然调用的是Bootstrap的方法，但是实际上时在通过放射调用Catalina中的方法，可以看一个代码示例：

private void load(String[] arguments) throws Exception {

  //主要是通过反射调用Catalina的load()方法

  // Call the load() method

  String methodName = "load";

  Object param[];

  Class<?> paramTypes[];

  if (arguments==null || arguments.length==0) {

    paramTypes = null;

    param = null;

  } else {

    paramTypes = new Class[1];

    paramTypes[0] = arguments.getClass();

    param = new Object[1];

    param[0] = arguments;

  }

  Method method =

    catalinaDaemon.getClass().getMethod(methodName, paramTypes);

  if (log.isDebugEnabled()) {

    log.debug("Calling startup class " + method);

  }

  method.invoke(catalinaDaemon, param);

}

可以看到代码，其实就是通过反射调用Catalina的load()方法。

3.5.操作Catalina的方法总结

Bootstrap在代码中对Catalina的操作，我们总结一下看看。

第一个是实例化Catalina

//org.apache.catalina.startup.Bootstrap#init()

//4.加载Catalina类，并为Catalina设置父类加载器

Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");

Object startupInstance = startupClass.getConstructor().newInstance();

第二个是调用方法，设置Catalina的parentClassLoader为sharedLoader

//通过反射调用catalina.setParentClassLoader(ClassLoader classloader)方法，

// 目的是设置Catalina的父类加载器为sharedLoader类加载器

String methodName = "setParentClassLoader";

Class<?> paramTypes[] = new Class[1];

paramTypes[0] = Class.forName("java.lang.ClassLoader");

Object paramValues[] = new Object[1];

paramValues[0] = sharedLoader;

//反射找到对应的方法时，需要指明两个参数：1.方法名称，2.方法对应的参数类型的列表，数组形式

Method method =

  startupInstance.getClass().getMethod(methodName, paramTypes);

method.invoke(startupInstance, paramValues);

第三个是调用Catalina的其他方法，主要接解决对应的启动或者关闭的命令

//org.apache.catalina.startup.Bootstrap#start

public void start() throws Exception {

  //主要调用Catalina的start()方法

  if( catalinaDaemon==null ) {

    init();

  }

  Method method = catalinaDaemon.getClass().getMethod("start", (Class [] )null);

  method.invoke(catalinaDaemon, (Object [])null);

}

4.总结

再明确一次Bootstrap的作用，一个是检查当前环境，二是创建三个类加载器，三是根据用户输入的参数，通过反射调用对应的方法。

环境检查在3.2中讲解的，类加载器在3.3中讲解的，根据参数执行方法在3.4.中讲解的。

以上，我们对Tomcat的启动器组件Bootstrap的分析就结束了。

巴特西

1.Tomcat组件梳理—Bootstrap启动器