tomcat源码分析-Bootstrap操作Catalina

1.前言

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业务的实现。

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

2.tomcat启动

2.1 从main看起

启动命令行：java [****] org.apache.catalina.startup.Boostrap start，从命令行中可知，调用的Boostrap类的main方法，main方法参数是start。

    public static void main(String args[]) {
        if (daemon == null) {
            Bootstrap bootstrap = new Bootstrap();
            try {
                bootstrap.init();
            }
            daemon = bootstrap;
        } else {
            Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
        }

        try {
            String command = "start";
            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);
            } 
        }

    }

从源码中可以看到，main方法可传入的参数有 startd、stopd、start、stop，startd和start的区别是设置了一个await的bool变量为true，这点在后面会继续提到。
通过运行tomcat参数的可以看到main方法主要做了3件事：

1. 实例化Boostrap对象，并调用其init方法；
2. 调用load方法
3. 调用start方法；

2.2、实例化Boostrap对象：

调用Boostrap的init方法主要完成三件事：
-（1）初始化路径：设置HOME和Base路径，其中HOME是tomcat安装目录，Base是tomcat工作目录；如果我们想要运行Tomcat 的 多个实例，但是不想安装多个Tomcat软件副本。那么我们可以配置多个工作 目录，每个运行实例独占一个工作目录，但是共享同一个安装目录。
-（2）初始化类加载器：初始化Tomcat类加载器：commonLoader、catalinaLoader、sharedLoader
commonLoader无父加载器，catalinaLoader和sharedLoader的父加载器都是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。

    public void init() throws Exception {
        //设置系统变量CATALINA_HOME和CATALINA_BASE
        setCatalinaHome();
        setCatalinaBase();
        //初始化classLoader
        initClassLoaders();

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

        SecurityClassLoad.securityClassLoad(catalinaLoader);

        // 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();
        // S 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);  
     
        catalinaDaemon = startupInstance;

    }

2.3、Boostrap的load方法

调用Catalina的load方法：
-（1）判断系统变量catalina设置HOME和Base路径是否设置，没有的话则设置一下
-（2）初始化命名服务的基本配置
-（3）Digester类，默认将conf/server.xml解析成相应的对象，这个解析很重要，因为是他完成了Connector和Container的初始化工作。先mark下，接下来会详细的介绍Digester是怎么完成Connector和Container的初始化，现在我们只要知道是这里完成的就可以了。
-（4）Server调用init初始化声明周期，其父类LifecycleBase实现

    //去掉了一些无用的代码
    public void load() {

        long t1 = System.nanoTime();

        // CATALINA_BASE和CATALINA_HOME设置
        initDirs();

        // 初始化命名服务的基本配置
        initNaming();

        //Digester类，主要用于处理xml配置文件(如conf/server.xml)，将xml文件转换成对应的java对象
        Digester digester = createStartDigester();

        InputSource inputSource = null;
        InputStream inputStream = null;
        File file = null;
        try {
            try {
                // 配置文件，由命令行参数-config指定，否则取默认值conf/server.xml  
                file = configFile();
                inputStream = new FileInputStream(file);
                inputSource = new InputSource(file.toURI().toURL().toString());
            } 

            try {
                inputSource.setByteStream(inputStream);
                //将cataline对象压栈，如果栈为空，则设置cataline对象为root
                digester.push(this);
                //解析server.xml里的Server并复制给Catalina类的server属性，而Server只有一个标准实现StandardServer，所以后面的getServer()即返回StandardServer
                digester.parse(inputSource);
            }
        } 

        getServer().setCatalina(this);

        // Stream redirection
        initStreams();

        // Start the new server
        try {
            getServer().init();
        } 
        ……
    }

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）注册钩子

    public void start() {
        try {
            //服务启动
            getServer().start();
        } 
        ……
        // Register shutdown hook
        if (useShutdownHook) {
            if (shutdownHook == null) {
                shutdownHook = new CatalinaShutdownHook();
            }
            Runtime.getRuntime().addShutdownHook(shutdownHook);
            LogManager logManager = LogManager.getLogManager();
            if (logManager instanceof ClassLoaderLogManager) {
                ((ClassLoaderLogManager) logManager).setUseShutdownHook(
                        false);
            }
        }

        if (await) {
            await(); // getServer().await()
            stop(); // Stop an existing server instance.
        }
    }

    public void await() {
      awaitSocket = new ServerSocket(port, 1,     InetAddress.getByName(address));
      while(!stopAwait) {
        // ...
        boolean match = command.toString.equals(shutdown);
        if (match) break;
      }
    }

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

评论

2 楼 IXHONG 2016-05-08  

BigBird2012 写道

这代码，怎么格式化的？markdown？

没错

1 楼 BigBird2012 2016-04-29  

这代码，怎么格式化的？markdown？