Tomcat 原理(1)(2)

最新推荐文章于 2024-10-09 23:05:29 发布
最新推荐文章于 2024-10-09 23:05:29 发布
阅读量318 收藏
点赞数
分类专栏： Java web 系统架构 文章标签： tomcat server web java

http://xifeng91.iteye.com/blog/260730#bc2028109

http://xifeng91.iteye.com/blog/260752


1 - Tomcat Server的组成部分 

1.1 - Server 

A Server element represents the entire Catalina servlet container. (Singleton) 

1.2 - Service 

A Service element represents the combination of one or more Connector components that share a single Engine 
Service是这样一个集合：它由一个或者多个Connector组成，以及一个Engine，负责处理所有Connector所获得的客户请求 

1.3 - Connector 

一个Connector将在某个指定端口上侦听客户请求，并将获得的请求交给Engine来处理，从Engine处获得回应并返回客户 
TOMCAT有两个典型的Connector，一个直接侦听来自browser的http请求，一个侦听来自其它WebServer的请求 
Coyote Http/1.1 Connector 在端口8080处侦听来自客户browser的http请求 
Coyote JK2 Connector 在端口8009处侦听来自其它WebServer(Apache)的servlet/jsp代理请求 

1.4 - Engine 

The Engine element represents the entire request processing machinery associated with a particular Service 
It receives and processes all requests from one or more Connectors 
and returns the completed response to the Connector for ultimate transmission back to the client 
Engine下可以配置多个虚拟主机Virtual Host，每个虚拟主机都有一个域名 
当Engine获得一个请求时，它把该请求匹配到某个Host上，然后把该请求交给该Host来处理 
Engine有一个默认虚拟主机，当请求无法匹配到任何一个Host上的时候，将交给该默认Host来处理 

1.5 - Host 

代表一个Virtual Host，虚拟主机，每个虚拟主机和某个网络域名Domain Name相匹配 
每个虚拟主机下都可以部署(deploy)一个或者多个Web App，每个Web App对应于一个Context，有一个Context path 
当Host获得一个请求时，将把该请求匹配到某个Context上，然后把该请求交给该Context来处理 
匹配的方法是“最长匹配”，所以一个path==""的Context将成为该Host的默认Context 
所有无法和其它Context的路径名匹配的请求都将最终和该默认Context匹配 

1.6 - Context 

一个Context对应于一个Web Application，一个Web Application由一个或者多个Servlet组成 
Context在创建的时候将根据配置文件$CATALINA_HOME/conf/web.xml和$WEBAPP_HOME/WEB-INF/web.xml载入Servlet类 
当Context获得请求时，将在自己的映射表(mapping table)中寻找相匹配的Servlet类 
如果找到，则执行该类，获得请求的回应，并返回 

2 - Tomcat Server的结构图 


3 - 配置文件$CATALINA_HOME/conf/server.xml的说明 
该文件描述了如何启动Tomcat Server 

4 - Context的部署配置文件web.xml的说明 
一个Context对应于一个Web App，每个Web App是由一个或者多个servlet组成的 
当一个Web App被初始化的时候，它将用自己的ClassLoader对象载入“部署配置文件web.xml”中定义的每个servlet类 
它首先载入在$CATALINA_HOME/conf/web.xml中部署的servlet类 
然后载入在自己的Web App根目录下的WEB-INF/web.xml中部署的servlet类 
web.xml文件有两部分：servlet类定义和servlet映射定义 
每个被载入的servlet类都有一个名字，且被填入该Context的映射表(mapping table)中，和某种URL PATTERN对应 
当该Context获得请求时，将查询mapping table，找到被请求的servlet，并执行以获得请求回应 

分析一下所有的Context共享的web.xml文件，在其中定义的servlet被所有的Web App载入 

5 - Tomcat Server处理一个http请求的过程 
假设来自客户的请求为： 
http://localhost:8080/wsota/wsota_index.jsp 

  2. 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得
  3. Connector把该请求交给它所在的Service的Engine来处理，并等待来自Engine的回应
  4. Engine获得请求localhost/wsota/wsota_index.jsp，匹配它所拥有的所有虚拟主机Host
  5. Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）
  6. localhost Host获得请求/wsota/wsota_index.jsp，匹配它所拥有的所有Context
  7. Host匹配到路径为/wsota的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）
  8. path="/wsota"的Context获得请求/wsota_index.jsp，在它的mapping table中寻找对应的servlet
  9. Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类
  10. 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
  11. Context把执行完了之后的HttpServletResponse对象返回给Host
  12. Host把HttpServletResponse对象返回给Engine
  13. Engine把HttpServletResponse对象返回给Connector
  14. Connector把HttpServletResponse对象返回给客户browser
source:http://docs.huihoo.com/apache/tomcat/heavyz/01-startup.html 

Xml代码   收藏代码
  1. <web-app>  
  2.   
  3.   
  4.   <!-- 概述：  
  5.        该文件是所有的WEB APP共用的部署配置文件，  
  6.        每当一个WEB APP被DEPLOY，该文件都将先被处理，然后才是WEB APP自己的/WEB-INF/web.xml  
  7.        -->  
  8.   
  9.   
  10.   
  11.   <!--  +-------------------------+  -->  
  12.   <!--  |    servlet类定义部分    |  -->  
  13.   <!--  +-------------------------+  -->  
  14.   
  15.     
  16.   
  17.   <!-- DefaultServlet  
  18.        当用户的HTTP请求无法匹配任何一个servlet的时候，该servlet被执行  
  19.        URL PATTERN MAPPING : /  
  20.        -->  
  21.   
  22.     <servlet>  
  23.         <servlet-name>default</servlet-name>  
  24.         <servlet-class>  
  25.           org.apache.catalina.servlets.DefaultServlet  
  26.         </servlet-class>  
  27.         <init-param>  
  28.             <param-name>debug</param-name>  
  29.             <param-value>0</param-value>  
  30.         </init-param>  
  31.         <init-param>  
  32.             <param-name>listings</param-name>  
  33.             <param-value>true</param-value>  
  34.         </init-param>  
  35.         <load-on-startup>1</load-on-startup>  
  36.     </servlet>  
  37.   
  38.   
  39.   <!-- InvokerServlet  
  40.        处理一个WEB APP中的匿名servlet  
  41.        当一个servlet被编写并编译放入/WEB-INF/classes/中，却没有在/WEB-INF/web.xml中定义的时候  
  42.        该servlet被调用，把匿名servlet映射成/servlet/ClassName的形式  
  43.        URL PATTERN MAPPING : /servlet/*  
  44.        -->  
  45.   
  46.     <servlet>  
  47.         <servlet-name>invoker</servlet-name>  
  48.         <servlet-class>  
  49.           org.apache.catalina.servlets.InvokerServlet  
  50.         </servlet-class>  
  51.         <init-param>  
  52.             <param-name>debug</param-name>  
  53.             <param-value>0</param-value>  
  54.         </init-param>  
  55.         <load-on-startup>2</load-on-startup>  
  56.     </servlet>  
  57.   
  58.   
  59.   <!-- JspServlet  
  60.        当请求的是一个JSP页面的时候（*.jsp）该servlet被调用  
  61.        它是一个JSP编译器，将请求的JSP页面编译成为servlet再执行  
  62.        URL PATTERN MAPPING : *.jsp  
  63.        -->  
  64.   
  65.     <servlet>  
  66.         <servlet-name>jsp</servlet-name>  
  67.         <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>  
  68.         <init-param>  
  69.             <param-name>logVerbosityLevel</param-name>  
  70.             <param-value>WARNING</param-value>  
  71.         </init-param>  
  72.         <load-on-startup>3</load-on-startup>  
  73.     </servlet>  
  74.   
  75.   
  76.   <!--  +---------------------------+  -->  
  77.   <!--  |    servlet映射定义部分    |  -->  
  78.   <!--  +---------------------------+  -->  
  79.   
  80.       
  81.     <servlet-mapping>  
  82.         <servlet-name>default</servlet-name>  
  83.         <url-pattern>/</url-pattern>  
  84.     </servlet-mapping>  
  85.   
  86.     <servlet-mapping>  
  87.         <servlet-name>invoker</servlet-name>  
  88.         <url-pattern>/servlet/*</url-pattern>  
  89.     </servlet-mapping>  
  90.   
  91.     <servlet-mapping>  
  92.         <servlet-name>jsp</servlet-name>  
  93.         <url-pattern>*.jsp</url-pattern>  
  94.     </servlet-mapping>  
  95.   
  96.   
  97.   <!--  +------------------------+  -->  
  98.   <!--  |    其它部分，略去先    |  -->  
  99.   <!--  +------------------------+  -->  
  100.   
  101.     ... ... ... ...  
  102.   
  103. </web-app>  


Xml代码   收藏代码
  1. <!-- 启动Server  
  2.      在端口8005处等待关闭命令  
  3.      如果接受到"SHUTDOWN"字符串则关闭服务器  
  4.      -->  
  5.   
  6. <Server port="8005" shutdown="SHUTDOWN" debug="0">  
  7.   
  8.   
  9.   <!-- Listener ???  
  10.        目前没有看到这里  
  11.        -->  
  12.   
  13.   <Listener className="org.apache.catalina.mbeans.ServerLifecycleListener" debug="0"/>  
  14.   <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" debug="0"/>  
  15.   
  16.   
  17.   <!-- Global JNDI resources ???  
  18.        目前没有看到这里，先略去  
  19.        -->  
  20.   
  21.   <GlobalNamingResources>  
  22.     ... ... ... ...  
  23.   </GlobalNamingResources>  
  24.   
  25.   
  26.   <!-- Tomcat的Standalone Service  
  27.        Service是一组Connector的集合  
  28.        它们共用一个Engine来处理所有Connector收到的请求  
  29.        -->  
  30.   
  31.   <Service name="Tomcat-Standalone">  
  32.   
  33.   
  34.     <!-- Coyote HTTP/1.1 Connector  
  35.          className : 该Connector的实现类是org.apache.coyote.tomcat4.CoyoteConnector  
  36.          port : 在端口号8080处侦听来自客户browser的HTTP1.1请求  
  37.          minProcessors : 该Connector先创建5个线程等待客户请求，每个请求由一个线程负责  
  38.          maxProcessors : 当现有的线程不够服务客户请求时，若线程总数不足75个，则创建新线程来处理请求  
  39.          acceptCount : 当现有线程已经达到最大数75时，为客户请求排队  
  40.                        当队列中请求数超过100时，后来的请求返回Connection refused错误  
  41.          redirectport : 当客户请求是https时，把该请求转发到端口8443去  
  42.          其它属性略  
  43.          -->  
  44.   
  45.     <Connector className="org.apache.coyote.tomcat4.CoyoteConnector"   
  46.                port="8080"   
  47.                minProcessors="5" maxProcessors="75" acceptCount="100"   
  48.                enableLookups="true"   
  49.                redirectPort="8443"   
  50.                debug="0"   
  51.                connectionTimeout="20000"   
  52.                useURIValidationHack="false"   
  53.                disableUploadTimeout="true" />  
  54.   
  55.   
  56.     <!-- Engine用来处理Connector收到的Http请求  
  57.          它将匹配请求和自己的虚拟主机，并把请求转交给对应的Host来处理  
  58.          默认虚拟主机是localhost  
  59.          -->  
  60.   
  61.     <Engine name="Standalone" defaultHost="localhost" debug="0">  
  62.       
  63.   
  64.       <!-- 日志类，目前没有看到，略去先 -->  
  65.   
  66.       <Logger className="org.apache.catalina.logger.FileLogger" .../>  
  67.   
  68.       <!-- Realm，目前没有看到，略去先 -->  
  69.   
  70.       <Realm className="org.apache.catalina.realm.UserDatabaseRealm" .../>  
  71.   
  72.   
  73.       <!-- 虚拟主机localhost  
  74.            appBase : 该虚拟主机的根目录是webapps/  
  75.            它将匹配请求和自己的Context的路径，并把请求转交给对应的Context来处理  
  76.            -->  
  77.   
  78.       <Host name="localhost" debug="0" appBase="webapps" unpackWARs="true" autoDeploy="true">  
  79.         
  80.   
  81.         <!-- 日志类，目前没有看到，略去先 -->  
  82.   
  83.         <Logger className="org.apache.catalina.logger.FileLogger" .../>  
  84.         
  85.   
  86.         <!-- Context，对应于一个Web App  
  87.              path : 该Context的路径名是""，故该Context是该Host的默认Context  
  88.              docBase : 该Context的根目录是webapps/mycontext/  
  89.              -->  
  90.   
  91.         <Context path="" docBase="mycontext" debug="0"/>  
  92.           
  93.   
  94.         <!-- 另外一个Context，路径名是/wsota -->  
  95.   
  96.         <Context path="/wsota" docBase="wsotaProject" debug="0"/>  
  97.                
  98.           
  99.       </Host>  
  100.         
  101.     </Engine>  
  102.   
  103.   </Service>  
  104.   
  105. </Server>  







Tomcat 原理解说：启动过程分析 

从开始学Java，使用网页编程，我们的程序就一直在web容器内运行。容器的概念也是彷佛距离我们相当遥远。Spring给了我们一扇窗户，让我们理解轻量级容器的解决方案。非常庆幸我们所处在一个开源的Java世界，所有的优秀软件都可以在代码级进行亲密接触。 
Tomcat结构写的相当之好，极易阅读。本系列文档计划着重以下3个方面： 
1. Tomcat 启动过程分析。分析tomcat的启动过程 
2. Tomcat Web容器功能分析。分析web容器的实现方法 
3. Tomcat 其他配置说明。一些我们目前应用较少的Tomcat配置项说明 
注意，本文档分析基于Tomcat5.028完成。 
Tomcat的启动过程简单说起来，就是读取配置文件server.xml，然后对其进行实例化的过程。 
1. 启动命令行参数 
命令行方式下，直接启动startup.bat/.sh即可。bat文件目的就在于获得启动参数。一般情况下，使用类似如下所示的启动方法。注意：bootstrap.jar文件中，还指定了3个包在classpath中。 
java -classpath "d:\tools\jdk1.5.0\lib\tools.jar;D:\Tomcat-5.0.28\bin\bootstrap.jar" -Dcatalina.base="D:\Tomcat-5.0.28" -Dcatalina.home="D:\Tomcat-5.0.28" -Djava.io.tmpdir="D:\Tomcat-5.0.28\temp" org.apache.catalina.startup.Bootstrap start 
Bootstrap是Tomcat的入口。比如启动、关闭、重启都是通过这个类实现对tomcat的控制。 

2. ClassLoader的使用 
Tomcat对不同的模块可能使用不同的ClassLoader加载。这也就是为什么很多类不在启动的classpath中，却可以被它调用的原因。 
下面是Bootstrap初始化ClassLoader的方法： 
Java代码   收藏代码
  1. private void initClassLoaders() {  
  2.     try {  
  3.         ClassLoaderFactory.setDebug(debug);  
  4.         commonLoader = createClassLoader("common", null);  
  5.         catalinaLoader = createClassLoader("server", commonLoader);  
  6.         sharedLoader = createClassLoader("shared", commonLoader);  
  7.     } catch (Throwable t) {  
  8.         log("Class loader creation threw exception", t);  
  9.         System.exit(1);  
  10.     }  
  11. }  

下图是Tomcat用户手册上看到的。 
       Bootstrap 
          | 
       System 
          | 
       Common 
      /      \ 
Catalina   Shared 
(server)     /   \ 
      Webapp1 Webapp2 ... 
Bootstrap是JVM提供的 
System是在classpath中提供的 
Common包含配置文件/org/apache/catalina/startup/catalina.properties中指定的类库支持 
Catalina和Shared都从Common中继承，包含的类库也在上面配置文件中指定。 
WebappX在部署单个Tomcat5实例时指定。一个webapp下面的类库对另外一个是不可见的 
Tomcat加载类的顺序和普通的不太一样，如下： 
Bootstrap classes of your JVM 
System class loader classses (described above) 
/WEB-INF/classes of your web application 
/WEB-INF/lib/*.jar of your web application 
$CATALINA_HOME/common/classes 
$CATALINA_HOME/common/endorsed/*.jar 
$CATALINA_HOME/common/lib/*.jar 
$CATALINA_BASE/shared/classes 
$CATALINA_BASE/shared/lib/*.jar 
注意，如果希望不使用JVM本身提供的类。这时可以使用jdk的endorsed 特性。 

3. Catalina类的作用 
如果要启动Tomcat，那么一个org.apache.catalina.startup.Catalina实例就生成，由它完成接下来的工作。 
下面是它的启动代码 
Java代码   收藏代码
  1. public void start() {  
  2.     if (server == null) {  
  3.         load();  
  4.     }  
  5.     long t1 = System.currentTimeMillis();  
  6.     // Start the new server  
  7.     if (server instanceof Lifecycle) {  
  8.         try {  
  9.             ((Lifecycle) server).start();  
  10.         } catch (LifecycleException e) {  
  11.             log.error("Catalina.start: ", e);  
  12.         }  
  13.     }  
  14.     long t2 = System.currentTimeMillis();  
  15.     log.info("Server startup in " + (t2 - t1) + " ms");  
  16.     try {  
  17.         // Register shutdown hook  
  18.         if (useShutdownHook) {  
  19.             if (shutdownHook == null) {  
  20.                 shutdownHook = new CatalinaShutdownHook();  
  21.             }  
  22.             Runtime.getRuntime().addShutdownHook(shutdownHook);  
  23.         }  
  24.     } catch (Throwable t) {  
  25.     }  
  26.     if (await) {  
  27.         await();  
  28.         stop();  
  29.     }  
  30. }   
启动过程先载入配置文件，然后根据配置文件启动的Server实例启动实例，在实例中注册关闭钩子。 
接下来的工作就是等待发出关闭指令或重启指令了。 
4. Server对象的生成 
服务的生成就是根据配置文件server.xml，实例化的对象。对象实例化过程中，会做载入webapp，在特定端口等待客户连接等工作。 
从server.xml到对象的映射是通过commons-digester.jar包完成的。这个包的一个主要功能就是映射xml到java对象。 
catalina类的方法createStartDigester完成了这个工作。部分代码如下 
Java代码   收藏代码
  1. Digester digester = new CatalinaDigester();  
  2. digester.setValidating(false);  
  3. digester.setClassLoader(StandardServer.class.getClassLoader());  
  4.   
  5. // Configure the actions we will be using  
  6. digester.addObjectCreate("Server","org.apache.catalina.core.StandardServer", "className");  
  7. digester.addSetProperties("Server");  
  8. digester.addSetNext("Server","setServer","org.apache.catalina.Server");   
digester会在解析之后，返回一个对象。 
5. 服务的中止 
StandardServer.await是保持tomcat运行的秘密。方法启动一个ServerSocket，侦听发出停止的字符串。这是一个死循环。当有停止运行的字符发出，跳出此循环。 
Java代码   收藏代码
  1. Socket socket = null;  
  2. InputStream stream = null;  
  3. try {  
  4.     socket = serverSocket.accept();  
  5.     socket.setSoTimeout(10 * 1000); // Ten seconds  
  6.     stream = socket.getInputStream();  
  7. } catch (AccessControlException ace) {  
  8. ......  
  9. while (true) {  
  10.     ......  
  11.     StringBuffer command = new StringBuffer();  
  12.     ......  
  13.     while (expected > 0) {  
  14.         ......  
  15.         ch = stream.read();  
  16.         ......  
  17.          command.append((char) ch);  
  18.         ......  
  19.     }  
  20.     ......  
  21.     boolean match = command.toString().equals(shutdown);  
  22.     if (match) break;  
  23. ......  
  24. }  
  25. ......  
  26. serverSocket.close();   
跳出循环后，系统执行关闭连接等资源的操作，服务就中止了。 
我们上面谈到，因为Catalina已经注册了关闭钩子，所以从命令行方式关闭进程也是可以释放资源的。但前提是JVM必须在。如果JVM都立刻杀掉了，释放的操作就不能进行了。 
Catalina.stopServer方法用于发出一个让服务停止的指令 
Java代码   收藏代码
  1. Socket socket = new Socket("127.0.0.1", server.getPort());  
  2. OutputStream stream = socket.getOutputStream();  
  3. String shutdown = server.getShutdown();  
  4. for (int i = 0; i < shutdown.length(); i++)  
  5.     stream.write(shutdown.charAt(i));  
  6. stream.flush();  
  7. stream.close();  
  8. socket.close();   

这一篇内容就是这些。下一篇文章将介绍StandardService的工作过程，着重在Web容器的工作原理

liangxw1
关注
专栏目录
Tomcat完整笔记
weixin_40212405的博客
10-12 920
1. Tomcat的安装和配置环境变量 安装 到官网下载需要的Tomcat版本的压缩包即可 注意：Tomcat 9 对应的JRE必须>=JRE 8；Tomcat 8 7同理 然后解压到指定的文件夹；目录名为：“apache-tomcat-[version]” （WINDOWS和Linux）一样的效果 配置环境变量 配置JRE环境变量，变量名为：CATALINA_HOME（required)和...
tomcat原理
wxdot1的博客
07-27 1607
1.利用socket获取HTTP协议字符串操作系统管着这几层操作系统管理的东西，真实的数据放在网卡当中，数据之间传输也是通过网卡传输的网卡的来历：如果只有两个计算机，只需要加一条电缆就行因为本质也是电容信号；后来电脑多了，就出现了网卡，控制着网络设备的发送与接收，很显然，网卡属于物理硬件。操作系统怎么操作网卡？通过网卡驱动来进行管理的socket和上述有什么关系？socket用于应用层和操作系统如何通信，他作用于应用层与操作系统之间，socket的本质是 操作系统提供的程序员操作网络协议的接口一个电脑发送一
Leetcode 46. Permutations
weixin_30407613的博客
08-04 78
https://leetcode.com/problems/permutations/ Medium Given a collection ofdistinctintegers, return all possible permutations. Example: Input: [1,2,3] Output: [ [1,2,3], [1...
tomcat中的几种log
cen_s的博客
11-02 2257
原文：http://www.10tiao.com/html/240/201705/2649257445/1.html 日志是程序员居家旅行必备，哦不对，是定位问题，修复bug，甚至是验证应用是否正常的必备利器。甚至很多时候，我们做一次部署仅仅是为了加一行log。虽然现在有各种各样的问题诊断工具，但是在定位线上问题时，我们很多时候还是希望有打印良好的log。 打印良好的log
Tomcat探秘（4）：tomcat启动过程详述
马靖的个人技术博客
06-11 9947
熟悉Tomcat的工程师们，后者从事Java开发的，肯定都知道Tomcat是如何启动和停止的。在Tomcat源码包里面有个bin目录，该目录下放置了一些很重要的脚本，Tomcat启动和停止的脚本程序就放在这里，分别是startup.bat、shutdown.bat（Windows环境）和start.sh、shutdown.sh（Linux、Unix环境）。大家一定都知道如何使用它们，接下来就是研究
Tomcat的使用总结(一)
悦分享
08-26 987
Tomcat的使用总结(一) 作为后端开发人员，在实际的工作中我们会非常高频地使用到web服务器。而tomcat作为web服务器领域中举足轻重的一个web框架，又是不能不学习和了解的。 2004年出版的tomcat书籍《How tomcat works》用非常直观和直白的方式来讲述了tomcat的框架结构和工作原理，楼主正是参考此书来深入学习tomcat的。想对tomcat进行深入了解的同学也...
Tomcat原理与实战
08-27
【Tomcat原理与实战】 Tomcat是一个开源的Java Servlet容器，由Apache软件基金会的Jakarta项目维护。它实现了Java EE的Web应用服务器规范，特别是Servlet和JSP规范，是开发和部署Java Web应用程序的常用工具。...
TOMCAT原理详解及请求过程
12-06
### TOMCAT原理详解及请求过程 #### 一、TOMCAT概述 TOMCAT是一个开源的免费的轻量级Web应用服务器，它主要作为一个JSP/Servlet容器而被广泛使用。Tomcat支持Java Servlet和JavaServer Pages (JSP)技术，并且提供...
tomcat服务器工作原理
12-28
**Tomcat服务器工作原理** Tomcat是一款开源的Java Servlet容器，它是Apache软件基金会下的Jakarta项目的核心组件，主要用于部署和运行Java Web应用程序。Tomcat以其轻量级、高效和易于管理的特性，成为了许多...
tomcat工作原理(中文版)
01-29
### Tomcat工作原理详解 #### 一、概览 Tomcat是Apache软件基金会下的Jakarta项目中的一个开源的Web服务器和Servlet容器。它主要用来运行Java Web应用，并且支持Servlet和JSP技术。Tomcat的核心架构包括多个组件，...
Tomcat关闭过程
peerless_hero的博客
12-01 4012
观察org.apache.catalina.startup.Catalina.java中的start()方法，我们发现Serever启动后，还要执行如下代码： /** * Await and shutdown. */ public void await() { getServer().await(); }查询await()方法的实现，将跟到or
TOMCAT运行时OOM解决
lazythinker的专栏
09-07 5997
统计分析系统因为内部系统，访问量不是太高，一直都是完成功能，没有对TOMCAT的配置关注过，直到最近发生了如下的报错： Exception in thread "http-bio-8080-Acceptor-0" java.lang.OutOfMemoryError: Java heap space Exception in thread "ContainerBackgroundPro
tomcat频繁死掉的问题
zaowei21的专栏
06-28 947
在网上找了些回答，以下是我觉得正确的回答：1.我想你的部分资源没有释放,积压卡死的2.连接池问题3.应该是服务器端响应request的线程的处理时间过长导致的全文阅读：http://www.javah.net/JSP_JSF/20070428/528.html
Tomcat流程图分析
技术人员
10-11 435
org.apache.catalina.startup.Bootstrap 启动类 synchronized (daemonLock) { if (daemon == null) { // Don't set daemon until init() has completed Bootstrap bootstrap = new Bootstrap(); try {
A Simple Web Server
陈文斌的专栏
11-22 584
The web server application consists of only three classes and is not fully functional. nevertheless, it serves as a good learning tool.
Tomcat关闭过程（Tomcat源码解析四）
jiaomingliang的专栏
08-10 4575
我们在Tomcat启动过程（Tomcat源代码阅读系列之三）一文中已经知道Tomcat启动以后，会启动6条线程，他们分别如下： "ajp-bio-8009-AsyncTimeout" daemon prio=5 tid=7f8738afe000 nid=0x115ad6000 waiting on condition [115ad5000] "ajp-bio-8009-Acceptor-0"
(转)Tomcat启动脚本catalina.sh
bluestar
04-10 1290
1 - 概述 脚本catalina.sh用于启动和关闭tomcat服务器，是最关键的脚本 另外的脚本startup.sh和shutdown.sh都是使用不同的参数调用了该脚本 该脚本的使用方法如下（引自该脚本本身）： echo "Usage: catalina.sh ( commands ... )" echo "commands:" echo " debug ...
tomcat源码系列(四)--关闭过程
one-programmer
11-19 659
Tomcat启动以后，会启动6条线程，他们分别如下： Tomcat threads"ajp-bio-8009-AsyncTimeout" daemon prio=5 tid=7f8738afe000 nid=0x115ad6000 waiting on condition [115ad5000]"ajp-bio-8009-Acceptor-0" daemon prio=5 tid=7f8738b05
MyBatis
最新发布
m0_74728220的博客
10-09 1035
<resource><includes><resource><includes>
Tomcat工作原理探索
"《how-tomcat-works中文版》是一本深入讲解Tomcat工作原理的书籍，由曹旭东于2011年5月26日编译。本书涵盖了Tomcat的基础知识，包括Web服务器的基本概念、servlet容器的工作机制、连接器(Connector)的实现、Tomcat...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值