Tomcat源码解析(二)： Bootstrap和Catalina

Tomcat源码系列文章

Tomcat源码解析(一)： Tomcat整体架构

一、基础组件

1、Lifecycle生命周期顶级接口

由于所有的组件均存在初始化、启动、停止等生命周期方法，拥有生命周期管理的特性
基于生命周期管理抽象成了一个接口Lifecycle
组件Server、Service、Container、Executor、Connector组件，都实现生命周期的接口

在这里插入图片描述

2、组件的默认实现

先回顾下组件的作用以及之间的关系

Server：表示整个Tomcat Catalina servlet容器，Server中可以有多个Service
Service：表示Connector和Engine的组合，对外提供服务，Service可以包含多个Connector和一个Engine
Connector：为Tomcat Engine的连接组件，支持三种协议：HTTP/1.1、HTTP/2.0、AJP
- Endpoint负责提供字节流给Processor
- Processor负责提供Tomcat Request对象给Adapter
- Adapter负责提供ServletRequest对象给容器，实现类只有CoyoteAdapter
Engine：顶级容器，不能被其他容器包含，它接受处理连接器的所有请求，并将响应返回相应的连接器
Host：表示一个虚拟主机，包含主机名称和IP地址，这里默认是localhost
Context：表示一个 Web 应用程序，是 Servlet、Filter 的父容器
Wrapper：表示一个 Servlet，它负责管理 Servlet 的生命周期，并提供了方便的机制使用拦截器

在这里插入图片描述

组件默认实现的类图

对于Endpoint组件来说，在Tomcat中没有对应的Endpoint接口，但是有一个抽象类AbstractEndpoint
Tomcat8.5版本中，默认采用的是NioEndpoint

在这里插入图片描述

ProtocolHandler：通过封装Endpoint和Processor ，实现针对具体协议的处理功能
Tomcat按照协议和IO提供了6个实现类
- AJP协议
  - AjpNioProtocol ：采用NIO的IO模型
  - AjpNio2Protocol：采用NIO2的IO模型
  - AjpAprProtocol ：采用APR的IO模型，需要依赖于APR库
- HTTP协议
  - Http11NioProtocol ：采用NIO的IO模型，默认使用的协议
  - Http11Nio2Protocol：采用NIO2的IO模型
  - Http11AprProtocol ：采用APR的IO模型，需要依赖于APR库

在这里插入图片描述

二、启动类Bootstrap

首先来看下整个启动过程，我们可以看到Bootstrap作为启动入口首先进行了初始化方法init然后load方法加载了Catalina

在这里插入图片描述

1、main

Bootstrap的main方法首先会创建一个Bootstrap对象，调用它的init方法初始化
然后根据启动参数，调用Bootstrap对象的不同方法，默认模式为start，该模式下将会先后调用load与start方法

private static final Object daemonLock = new Object();
private static volatile Bootstrap daemon = null;

// Bootstrap类的main方法
public static void main(String args[]) {
    // 创建一个 Bootstrap 对象
    synchronized (daemonLock) {
        if (daemon == null) {
            Bootstrap bootstrap = new Bootstrap();
            try {
                // 调用init方法初始化
                bootstrap.init();
            } catch (Throwable t) {
                handleThrowable(t);
                t.printStackTrace();
                return;
            }
            daemon = bootstrap;
        } else {
            Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
        }
    }

    // 根据启动参数，分别调用 Bootstrap 对象的不同方法
    try {
        // 默认参数为start
        String command = "start"; 
        if (args.length > 0) {
            command = args[args.length - 1];
        }

        if (command.equals("startd")) {
            ...
        } else if (command.equals("stopd")) {
            ...
        } 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")) {
           ...
        } else if (command.equals("configtest")) {
            ...                    
        } else {
            log.warn("Bootstrap: command \"" + command + "\" does not exist.");
        }
    } catch (Throwable t) {
        if (t instanceof InvocationTargetException &&
                t.getCause() != null) {
            t = t.getCause();
        }
        handleThrowable(t);
        t.printStackTrace();
        System.exit(1);
    }
}

2、init

本文对类加载器内容不做分析，后续看情况单独讲
简单来说init就是反射实例化Catalina对象

public void init() throws Exception {
	// 初始化类加载器相关内容
    initClassLoaders();
    Thread.currentThread().setContextClassLoader(catalinaLoader);
    SecurityClassLoad.securityClassLoad(catalinaLoader);

    // Load our startup class and call its process() method
    if (log.isDebugEnabled())
        log.debug("Loading startup class");
        
    // 通过catalinaLoader加载Catalina，反射实例化Catalina对象
    Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
    Object startupInstance = startupClass.getConstructor().newInstance();

    // Set the 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;
   // 反射将sharedLoader设置为catalinaLoader的父类加载器，本文不做分析
    Method method =
        startupInstance.getClass().getMethod(methodName, paramTypes);
    method.invoke(startupInstance, paramValues);
	
	// 将catalina实例引用赋值
    catalinaDaemon = startupInstance;
}

3、load与start

load与start都是通过上一步获取到的catalinaDaemon对象反射调用catalina类的load与start方法
这两个过程我们会在下面的Catalina内容中介绍

load方法：

private void load(String[] arguments) throws Exception {
    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); 
    // 反射调用catalina的load方法，参数为null
    method.invoke(catalinaDaemon, param);
}

start方法：

 public void start()
     throws Exception {
     if( catalinaDaemon==null ) init();
	 // 反射调用catalina的start方法，参数为null
     Method method = catalinaDaemon.getClass().getMethod("start", (Class [] )null);
     method.invoke(catalinaDaemon, (Object [])null);
 }

三、加载Catalina

上文中Bootstrap类的load与start方法实质上就是反射调用catalina类的load与start方法

1、load

创建Digester对象，解析conf/server.xml文件
调用Server实现类StandardServer的init方法来初始化组件（下篇文章单独讲）

public void load() {
	// 如果已经加载则退出，默认false，下面会置为true
    if (loaded) {
        return;
    }
    loaded = true;

    initDirs();
    initNaming();

    // 创建Digester对象，用来解析server.xml文件
    Digester digester = createStartDigester();

    InputSource inputSource = null;
    InputStream inputStream = null;
    File file = null;

     try {
     	 // 加载conf目录下的server.xml文件
         file = configFile();
         inputStream = new FileInputStream(file);
         inputSource = new InputSource(file.toURI().toURL().toString());
     } catch (Exception e) {
		...
     }

     try {
         inputSource.setByteStream(inputStream);
         digester.push(this);
         // 开始解析conf/server.xml文件
         digester.parse(inputSource);
     } catch (SAXParseException spe) {
		...
     } 

	// server和catalina之间建立关联
	// Server接口实现类StandardServer是在解析server.xml文件时候创建
	// 当时StandardServer对象set到Catalina
	// 此时又将Catalinaset到StandardServer对象中
	// 形成：你中有我，我中有你
    getServer().setCatalina(this);
    getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
    getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());

	...

    // 初始化server，后面另开一篇单独讲
    try {
        getServer().init();
    } catch (LifecycleException e) {
		...
    }
}

Digester对象解析server.xml文件

在这里插入图片描述

2、start

再来看下整个启动过程
Catalina的load方法最后一步getServer().init()，就是Server、Service、Engine等一系列组件的初始化

在这里插入图片描述

调用server实现类StandardServer的start方法来启动服务器（下篇文章单独讲）

public void start() {

    if (getServer() == null) {
        load();
    }

    if (getServer() == null) {
        // 无法启动服务器。未配置服务器实例
        log.fatal("Cannot start server. Server instance is not configured.");
        return;
    }

    long t1 = System.nanoTime();

    // 调用server的start方法来启动服务器
    try {
        getServer().start();
    } catch (LifecycleException e) {
        log.fatal(sm.getString("catalina.serverStartFail"), e);
        try {
            getServer().destroy();
        } catch (LifecycleException e1) {
            log.debug("destroy() failed for failed Server ", e1);
        }
        return;
    }

    long t2 = System.nanoTime();
    if(log.isInfoEnabled()) {
        log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms");
    }

    // 注册关闭钩子
    if (useShutdownHook) {
        if (shutdownHook == null) {
            shutdownHook = new CatalinaShutdownHook();
        }
        // 注册shutdown钩子，main结束时调用
        // 如果server未停止调用stop方法停止
        Runtime.getRuntime().addShutdownHook(shutdownHook);

        LogManager logManager = LogManager.getLogManager();
        if (logManager instanceof ClassLoaderLogManager) {
            ((ClassLoaderLogManager) logManager).setUseShutdownHook(
                    false);
        }
    }
	// 进入等待状态
	// 启动类Bootstrap默认调start方法设置await=true
    if (await) {
    	// main线程等待，等待接收shutdown命令，接受到则跳出阻塞
        await();
        // 跳出阻塞，执行Server.stop();
        stop();
    }
}

2.1、注册shutdown钩子

注册shutdown钩子(CatalinaShutdownHook)，即注册一个线程任务，main结束时调用
getServer() != null 如果server未停止调用Catalina的stop方法停止

protected class CatalinaShutdownHook extends Thread {
    @Override
    public void run() {
        try {
            if (getServer() != null) {
                Catalina.this.stop();
            }
        } catch (Throwable ex) {
			...
        }
    }
}

2.2、监听shutdown命令

Socket监听8005端口shutdown命令
服务启动后服务器会监听8005端口，如果这个端口接收到了"SHUTDOWN"这个字符串，那么就会终止Server

server.xml开头内容

在这里插入图片描述

Catalina的await方法实际是调用Server实现类StandardServer的await方法

public void await() {
    getServer().await();
}

while循环监听Socket8005端口
如果Socket输入流读取到字符串“SHUTDOWN”，跳出while循环
Catalina的await阻塞方法就通过了

// StandardServer类方法

private int port = 8005;

private String shutdown = "SHUTDOWN";

private volatile ServerSocket awaitSocket = null;

@Override
public void await() {
    // shutdown端口配置为-2，启动完Server直接再终止Server
    if( port == -2 ) {
        return;
    }
    // 配置为-1，则不再监听shutdown端口
    if( port==-1 ) {
        try {
            awaitThread = Thread.currentThread();
            while(!stopAwait) {
                try {
                    Thread.sleep( 10000 );
                } catch( InterruptedException ex ) {
                    // continue and check the flag
                }
            }
        } finally {
            awaitThread = null;
        }
        return;
    }

    // 开启socket监听server.xml中的shutdown端口
    // 创建socket服务端
    try {
        awaitSocket = new ServerSocket(port, 1,
                InetAddress.getByName(address));
    } catch (IOException e) {
        return;
    }
    
    // 默认false，进入while循环
    while (!stopAwait) {
        ServerSocket serverSocket = awaitSocket;
        if (serverSocket == null) {
            break;
        }

        // Wait for the next connection
        Socket socket = null;
        StringBuilder command = new StringBuilder();
        InputStream stream;
        try {
        	// accept阻塞监听端口
            socket = serverSocket.accept();
            // 设置阻塞超时时间10秒，如果超时抛异常，catch捕捉到重新进入while循环
            socket.setSoTimeout(10 * 1000);  
            stream = socket.getInputStream();
        } catch (SocketTimeoutException ste) {
            continue;
        }
		
		// 从流中读取字符串
		...
                
        // 如果读取到字符串命令是"SHUTDOWN"则，跳出循环，开始终止服务器
        // shutdown变量是取server.xml中Server的shutdown属性
        boolean match = command.toString().equals(shutdown);
        if (match) {
            log.info(sm.getString("standardServer.shutdownViaPort"));
            break;
        } else
            log.warn("StandardServer.await: Invalid command '"
                    + command.toString() + "' received");
    }
}

2.3、停止Tomcat

await方法的作用是停住主线程，等待用户输入SHUTDOWN命令之后
- 停止等待，然后main线程就调用stop方法来停止Tomcat
最终调用Server的stop和destroy方法（下篇文章单独讲）

public void stop() {
    try {
        if (useShutdownHook) {
        	// 移除shutdown钩子，这个stop方法会停止server，不需要钩子再次执行
            Runtime.getRuntime().removeShutdownHook(shutdownHook);
            
            LogManager logManager = LogManager.getLogManager();
            if (logManager instanceof ClassLoaderLogManager) {
                ((ClassLoaderLogManager) logManager).setUseShutdownHook(
                        true);
            }
        }
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
    }

    // 调用Server的stop和destroy方法
    try {
        Server s = getServer();
        LifecycleState state = s.getState();
        if (LifecycleState.STOPPING_PREP.compareTo(state) <= 0
                && LifecycleState.DESTROYED.compareTo(state) >= 0) {
            // Nothing to do. stop() was already called
        } else {
            s.stop();
            s.destroy();
        }
    } catch (LifecycleException e) {
        log.error("Catalina.stop", e);
    }
}