通俗易懂之Tomcat源码分析——初始化与启动

一 前言

1.1、 问题思考

在阅读tomcat源码前，我们一般都会有如下几个疑问：

• web容器和servlet容器的区别是什么；

• 在springMVC中的web.xml是什么时候加载到tomcat中的；

• tomcat是怎么加载我们的web服务的；

• tomcat是怎么实现的热部署；

• 一个http请求是怎么被tomcat监听到的，会有哪些处理；

• 为什么请求可以有需要通过nginx的，也可以不需要nginx的直接请求到tomcat上？……

如果你想知道答案，那么接下来的文章会告诉你。

1.2、 基本姿势

问题先放在一边，我们都知道Tomcat是一种web容器，用来接收http请求，并将请求得到的结果返回。那么如果要我们设计一个web容器，该怎么做？

很自然的会想到，要有一个网络连接通信维护者和一个请求处理者。通信维护者能够监听到请求并返回数据；请求处理者能够将请求进行分解处理，得到请求应该返回的数据。 如果你的思路是这样的，那么恭喜你，你看源码会简单很多，因为 Tomcat 的设计核心就是这样的，由两大组件组成：Connector 和 Container。Connector负责的是底层的网络通信的实现，而Container负责的是上层servlet业务的实现。

阅读源码前的准备工作：tomcat源码下载，http://tomcat.apache.org/download-70.cgi

下载好源码后导入eclipse。Tomcat7.0工程是用 ant 构建的，在导入eclipse的时候可以选择 file-new-project-java project from existing ant buildfile 导入即可。

也许你会猴急，希望快点知道 Connector 和 Container 是怎么设计和实现的，不过我要掉你胃口了，先得给你讲讲 Tomcat 启动过程，因为只有知道了 Tomcat 启动过程，才能对 Connector 和 Container 是怎么初始化的了然于胸，知道了 Connector 和 Container 的初始化才能准确的把握其结构。

二 Tomcat 启动

2.1、 从main看起

我们从main入手看看到底做了什么

1. public static void main(String args[]) {

2.    if (daemon == null) {

3.        // Don't set daemon until init() has completed

4.        Bootstrap bootstrap = new Bootstrap();                               // 1.创建当前的 Bootstrap 类型的对象

5.        try {

6.            bootstrap.init();                                            // 2. 初始化整个系统中用到的几个 classLoader, 并设置父子关系, 创建 org.apache.catalina.startup.Catalina 对象, 设置其 parentClassLoader 为shareClassLoader, 为创建 WebappClassLoader 做准备

7.        } catch (Throwable t) {

8.            handleThrowable(t);

9.            t.printStackTrace();

10.            return;

11.        }

12.        daemon = bootstrap;                                         // 3. 保存当前引用到静态变量

13.    } else {

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

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

16.        // a range of class not found exceptions.

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

18.    }

19.                                                                   // 4. 程序运行到这边时 Thread.currentThread().contextClassLoader 就是 catalinaClassLoader 了(在 bootstrap.init() 里面进行了设置), 下面的所有加载 class操作, 都是由这个 classloader 来进行加载 (PS: 则在 Tomcat 8.0.x 里面, 这里的 catalinaClassLoader 其实就是 commonClassLoader)

20.    try {

21.        String command = "start";                                  // 5. 默认命令参数

22.        if (args.length > 0) {                                     // 6. 这里可能是其他的参数, 但默认命令就是 start

23.            command = args[args.length - 1];

24.        }

25.  

26.        if (command.equals("startd")) {                            // 7. 启动 Tomcat (PS: 这种方式, Tomcat 启动过后会立刻 关闭, 主要是 Catalina 里面的 await = false )

27.            args[args.length - 1] = "start";

28.            daemon.load(args);

29.            daemon.start();

30.        } else if (command.equals("stopd")) {                      // 8. 停止 Tomcat

31.            args[args.length - 1] = "stop";

32.            daemon.stop();

33.        } else if (command.equals("start")) {

34.            daemon.setAwait(true);                                 // 9. 通过更改 Catalina 里面的 await 值, 在 Tomcat start 执行时, 程序会 hold 住, 直到有向 Tomcat 发送 stop 命令, 程序才会停止 (详情见 Catalina.start() 方法最后那部分)

35.            daemon.load(args);                                     // 10. 直接调用 Catalina.load 方法, 进行初始化 各个文件, 命名服务, 用 Digester 来解析 XML 文件, 并且  init Tomcat 容器里面的各个组件

36.            daemon.start();                                        // 11. 启动当前 bootstrap 对象, 其实主要是通过反射调用前面生成的 org.apache.catalina.startup.Catalina 的 start 方法

37.        } else if (command.equals("stop")) {                       // 12. 停止 Tomcat (最终还是调用 StandardServer.stop())

38.            daemon.stopServer(args);

39.        } else if (command.equals("configtest")) {                 // 13. 这个只是 将 Tomcat 的配置文件加载进来, 通过反射调用 Catalina.init, 从而检测 程序对应的配置文件是否正确

40.            daemon.load(args);

41.            if (null==daemon.getServer()) {

42.                System.exit(1);

43.            }

44.            System.exit(0);

45.        } else {

46.            log.warn("Bootstrap: command \"" + command + "\" does not exist.");

47.        }

48.    } catch (Throwable t) {                                     // 抛出异常一直退出

49.        // Unwrap the Exception for clearer error reporting

50.        if (t instanceof InvocationTargetException &&

51.                t.getCause() != null) {

52.            t = t.getCause();

53.        }

54.        handleThrowable(t);

55.        t.printStackTrace();

56.        System.exit(1);

57.    }

58. }

上面的 main 主要strong text做了3件事情:

1. 创建 Bootstrap 对象

2. 调用bootstrap做一些初始化的操作(主要是 classloader 的创建)

3. 更具命令行传来的参数start -> 先后通过反射来调用 Catalina 类的 load, 与 start 方法.

2.2、实例化Boostrap对象

调用Boostrap的init方法主要完成三件事：

（1）初始化路径：设置HOME和Base路径，其中HOME是tomcat安装目录，Base是tomcat工作目录；如果我们想要运行Tomcat 的 多个实例，但是不想安装多个Tomcat软件副本。那么我们可以配置多个工作 目录，每个运行实例独占一个工作目录，但是共享同一个安装目录。

（2）初始化类加载器：初始化Tomcat类加载器：catalinaLoader、sharedLoader commonLoader无父加载器，catalinaLoader和sharedLoader的父加载器都是commonLoader，commonLoader的父加载器就是系统类加载器。其中若tomcat的配置文件没有配置：server.loader则catalinaLoader=commonLoader，同理，没配置shared.loader……,这三种都是URLClassLoader，使用Java 中的安全模型。 Tomcat 的类加载器体系如下结构所示：

 

（3）初始化Boostrap的Catalina对象：通过反射生成Catalina对象，并通过反射调用setParentClassLoader方法设置其父 ClassLoader为sharedLoader。为什么要用反射，不直接在声明的时候生成对象？使用反射来生成实例的原因是因为在tomcat的发展历史中可以不止Catalina一种启动方式，现在看代码已经没必要了。

（4）其他：主线程的classLoader设置为catalinaLoader，安全管理的classLoad设置为catalineLoader。

1. public void init()

2.        throws Exception

3.    {

4.        //设置系统变量CATALINA_HOME和CATALINA_BASE

5.        setCatalinaHome();

6.        setCatalinaBase();

7.        //初始化classLoader

8.        initClassLoaders();

9.  

10.        Thread.currentThread().setContextClassLoader(catalinaLoader);//主线程的classLoader

11.  

12.        SecurityClassLoad.securityClassLoad(catalinaLoader);

13.  

14.        // Load our startup class and call its process() method

15.        if (log.isDebugEnabled())

16.            log.debug("Loading startup class");

17.        Class startupClass =

18.            catalinaLoader.loadClass

19.            ("org.apache.catalina.startup.Catalina");

20.        Object startupInstance = startupClass.newInstance();

21.  

22.        //TODO:使用反射来生成实例的原因是因为在tomcat的发展历史中可以不止Catalina一种启动方式，现在看代码已经没必要了

23.        // Set the shared extensions class loader

24.        if (log.isDebugEnabled())

25.            log.debug("Setting startup class properties");

26.        String methodName = "setParentClassLoader";

27.        Class paramTypes[] = new Class[1];

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

29.        Object paramValues[] = new Object[1];

30.        paramValues[0] = sharedLoader;

31.        Method method =

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

33.        method.invoke(startupInstance, paramValues);

34.  

35.        //TODO:设置catalina的父classLoader为sharedLoader        

36.        catalinaDaemon = startupInstance;

37.  

38.    }

2.3、Boostrap的load方法

调用Catalina的load方法。通过参数判断设置一些条件并判断是否立即加载，加载调用load方法主要做了4件事：

1. 判断系统变量catalina设置HOME和Base路径是否设置，没有的话则设置一下（感觉像是烂代码啊，在Boostrap初始化的时候不是已经设置过一次吗？为什么不写在一起？）

2. 初始化命名服务的基本配置

3. Digester类，默认将conf/server.xml解析成相应的对象，这个解析很重要，因为是他完成了Connector和Container的初始化工作。先mark下，接下来会详细的介绍Digester是怎么完成Connector和Container的初始化，现在我们只要知道是这里完成的就可以了。

4. Server调用init初始化声明周期，其父类LifecycleMBeanBase实现

 

1. //去掉了一些无用的代码

2. public void load() {

3.  

4.        long t1 = System.nanoTime();

5.  

6.        // CATALINA_BASE和CATALINA_HOME设置

7.        initDirs();

8.  

9.        // 初始化命名服务的基本配置

10.        initNaming();

11.  

12.        //Digester类，主要用于处理xml配置文件，将xml文件转换成对应的java对象（默认为conf/server.xml）  

13.        Digester digester = createStartDigester();

14.  

15.        InputSource inputSource = null;

16.        InputStream inputStream = null;

17.        File file = null;

18.        try {

19.            try {

20.                // 配置文件，由命令行参数-config指定，否则取默认值conf/server.xml  

21.                file = configFile();

22.                inputStream = new FileInputStream(file);

23.                inputSource = new InputSource(file.toURI().toURL().toString());

24.            }

25.  

26.            try {

27.                inputSource.setByteStream(inputStream);

28.                //将cataline对象压栈，如果栈为空，则设置root为cataline对象

29.                digester.push(this);

30.                //遇到相应的应用对对象赋值，相应的调用则调用

31.                digester.parse(inputSource);

32.            }

33.        }

34.  

35.        getServer().setCatalina(this);

36.  

37.        // Stream redirection

38.        initStreams();

39.  

40.        // Start the new server

41.        try {

42.            getServer().init();

43.        }

44.        ……

45.    }

2.4、 Boostrap的start方法

调用Catalina的start方法：

1. Server加载：Server才是正真的tomcat服务执行者，包括Connector和Container。调用load方法；

2. 调用Server的start方法，最终调用的是StandardServer的startInternal方法，调用自己所有的Service的start方法，启动connector和container、excutor的start方法，后文会继续扩展。

3. 注册钩子

1. public void start() {

2.        try {

3.            //服务启动

4.            getServer().start();

5.        }

6.        ……

7.        // Register shutdown hook

8.        if (useShutdownHook) {

9.            if (shutdownHook == null) {

10.                shutdownHook = new CatalinaShutdownHook();

11.            }

12.            Runtime.getRuntime().addShutdownHook(shutdownHook);

13.            LogManager logManager = LogManager.getLogManager();

14.            if (logManager instanceof ClassLoaderLogManager) {

15.                ((ClassLoaderLogManager) logManager).setUseShutdownHook(

16.                        false);

17.            }

18.        }

19.  

20.        if (await) {

21.            await();

22.            stop();

23.        }

24.    }

可以看到，Boostrap调用Catalina的方法时，全部都用的是反射，包括生成Catalina对象。而tomcat的启动说白了其实就是初始化并启动Connector和Container。

 

往期精彩推荐

【面试篇】 BAT大企内部面试题泄密

【资源篇】 SpringBoot入门到高级全套资源

【技术篇】 Java中的String为什么不可变？

【技巧篇】 eclipse最全的快捷键(必收藏)

【面试篇】 JAVA多线程和并发基础面试问答

【面试篇】 HashMap和Hashtable的区别

【干货篇】 Java学习路线全攻略(资料、视频、源码、项目实战)

 

                            本文转载自微信公众号 『 java大数据修炼之道 』, 更多精彩请识别文末二维码识别关注

                                                         本公众号不定期举行送书和派送福利等活动, 欢迎关注 !!!

 

 

 

                                  Java大数据修炼之道，一个汇聚一万技术人的圈子，让学习之路更有趣！