Tomcat源码解析——Tomcat的启动流程

已于 2024-04-20 20:44:30 修改
阅读量1.4k 收藏 26
点赞数 13
分类专栏： Tomcat 文章标签： tomcat Tomcat启动 Tomcat源码
于 2024-04-14 22:57:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37914588/article/details/137753466
版权

一、启动脚本

        当我们在服务启动Tomcat时，都是通过执行startup.sh脚本启动。

        

        在Tomcat的启动脚本startup.sh中，最终会去执行catalina.sh脚本，传递的参数是start。

        

        在catalina.sh脚本中，前面是环境判断和初始化参数，最终根据传递的start来执行上图的代码，最终会调用Tomcat的Bootstrap启动类的main方法，传递的参数是start。

二、源码解析

        为了更容易的理解源码，整个系列中Tomcat的运行模式采用BIO的方式。

    public static void main(String args[]) {
        if (daemon == null) {
            Bootstrap bootstrap = new Bootstrap();
            try {
                //初始化
                bootstrap.init();
            } catch (Throwable t) {
                handleThrowable(t);
                t.printStackTrace();
                return;
            }
            daemon = bootstrap;
        } else {
            Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
        }
        try {
            String command = "start";
            if (args.length > 0) {
                command = args[args.length - 1];
            }
            //脚本传递的是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")) {
                //加载和启动整个Tomcat
                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);
            } 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);
        }
    }

        在启动类的main方法中，创建了一个启动类的实例，然后进行初始化，最后再根据启动命令传递进来的参数，也就是上文中的 start 来执行对应的逻辑，即加载和启动整个Tomcat。

    public void init() throws Exception {
        //设置容器的路径和脚本中的基本信息
        setCatalinaHome();
        setCatalinaBase();
        //初始化Tomcat的三大类加载器
        initClassLoaders();
        //该类加载器用于加载这个源码的类
        Thread.currentThread().setContextClassLoader(catalinaLoader);
        SecurityClassLoad.securityClassLoad(catalinaLoader);
        //创建一个容器的启动实例，待会用于加载server.xml
        Class<?> startupClass =
            catalinaLoader.loadClass
            ("org.apache.catalina.startup.Catalina");
        Object startupInstance = startupClass.newInstance();
        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;
    }

        在初始化启动器是，主要是创建三大类加载器（commonLoader、catalinaLoader、sharedLoader）并设置好父子关系，最后再创建一个启动的实例，主要是用来解析server.xml文件。

        在Tomcat中一共有四大类加载器，如下图：

类加载器作用父加载器

commonLoader（共同类加载器）

加载$CATALINA_HOME/lib下的类加载器应用类加载器

catalinaLoader（容器类加载器）

加载Tomcat应用服务器的类加载器，可以理解为加载Tomcat源码中的类共同类加载器

sharedLoader（共享类加载器）

加载应用类加载器的共享的类加载器，例如相同版本的mysql驱动等共同类加载器
WebappLoader（Web应用类加载）加载Web应用下的类类加载，每个web应用之间是相互隔离的共享类加载器

        commonLoader、catalinaLoader、sharedLoader可以在tomcat下的conf/catalina.properties文件中修改。

        初始化完成之后，会根据启动参数 start，然后执行daemon.load(args)，即加载。

    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);
        method.invoke(catalinaDaemon, param);
    }

        加载就是通过反射去调用Catalina的load方法。

Catalina：
    public void load() {
        //找到脚本中设置的路径
        initDirs();
        initNaming();
        //创建一个解析器
        Digester digester = createStartDigester();
        InputSource inputSource = null;
        InputStream inputStream = null;
        File file = null;
        try {
            try {
                //读取server.xml文件
                file = configFile();
                inputStream = new FileInputStream(file);
                inputSource = new InputSource(file.toURI().toURL().toString());
            } catch (Exception e) {
                if (log.isDebugEnabled()) {
                    log.debug(sm.getString("catalina.configFail", file), e);
                }
            }
            if (inputStream == null) {
                try {
                    inputStream = getClass().getClassLoader()
                            .getResourceAsStream(getConfigFile());
                    inputSource = new InputSource
                            (getClass().getClassLoader()
                                    .getResource(getConfigFile()).toString());
                } catch (Exception e) {
                    if (log.isDebugEnabled()) {
                        log.debug(sm.getString("catalina.configFail",
                                getConfigFile()), e);
                    }
                }
            }

            if (inputStream == null) {
                try {
                    inputStream = getClass().getClassLoader()
                            .getResourceAsStream("server-embed.xml");
                    inputSource = new InputSource
                            (getClass().getClassLoader()
                                    .getResource("server-embed.xml").toString());
                } catch (Exception e) {
                    if (log.isDebugEnabled()) {
                        log.debug(sm.getString("catalina.configFail",
                                "server-embed.xml"), e);
                    }
                }
            }
            if (inputStream == null || inputSource == null) {
                if (file == null) {
                    log.warn(sm.getString("catalina.configFail",
                            getConfigFile() + "] or [server-embed.xml]"));
                } else {
                    log.warn(sm.getString("catalina.configFail",
                            file.getAbsolutePath()));
                    if (file.exists() && !file.canRead()) {
                        log.warn("Permissions incorrect, read permission is not allowed on the file.");
                    }
                }
                return;
            }
            try {
                //解析server.xml文件，把server.xml中的每一个标签都转换成对应的实例对象
                inputSource.setByteStream(inputStream);
                digester.push(this);
                digester.parse(inputSource);
            } catch (SAXParseException spe) {
                log.warn("Catalina.start using " + getConfigFile() + ": " +
                        spe.getMessage());
                return;
            } catch (Exception e) {
                log.warn("Catalina.start using " + getConfigFile() + ": ", e);
                return;
            }
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    // Ignore
                }
            }
        }
        getServer().setCatalina(this);
        initStreams();
        try {
            //初始化最顶层的组件,会导致Service组件和Connector组件也跟着初始化
            getServer().init();
        } catch (LifecycleException e) {
            if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
                throw new java.lang.Error(e);
            } else {
                log.error("Catalina.start", e);
            }

        }
    }


StandardService：
    protected void startInternal() throws LifecycleException {

        setState(LifecycleState.STARTING);

        //容器的初始化（Engine、Host、Context）
        if (container != null) {
            synchronized (container) {
                container.start();
            }
        }
        
        //共享线程池的初始化
        synchronized (executors) {
            for (Executor executor: executors) {
                executor.start();
            }
        }

        synchronized (connectors) {
            //连接器的初始化
            for (Connector connector: connectors) {
                try {
                    if (connector.getState() != LifecycleState.FAILED) {
                        connector.start();
                    }
                } catch (Exception e) {
                    log.error(sm.getString(
                            "standardService.connector.startFailed",
                            connector), e);
                }
            }
        }
    }

        在Catalina的load方法中，会找到server.xml文件，然后解析标签并创建出对应的实例对象，最终在调用最顶层的Server组件的init方法，会调用Service组件的初始化，而Service组件的会调用Connector组件的初始化和容器的初始化（Engine、Host、Contxt）

        在上面3个组件的初始化中最值得关注的是Connector组件的初始化，因为它会绑定一个端口并且添加对应的协议处理器，从而等待请求。

Connector：
    
    protected void initInternal() throws LifecycleException {

        super.initInternal();
        //创建一个适配器
        adapter = new CoyoteAdapter(this);
        //协议处理器在连接器创建时也跟着创建了
        protocolHandler.setAdapter(adapter);
        if( null == parseBodyMethodsSet ) {
            setParseBodyMethods(getParseBodyMethods());
        }
        //...省略
        try {
            //协议处理器初始化
            protocolHandler.init();
        } catch (Exception e) {
            throw new LifecycleException
                (sm.getString
                 ("coyoteConnector.protocolHandlerInitializationFailed"), e);
        }
        mapperListener.init();
    }

Http11Protocol：

    public void init() throws Exception {
        //...省略
        try {
            endpoint.init();
        } catch (Exception ex) {
            getLog().error(sm.getString("abstractProtocolHandler.initError",
                    getName()), ex);
            throw ex;
        }
    }

JIoEndpoint:
    public final void init() throws Exception {
        testServerCipherSuitesOrderSupport();
        if (bindOnInit) {
            bind();
            bindState = BindState.BOUND_ON_INIT;
        }
    }

    public void bind() throws Exception {

        if (acceptorThreadCount == 0) {
            acceptorThreadCount = 1;
        }
        if (getMaxConnections() == 0) {
            setMaxConnections(getMaxThreadsExecutor(true));
        }
        
        if (serverSocketFactory == null) {
            if (isSSLEnabled()) {
                serverSocketFactory =
                    handler.getSslImplementation().getServerSocketFactory(this);
            } else {
                serverSocketFactory = new DefaultServerSocketFactory(this);
            }
        }
        //创建ServerSocket绑定监听端口
        if (serverSocket == null) {
            try {
                if (getAddress() == null) {
                    serverSocket = serverSocketFactory.createSocket(getPort(),
                            getBacklog());
                } else {
                    serverSocket = serverSocketFactory.createSocket(getPort(),
                            getBacklog(), getAddress());
                }
            } catch (BindException orig) {
                String msg;
                if (getAddress() == null)
                    msg = orig.getMessage() + " <null>:" + getPort();
                else
                    msg = orig.getMessage() + " " +
                            getAddress().toString() + ":" + getPort();
                BindException be = new BindException(msg);
                be.initCause(orig);
                throw be;
            }
        }

    }

        在连接器的初始化方法中，会调用协议处理器的初始化方法，协议处理器会调用Endpoint的初始化方法，最终在Endpoint中完成了ServerSocket的创建，并且绑定了端口（此时还不能接受处理HTTP请求）

        当Catalina的load方法调用完成后，除了懒加载的容器组件还未创建，其它组件都已经创建出来了，下一步就是启动这些组件（上面只是初始化，组件还没开始工作）。

    public void start()
        throws Exception {
        if( catalinaDaemon==null ) init();
        Method method = catalinaDaemon.getClass().getMethod("start", (Class [] )null);
        method.invoke(catalinaDaemon, (Object [])null);
    }

        跟调用load方法一样，也是通过反射去调用Catalina的start方法。

    public void start() {
        //...省略
        try {
            //调用Server的启动方法
            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;
        }
        //...省略
    }

        通过调用最顶层Server组件的start方法，会导致Service组件的start被调用，而Service组件的会调用Connector组件的start方法。

        此处值得关注的还是Connector的start方法，在上文中，ServerSocket已经被创建并且绑定了端口，但是还没有去执行接受连接的方法。  

Connector：
    protected void startInternal() throws LifecycleException {
        //...省略
        try {
            //调用协议处理器的start
            protocolHandler.start();
        } catch (Exception e) {
            //...省略
        }
        mapperListener.start();
    }


Http11Protocol

    public void start() throws Exception {
        try {
            endpoint.start();
        } catch (Exception ex) {
            
        }
    }


JIoEndpoint

    public final void start() throws Exception {
        if (bindState == BindState.UNBOUND) {
            bind();
            bindState = BindState.BOUND_ON_START;
        }
        startInternal();
    }



    public void startInternal() throws Exception {

        if (!running) {
            running = true;
            paused = false;
            //创建一个线程池
            if (getExecutor() == null) {
                createExecutor();
            }
            initializeConnectionLatch();
            //创建连接接收器并放入线程池中接受连接
            startAcceptorThreads();
            //创建一个超时处理线程
            Thread timeoutThread = new Thread(new AsyncTimeout(),
                    getName() + "-AsyncTimeout");
            timeoutThread.setPriority(threadPriority);
            timeoutThread.setDaemon(true);
            timeoutThread.start();
        }
    }


    protected final void startAcceptorThreads() {
        int count = getAcceptorThreadCount();
        //创建连接接收器
        acceptors = new Acceptor[count];
        for (int i = 0; i < count; i++) {
            acceptors[i] = createAcceptor();
            String threadName = getName() + "-Acceptor-" + i;
            acceptors[i].setThreadName(threadName);
            //一个连接接收器对应一个线程
            Thread t = new Thread(acceptors[i], threadName);
            t.setPriority(getAcceptorThreadPriority());
            t.setDaemon(getDaemon());
            t.start();
        }
    }

Acceptor：        
        public void run() {
                //...省略
                try {
                    countUpOrAwaitConnection();

                    Socket socket = null;
                    try {
                        //此处调用ServerSocket的阻塞接受连接方法
                        socket = serverSocketFactory.acceptSocket(serverSocket);
                    } catch (IOException ioe) {
                        countDownConnection();
                        // Introduce delay if necessary
                        errorDelay = handleExceptionWithDelay(errorDelay);
                        // re-throw
                        throw ioe;
                    }
                 //...省略
        }

          连接器start中调用协议处理器的start，协议处理器最终调用Endpoint的start，最终在Endpoint中创建了Acceptor(接收器)，并且将Acceptor放入一个线程中异步处理（因为BIO的socket会阻塞），此刻整个tomcat的启动流程大致完成，Tomcat启动完成之后，就是在Acceptor中接受请求并处理了。

        Tomcat启动时序图：

        

许夜3
关注
专栏目录
tomcat源码解析
01-20
### tomcat源码解析 #### 简介与概览 Tomcat作为一款开源的Servlet容器，被广泛应用于Java Web应用的开发与部署环境中。它不仅支持Servlet API，还支持JSP规范，使得开发者能够轻松地构建动态网页。本文旨在深入...
tomcat的启动过程（Tomcat源码解析（三））
jiaomingliang的专栏
08-10 9943
Tomcat组件生命周期管理 在Tomcat总体结构 （Tomcat源代码解析之二）中，我们列出了Tomcat中Server,Service,Connector,Engine,Host,Context的继承关系图，你会发现它们都实现了org.apache.catalina.Lifecycle接口，而org.apache.catalina.util.LifecycleBase采用了模板方法模式
Tomcat服务器的安装和启动
热门推荐
weixin_49628108的博客
03-27 4万+
新手小白安装Tomcat服务器教程
Tomcat源码
最新发布
weixin_46020880的博客
09-10 1179
Tomcat源码相对 spring 这类框架来说，可读性并不高，本次源码解析 主要把重点放在各组件功能和关系上，源码阅读过程会涉及到 多线程/nio/scoket 希望在阅读文章之前，你可以对这些概念有了解。
Tomcat -- 启动流程
neei的博客
07-03 3957
Tomcat核心原理解析
Tomcat的简介、版本选择与安装、配置与运行（启动、关闭、重启、配置成开机自启动服务）
u010804417的博客
08-11 1万+
Apache Tomcat是一个对于 【Jakarta Servlet、Jakarta 服务器页面、Jakarta 表达式语言？、Jakarta WebSocket、Jakarta 注解和Jakarta 身份验证规范】的开源实现。Jakarta EE平台（Jakarta EE platform）是Java EE平台（Java EE platform）的演变。Tomcat 10及更高版本实现了作为Jakarta EE一部分开发的规范。Tomcat 9及更早版本实现了为Java EE一部分发展的规范。
Tomcat源码解析系列一：Tomcat的整体架构
Running666的博客
05-21 938
Acceptor接收到请求封装成一个SocketProcessor扔进线程池Executor后，会调用Processor从操作系统底层读取、过滤字节流，对应用层协议（HTTP/AJP）进行解析封装，生成org.apache.coyote.Request和org.apache.coyote.Response对象。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8bARZsoh-1684648768857)(assets/image-20220719102639459.png)]
tomcat 服务器启动与部署项目
longool的博客
06-21 4649
tomcat
SpringBoot 源码解析——源码模块依赖分析.docx
11-12
在深入解析 SpringBoot 的源码时，了解其模块间的依赖关系至关重要，这有助于我们更好地理解框架的工作原理以及如何自定义和扩展功能。 首先，SpringBoot 的核心模块包括 `spring-boot` 和 `spring-boot-...
TOMCAT源码分析(启动框架).pdf
09-29
### TOMCAT源码分析——启动框架详解 #### 一、前言 TOMCAT作为一款广泛使用的开源Java Servlet容器，其内部实现复杂且强大。本文旨在深入剖析TOMCAT的启动框架及其整体架构，帮助读者更好地理解其工作原理。...
tomcat8.0源码+catalina-home.rar
03-13
本文将基于"tomcat8.0源码+catalina-home.rar"这个压缩包，详细探讨Tomcat 8.0的核心组件——Catalina Home，并通过源码分析，揭示其内部运行机制。 Catalina是Tomcat服务器的核心部分，负责处理Servlet和JSP请求。...
tomcat 类加载机制 —— ClassLoader
07-17
《Tomcat类加载机制——ClassLoader详解》 在Java Web开发中，Tomcat作为最常用的Servlet容器，其类加载机制对于...通过阅读和研究Tomcat源码，我们可以更深入地了解这一机制，从而更好地驾驭这个强大的Web服务器。
Tomcat 的使用（图文教学）
weixin_52533007的博客
07-26 1万+
本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！Tomcat 是一款免费、开源的 Web 服务器和 Servlet 容器，由 Apache 软件基金会开发和维护。Tomcat 实现了 Java Servlet、JavaServer Pages（JSP）、Java Expression Language（EL）和 WebSocket 等 Java 技术规范，可以作为 Web 应用程序的运行环境。
tomcat之源码分析
qq_36851469的博客
01-21 2596
catalina就是Tomcat服务器使用的 Apache实现的servlet容器的名字。 Tomcat的核心分为3个部分: （1）Web容器：处理静态页面。 （2）catalina：一个处理servlet的容器。 （3）JSP容器：把jsp页面翻译成一般的servlet。 Catalina 连接器负责将一个请求与容器相连。工作包括为它接收到的每个HTTP请求创建一个request对象和一个response对象。然后将处理过程交给容器。容器从连接器中接收到request对象和response对象，并负责调
Tomcat启动流程
kankan_s的专栏
08-05 1245
服务表示Tomcat的一个实例，而连接器用于处理与客户端的连接。请注意，Tomcat的源代码是一个复杂的Java项目，源码分析需要一定的Java Web开发和Java EE知识基础。跟踪源码：选择您感兴趣的启动过程中的某个关键点，例如服务初始化、连接器启动等，然后跟踪源码，深入了解每个方法的功能和执行流程。启动Web应用程序：在Tomcat启动过程中，会初始化并启动预加载的Web应用程序，即调用Web应用程序的。启动连接器：Tomcat会启动之前创建的连接器，开始监听指定的端口，等待客户端请求的到来。
Tomcat-启动流程
罗曼蒂克在消亡
08-29 991
Tomcat的启动流程,Debug盯源码梳理
浅谈Tomcat的启动流程（源码级别）
持续Java学习中
01-23 6337
文章目录一、启动入口1、startup.sh2、catalina.sh二、基础组件概念梳理1、整体架构2、LifecycleBase抽象类3、实现了LifecycleBase抽象类的子类三、tomcat初始化（init）1、tomcat自定义类加载器四、tomcat加载（load）1、createStartDigester（第2步）1）抽象指定的层级关系2）addObjectCreate3）addRuleSet4）addRule2、getServer().init(第5步)1）JMX2）globalNami
Tomcat源码环境搭建及启动
weixin_44406041的博客
07-11 1592
Tomcat源码项目搭建及启动，源码项目搭建过程中问题解决。
Tomcat源码解析(一)： Tomcat整体架构
从基础到源码解析的学习记录
01-09 3192
来确定请求是由哪个Wrapper容器里的。Pipeline-Valve是责任链模式。Tomcat支持的I/O模型。Tomcat支持的应用层协议。Pipeline接口。
tomcat 启动
04-27
Tomcat是一个开源的Java Servlet容器，用于运行Java Web应用程序。它是Apache软件基金会的一个项目，提供了一个HTTP服务器环境来运行Java代码。下面是Tomcat启动的步骤： 1. 下载和安装Tomcat：首先，你需要从Tomcat官方网站下载Tomcat的二进制文件，并按照官方文档的指导进行安装。 2. 配置环境变量：在安装完成后，需要设置JAVA_HOME和CATALINA_HOME两个环境变量。JAVA_HOME指向Java的安装目录，CATALINA_HOME指向Tomcat的安装目录。 3. 启动Tomcat：进入Tomcat的安装目录，找到bin目录下的startup.bat（Windows）或startup.sh（Linux）文件，双击运行（Windows）或在终端中执行（Linux）。 4. 检查启动状态：启动成功后，可以通过访问http://localhost:8080来检查Tomcat是否正常运行。如果能够看到Tomcat的欢迎页面，则表示启动成功。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值