Tomcat启动流程

最新推荐文章于 2024-05-03 01:51:16 发布

记忆中逝去的往事

最新推荐文章于 2024-05-03 01:51:16 发布

阅读量1.4k

点赞数

分类专栏： Tomcat 文章标签： tomcat

本文链接：https://blog.csdn.net/z1790424577/article/details/105513906

版权

Tomcat 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Lifecycle

由于所有的组件均存在初始化、启动、停止等生命周期方法，拥有生命周期管理的特性，所以Tomcat在设计的时候，基于生命周期管理抽象成了一个接口 Lifecycle ，而组件 Server、Service、Container、Executor、Connector 组件，都实现了一个生命周期的接口，从而具有了以下生命周期中的核心方法：

init（）：初始化组件
start（）：启动组件
stop（）：停止组件
destroy（）：销毁组件

在这里插入图片描述

各组件的默认实现

上面我们提到的Server、Service、Engine、Host、Context都是接口，下图中罗列了这些接口的默认实现类。当前对于 Endpoint组件来说，在Tomcat中没有对应的Endpoint接口，但是有一个抽象类 AbstractEndpoint ，其下有三个实现类： NioEndpoint、
Nio2Endpoint、AprEndpoint ，这三个实现类，分别对应于前面讲解链接器 Coyote时，提到的链接器支持的三种IO模型：NIO，NIO2，APR ，Tomcat8.5版本中，默认采用的是 NioEndpoint；
在这里插入图片描述
ProtocolHandler ：Coyote协议接口，通过封装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库；

在这里插入图片描述

流程

在这里插入图片描述
初始化流程：

启动tomcat ，需要调用 bin/startup.bat (在linux 目录下 , 需要调用 bin/startup.sh)，在startup.bat 脚本中, 调用了catalina.bat；
在catalina.bat 脚本文件中，调用了BootStrap 中的main方法；
```
set MAINCLASS=org.apache.catalina.startup.Bootstrap
```

在BootStrap 的main方法中调用了 init 方法，来创建Catalina及初始化类加载器；

    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;
                }

在BootStrap的main方法中调用了 load 方法，在其中又调用了Catalina的load方法；

在Catalina 的load方法中 , 需要进行一些初始化的工作, 并需要构造Digester 对象, 用于解析 XML，最后初始化Server；

Catalina--->load()
        //解析Server.xml文件配置
        Digester digester = createStartDigester();
        
        getServer().setCatalina(this);
        getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
        getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());
        
		getServer().init();

在Server的initInternal()方法中，初始化了Engine、Executor、Connector;
```
engine.init();
executor.init();
connector.init();
```

在Connector中的initInternal()方法中，设置了CoyoteAdapter适配器并初始化了ProtocolHandler；

 adapter = new CoyoteAdapter(this);
 protocolHandler.setAdapter(adapter);
 protocolHandler.init();

ProtocolHandler是个接口，调用AbstractHttp11Protocol的init()方法，在此方法中调用了AbstractProtocol的init()方法，此方法中初始化了EndPoint;
```
endpoint.init();
```

启动流程

在BootStrap 的main方法中调用了start()方法；
通过反射又调用了Catalina的start()方法；
```
getServer().start();
```
在Server中的startInternal()方法又调用了Engine、Executor、Connector的start()方法；
在Connector的startInternal()方法中调用了ProtocolHandler的start()方法；
在AbstractProtocol的start()方法中调用了EndPoint的start()方法；

Tomcat 请求处理流程

设计了这么多层次的容器，Tomcat是怎么确定每一个请求应该由哪个Wrapper容器里的Servlet来处理的呢？答案是，Tomcat是用Mapper组件来完成这个任务的。

Mapper组件的功能就是将用户请求的URL定位到一个Servlet，它的工作原理是：Mapper组件里保存了Web应用的配置信息，其实就是容器组件与访问路径的映射关系，比如Host容器里配置的域名、Context容器里的Web应用路径，以及Wrapper容器里
Servlet映射的路径，你可以想象这些配置信息就是一个多层次的Map。

当一个请求到来时，Mapper组件通过解析请求URL里的域名和路径，再到自己保存的Map里去查找，就能定位到一个Servlet。请你注意，一个请求URL最后只会定位到一个Wrapper容器，也就是一个Servlet。下面的示意图中，就描述了当用户请求链接 http://www.itcast.cn/bbs/findAll 之后, 是如何找到最终处理业务逻辑的servlet：
在这里插入图片描述
那上面这幅图只是描述了根据请求的URL如何查找到需要执行的Servlet ，那么下面我们再来解析一下，从Tomcat的设计架构层面来分析Tomcat的请求处理：

步骤如下:

Connector组件Endpoint中的Acceptor监听客户端套接字连接并接收Socket；
将连接交给线程池Executor处理，开始执行请求响应任务；
Processor组件读取消息报文，解析请求行、请求体、请求头，封装成Request对象；
Mapper组件根据请求行的URL值和请求头的Host值匹配由哪个Host容器、Context容器、Wrapper容器处理请求；
CoyoteAdaptor组件负责将Connector组件和Engine容器关联起来，把生成的Request对象和响应对象Response传递到Engine容器中，调用 Pipeline；
Engine容器的管道开始处理，管道中包含若干个Valve、每个Valve负责部分处理逻辑。执行完Valve后会执行基础的 Valve–StandardEngineValve，负责调用Host容器的Pipeline；
Host容器的管道开始处理，流程类似，最后执行 Context容器的Pipeline；
Context容器的管道开始处理，流程类似，最后执行 Wrapper容器的Pipeline；
Wrapper容器的管道开始处理，流程类似，最后执行 Wrapper容器对应的Servlet对象的处理方法；

在这里插入图片描述
在前面所讲解的Tomcat的整体架构中，我们发现Tomcat中的各个组件各司其职，组件之间松耦合，确保了整体架构的可伸缩性和可拓展性，那么在组件内部，如何增强组件的灵活性和拓展性呢？在Tomcat中，每个Container组件采用责任链模式来完成具体的请求处理。

在Tomcat中定义了Pipeline 和 Valve 两个接口，Pipeline 用于构建责任链，后者代表责任链上的每个处理器。Pipeline 中维护了一个基础的Valve，它始终位于Pipeline的末端（最后执行），封装了具体的请求处理和输出响应的过程。当然，我们也可以调用
addValve()方法，为Pipeline 添加其他的Valve，后添加的Valve 位于基础的Valve之前，并按照添加顺序执行。Pipiline通过获得首个Valve来启动整合链条的执行。

Pipeline相关信息：https://www.cnblogs.com/coldridgeValley/p/5816414.html；

Jasper 简介

对于基于JSP 的web应用来说，我们可以直接在JSP页面中编写 Java代码，添加第三方的标签库，以及使用EL表达式。但是无论经过何种形式的处理，最终输出到客户端的都是标准的HTML页面（包含js ，css…），并不包含任何的java相关的语法。也就是说，我们可以把jsp看做是一种运行在服务端的脚本。那么服务器是如何将 JSP页面转换为HTML页面的呢？

Jasper模块是Tomcat的JSP核心引擎，我们知道JSP本质上是一个Servlet。Tomcat使用Jasper对JSP语法进行解析，生成Servlet并生成Class字节码，用户在进行访问jsp时，会访问Servlet，最终将访问的结果直接响应在浏览器端。另外，在运行的时候，Jasper还会检测JSP文件是否修改，如果修改，则会重新编译JSP文件。

JSP 编译方式

运行时编译：
Tomcat 并不会在启动Web应用的时候自动编译JSP文件，而是在客户端第一次请求时，才编译需要访问的JSP文件。

创建一个web项目

<%--
  Created by IntelliJ IDEA.
  User: dell
  Date: 2020/4/14
  Time: 17:14
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  This is a Test!!!
  </body>
</html>

Tomcat 在默认的web.xml 中配置了一个org.apache.jasper.servlet.JspServlet，用于处理所有的.jsp 或 .jspx 结尾的请求，该Servlet 实现即是运行时编译的入口。

    <servlet>
        <servlet-name>jsp</servlet-name>
        <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
        <init-param>
            <param-name>fork</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <param-name>xpoweredBy</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>3</load-on-startup>
    </servlet>

JspServlet 处理流程图：
在这里插入图片描述
编译结果：

如果在 tomcat/conf/web.xml 中配置了参数scratchdir ，则jsp编译后的结果，就会存储在该目录下；
如果没有配置该选项，则会将编译后的结果，存储在Tomcat安装目录下的work/Catalina(Engine名称)/localhost(Host名称)/Context名称；

如果使用的是 IDEA 开发工具集成Tomcat 访问web工程中的jsp ，编译后的结果，存放在：

C:\Users\Administrator\.IntelliJIdea2019.1\system\tomcat\_project_tomcat\work\Catalina\localhost\jsp_demo_01_war_exploded\org\apache\jsp

预编译：
除了运行时编译，我们还可以直接在Web应用启动时，一次性将Web应用中的所有的JSP页面一次性编译完成。在这种情况下，Web应用运行过程中，便可以不必再进行实时编译，而是直接调用JSP页面对应的Servlet 完成请求处理，从而提升系统性能。
Tomcat 提供了一个Shell程序JspC，用于支持JSP预编译，而且在Tomcat的安装目录下提供了一个 catalina-tasks.xml 文件声明了Tomcat 支持的Ant任务，因此，我们很容易使用 Ant 来执行JSP 预编译。（要想使用这种方式，必须得确保在此之前已经下载并安装了Apache Ant）。

JSP编译原理

编译后的.class 字节码文件及源码：

/*
 * Generated by the Jasper component of Apache Tomcat
 * Version: Apache Tomcat/@VERSION@
 * Generated at: 2020-04-14 09:24:08 UTC
 * Note: The last modified time of this file was set to
 *       the last modified time of the source file after
 *       generation to assist with modification tracking.
 */
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private static final java.util.Set<java.lang.String> _jspx_imports_packages;

  private static final java.util.Set<java.lang.String> _jspx_imports_classes;

  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = null;
  }

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public java.util.Set<java.lang.String> getPackageImports() {
    return _jspx_imports_packages;
  }

  public java.util.Set<java.lang.String> getClassImports() {
    return _jspx_imports_classes;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
      throws java.io.IOException, javax.servlet.ServletException {

    final java.lang.String _jspx_method = request.getMethod();
    if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
      response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSPs only permit GET POST or HEAD");
      return;
    }

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;


    try {
      response.setContentType("text/html;charset=UTF-8");
      pageContext = _jspxFactory.getPageContext(this, request, response,
      			null, true, 8192, true);
      _jspx_page_context = pageContext;
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;

      out.write("\n");
      out.write("\n");
      out.write("<html>\n");
      out.write("  <head>\n");
      out.write("    <title>$Title$</title>\n");
      out.write("  </head>\n");
      out.write("  <body>\n");
      out.write("  This is a Test!!!\n");
      out.write("  </body>\n");
      out.write("</html>\n");
    } catch (java.lang.Throwable t) {
      if (!(t instanceof javax.servlet.jsp.SkipPageException)){
        out = _jspx_out;
        if (out != null && out.getBufferSize() != 0)
          try {
            if (response.isCommitted()) {
              out.flush();
            } else {
              out.clearBuffer();
            }
          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

由编译后的源码解读，可以分析出以下几点：

其类名为 index_jsp ，继承自 org.apache.jasper.runtime.HttpJspBase ，该类是HttpServlet 的子类，所以jsp 本质就是一个Servlet;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent,
                 org.apache.jasper.runtime.JspSourceImports
public abstract class HttpJspBase extends HttpServlet implements HttpJspPage

通过属性 _jspx_dependants 保存了当前JSP页面依赖的资源，包含引入的外部的JSP页面、导入的标签、标签所在的jar包等，便于后续处理过程中使用（如重新编译检测，因此它以Map形式保存了每个资源的上次修改时间）;
```
private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;
```

通过属性 _jspx_imports_packages 存放导入的 java 包，默认导入 javax.servlet ，javax.servlet.http, javax.servlet.jsp;

private static final java.util.Set<java.lang.String> _jspx_imports_packages;
  static {
    _jspx_imports_packages = new java.util.HashSet<>();
    _jspx_imports_packages.add("javax.servlet");
    _jspx_imports_packages.add("javax.servlet.http");
    _jspx_imports_packages.add("javax.servlet.jsp");
    _jspx_imports_classes = null;
  }

通过属性 _jspx_imports_classes 存放导入的类，通过import 指令导入的DateFormat 、SimpleDateFormat 、Date 都会包含在该集合中。_jspx_imports_packages 和 _jspx_imports_classes 属性主要用于配置 EL 引擎上下文;

请求处理由方法 _jspService 完成，而在父类 HttpJspBase 中的service 方法通过模板方法模式，调用了子类的 _jspService 方法;

    @Override
    public final void service(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException
    {
        _jspService(request, response);
    }

_jspService 方法中定义了几个重要的局部变量： pageContext 、Session、application、config、out、page。由于整个页面的输出有 _jspService 方法完成，因此这些变量和参数会对整个JSP页面生效。这也是我们为什么可以在JSP页面使用这些变量的原因;
指定文档类型的指令（page）最终转换为 response.setContentType() 方法调用;
对于每一行的静态内容（HTML），调用 out.write 输出;
对于 <% … %> 中的java 代码，将直接转换为 Servlet 类中的代码。如果在 Java代码中嵌入了静态文件，则同样调用 out.write 输出;

JSP编译流程

JSP 编译过程如下：
在这里插入图片描述
Compiler 编译工作主要包含代码生成和编译两部分：
代码生成:

Compiler 通过一个 PageInfo 对象保存JSP 页面编译过程中的各种配置，这些配置可能来源于 Web 应用初始化参数，也可能来源于JSP页面的指令配置（如 page ，include）;
调用ParserController 解析指令节点，验证其是否合法，同时将配置信息保存到PageInfo 中，用于控制代码生成;
调用ParserController 解析整个页面，由于 JSP 是逐行解析，所以对于每一行会创建一个具体的Node 对象。如静态文本（TemplateText）、Java代码（Scriptlet）、定制标签（CustomTag）、Include指令（IncludeDirective）;
验证除指令外其他所有节点的合法性，如脚本、定制标签、EL表达式等;
收集除指令外其他节点的页面配置信息;
编译并加载当前 JSP 页面依赖的标签;
对于JSP页面的EL表达式，生成对应的映射函数;
生成JSP页面对应的Servlet 类源代码;

编译:
代码生成完成后， Compiler 还会生成 SMAP 信息。如果配置生成 SMAP 信息，Compiler 则会在编译阶段将SMAP 信息写到class 文件中。

在编译阶段， Compiler 的两个实现 AntCompiler 和 JDTCompiler 分别调用先关框架的API 进行源代码编译。

对于 AntCompiler 来说，构造一个 Ant 的javac 的任务完成编译。

对于 JDTCompiler 来说，调用 org.eclipse.jdt.internal.compiler.Compiler 完成编译。

记忆中逝去的往事

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Tomcat启动流程

Lifecycle由于所有的组件均存在初始化、启动、停止等生命周期方法，拥有生命周期管理的特性，所以Tomcat在设计的时候，基于生命周期管理抽象成了一个接口 Lifecycle ，而组件 Server、Service、Container、Executor、Connector 组件，都实现了一个生命周期的接口，从而具有了以下生命周期中的核心方法：init（）：初始化组件start（...
复制链接

扫一扫