SilverLining's Blog

Tomcat 组件生命周期与初始化过程

LifeCycle 接口

上一篇文章中提到,Tomcat 中主要有这些重要的组件:

这些组件是层层包含的。 Tomcat 通过定义 LifeCycle 接口来统一管理各组件的生命周期。我们来看一下 LifeCycle 接口中定义了以下方法:

public interface Lifecycle {
    public void init() throws LifecycleException;
    public void start() throws LifecycleException;
    public void stop() throws LifecycleException;
    public void destroy() throws LifecycleException;
}

LifeCycle 这个类的继承关系中,我们也可以印证,如 Container 以及其包含的 Host, Engine, wrapperContext 都实现了 LifeCycle 接口。

同样的,ServiceServer 这两大组件也实现了 LifeCycle 接口,并分别被 StandardServiceStandardServer 类实现。

启动入口分析

之前我们已经找到 Bootstrap 类是 Tomcat 程序的启动入口,那么我们是如何找到这个入口的呢?

首先,对于下载的 Tomcat Server,其启动入口是 bin/startup.sh 文件,他其实是启动了 catalina.sh,并传入了 start 参数:

PRGDIR=`dirname "PRG"`
EXECUTABLE=catalina.sh

exec "PRGDIR"/"EXECUTABLE" start "@"

那么我们再进去看 catalina.sh,搜索解析 start 参数的地方:

elif [ "1" = "start" ] ; then
    # ...
    if [ "1" = "-security" ] ; then
        # eval <some_code>
    else
        eval _NOHUP ""_RUNJAVA"" ""CATALINA_LOGGING_CONFIG""LOGGING_MANAGER "JAVA_OPTS" "CATALINA_OPTS" 
          -DENDORSED_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 "&"
    fi
fi

所以 Tomcat 启动的过程就可以简化理解为:

java xxx.jar $SOME_OPTS org.apache.catalina.startup.Bootstrap

至此确认了 Tomcat 启动的入口就是这个 Bootstrap 类。

继续看 Bootstrap.main 方法:

public final class Bootstrap {

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

    public static void main(String args[]) {
        synchronized (daemonLock) {
            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;
            } 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);
            }
        }
        // ...
    }

    public void init() throws Exception {

        initClassLoaders();

        // 实例化 Catalina 对象 startupInstance
        Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
        Object startupInstance = startupClass.getConstructor().newInstance();

        // Set the shared extensions class loader
        String methodName = "setParentClassLoader";
        Class<?> paramTypes[] = new Class[1];
        paramTypes[0] = Class.forName("java.lang.ClassLoader");
        Object paramValues[] = new Object[1];
        paramValues[0] = sharedLoader;

        // 反射调用 startupInstance.setParentClassLoader(paramValues) 方法,设置类加载器
        Method method = startupInstance.getClass().getMethod(methodName, paramTypes);
        method.invoke(startupInstance, paramValues);

        // 赋值给 catalinaDaemon
        catalinaDaemon = startupInstance;
    }
}

这段初始化逻辑,实际上是:

接着往下看 Main 方法,这里指出了 Tomcat 启动的关键两个步骤:加载初始化阶段启动阶段

public final class Bootstrap {
    public static void main(String args[]) {
        if (command.equals("start")) {
                daemon.setAwait(true);
                daemon.load(args);
                daemon.start();
        }
    }

    private void load(String[] arguments) throws Exception {
        String methodName = "load";
        Object param[];
        Class<?> paramTypes[];

        // 实际上是调用 Catalina.load()
        Method method = catalinaDaemon.getClass().getMethod(methodName, paramTypes);
        method.invoke(catalinaDaemon, param);
    }

    public void start() throws Exception {
        if (catalinaDaemon == null) {
            init();
        }

        // 实际上是调用 Catalina.start()
        Method method = catalinaDaemon.getClass().getMethod("start", (Class [])null);
        method.invoke(catalinaDaemon, (Object [])null);
    }
}

这里是典型的委派模式的应用。

加载初始化阶段

Server 初始化

先看 Catalina.load()方法。

public class Catalina {

    public void load() {
        initDirs();
        initNaming();

        // Create and execute our Digester
        Digester digester = createStartDigester();

        file = configFile();
        inputStream = new FileInputStream(file);
        inputSource = new InputSource(file.toURI().toURL().toString());

        inputSource.setByteStream(inputStream);
        digester.push(this);

        // 解析 server.xml 配置文件
        digester.parse(inputSource);

        getServer().setCatalina(this);
        getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
        getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());

        initStreams();

        // 继续初始化下一层的 Server 对象
        getServer().init();
    }
}

此时初始化来到了 Server.init()阶段,而这个接口定义在 LifeCycle.init()中,这里 LifeCycleServer 对象的生命周期进行了管理。

public abstract class LifecycleBase implements Lifecycle {
    @Override
    public final synchronized void init() throws LifecycleException {
        if (!state.equals(LifecycleState.NEW)) {
            invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
        }

        // 模板方法设计模式,定义抽象步骤顺序,由子类提供实现
        try {
            // 典型的状态模式的影子
            setStateInternal(LifecycleState.INITIALIZING, null, false);

            // 核心初始化操作,这里是调用了 Server.initInternal()
            initInternal();

            // 典型的状态模式的影子
            setStateInternal(LifecycleState.INITIALIZED, null, false);
        } catch (Throwable t) {
            handleSubClassException(t, "lifecycleBase.initFail", toString());
        }
    }
}

public final class StandardServer extends LifecycleMBeanBase implements Server {
    @Override
    protected void initInternal() throws LifecycleException {
        super.initInternal();
        // ...

        // 继续初始化下一级所有的 Service 容器
        // Service.init() 方法再次被 LifeCycle.init() 接管生命周期
        for (Service service : services) {
            service.init();
        }
    }
}

StandardServer 中,通过一个遍历继续初始化下一级所有的 Service 容器。

Service 初始化

老规矩,Service 容器的初始化也要先去 LifeCycle 报道,然后实现其 initInternal()方法:

public class StandardService extends LifecycleMBeanBase implements Service {
    @Override
    protected void initInternal() throws LifecycleException {

        super.initInternal();

        // 1. Servlet 容器引擎初始化
        if (engine != null) {
            engine.init();
        }

        // Initialize any Executors
        for (Executor executor : findExecutors()) {
            if (executor instanceof JmxEnabled) {
                ((JmxEnabled) executor).setDomain(getDomain());
            }
            executor.init();
        }

        // Initialize mapper listener
        mapperListener.init();

        // Initialize our defined Connectors
        synchronized (connectorsLock) {
            for (Connector connector : connectors) {
                try {
                    // 2. 遍历初始化所有的 Connector
                    connector.init();
                } catch (Exception e) {
                    String message = sm.getString(
                            "standardService.connector.initFailed", connector);
                    log.error(message, e);

                    if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE"))
                        throw new LifecycleException(message);
                }
            }
        }
    }
}

Engine 初始化

先看 Engine 对象的初始化逻辑。可以看到 StandardEngine 的初始化过程逻辑其实是在其父类 ContainerBase 中完成的。

public class StandardEngine extends ContainerBase implements Engine {
    @Override
    protected void initInternal() throws LifecycleException {
        getRealm();
        super.initInternal();
    }
}

public abstract class ContainerBase extends LifecycleMBeanBase implements Container {
    @Override
    protected void initInternal() throws LifecycleException {
        BlockingQueue<Runnable> startStopQueue = new LinkedBlockingQueue<>();
        startStopExecutor = new ThreadPoolExecutor(
                getStartStopThreadsInternal(),
                getStartStopThreadsInternal(), 10, TimeUnit.SECONDS,
                startStopQueue,
                new StartStopThreadFactory(getName() + "-startStop-"));
        startStopExecutor.allowCoreThreadTimeOut(true);
        super.initInternal();
    }
}

可以看到 Engine 组件初始化阶段,其实就是创建了一个名叫 startStopExecutor 的线程池,这个线程池会在 Engine.start()过程中使用,并对应多个 Host 实例。

Connector 初始化

Connector 的初始化,主要是调用了 ProtocolHandler.init()方法。

public class Connector extends LifecycleMBeanBase  {

    protected final ProtocolHandler protocolHandler;

    @Override
    protected void initInternal() throws LifecycleException {

        super.initInternal();

        // Initialize adapter
        adapter = new CoyoteAdapter(this);
        protocolHandler.setAdapter(adapter);

        // ...

        // 初始化 protocolHandler
        protocolHandler.init();
    }
}

继续看 AbstractProtocol.init()实现,其中调用了 Endpoint.init()方法来初始化 Endpoint 对象。

public abstract class AbstractProtocol<S> implements ProtocolHandler, MBeanRegistration {

    private final AbstractEndpoint<S> endpoint;

    @Override
    public void init() throws Exception {
        // ...
        String endpointName = getName();
        endpoint.setName(endpointName.substring(1, endpointName.length()-1));
        endpoint.setDomain(domain);

        // 初始化 Endpoint 对象
        endpoint.init();
    }
}

Endpoint 对象在初始化过程中调用了 bind()虚方法,最终由 NioEndpoint 类来实现:

public abstract class AbstractEndpoint<S> {

    public abstract void bind() throws Exception;

    public void init() throws Exception {
        if (bindOnInit) {
            bind();
            bindState = BindState.BOUND_ON_INIT;
        }
        // ...
    }
}

public class NioEndpoint extends AbstractJsseEndpoint<NioChannel> {

    @Override
    public void bind() throws Exception {

        if (!getUseInheritedChannel()) {

            // 获取 NIO Channel
            serverSock = ServerSocketChannel.open();
            socketProperties.setProperties(serverSock.socket());
            InetSocketAddress addr = (getAddress()!=null?new InetSocketAddress(getAddress(),getPort()):new InetSocketAddress(getPort()));

            // 绑定端口,但尚未 accept 客户端连接
            serverSock.socket().bind(addr,getAcceptCount());
        }
        // ...
    }
}

这里的 NioEndpoint 对象初始化过程中,获取了 NIO Channel 并完成了 serverSock.socket()的端口绑定。

至此,Tomcat 启动过程中,主要组件的初始化逻辑基本完成了。