`
hyw520110
  • 浏览: 218672 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

[How Tomcat Works]第1章 一个简单的Web服务器

    博客分类：
  • java
应用服务器WebTomcat浏览器Socket 
阅读更多

译者 jarfield

博客 http://jarfield.javaeye.com      

  1. 超文本传输协议（HTTP ）
  2. HTTP 请求
  3. HTTP 响应
  4. Socket 类
  5. ServerSocket 类
  6. 应用程序
    1. HttpServer 类
    2. Request 类
    3. Response 类
    4. 运行应用程序
  7. 总结

    本章解释了Java Web 服务器是如何工作的。Web 服务器又被称为超文本传输协议（Hypertext Transport  Protocol , HTTP ）服务器，因为它和客户端（通常是浏览器）使用HTTP 协议进行通信。基于Java 开发的Web 服务器都使用到两个重要的类 ：java.net.Socket 和 java.net.ServerSocket , 并通过HTTP 消息完成通信。因此，本章的开头就开始讨论HTTP 和这两个类。然后，继续介绍本章附带的应用程序。

超文本传输协议（HTTP ）

    HTTP 协议，允许Web 服务器和浏览器在Internet 上发送和接受数据。HTTP 是一种基于“请求-响应”模式的协议。客户端请求一个文件（file ），服务器针对该请求给出响应。HTTP 使用可靠的TCP 连接——默认端口是80 。HTTP的最初版本是HTTP/0.9 ，后来被HTTP/1.0 重写。HTTP/1.0 的替代者是当前的HTTP/1.1 。HTTP/1.1 定义在RFC 2612 中，可以从 http://www.w3.org/Protocols/HTTP/1.1/rfc2616.pdf 下载。


    提示：本节只是简短地介绍HTTP ，目的是帮助你理解Web 服务器发送的HTTP 消息。如果你想更深入得了解HTTP ，可以读读RFC 2616 。

    HTTP 的通信总是由客户端主动初始化：建立连接并发送HTTP 请求。Web 服务器从来不主动联系（contact ）客户端，或者建立到客户端的回调（callback ）连接。无论客户端还是服务器，都可以随时（prematurely ）中断连接。例如，当你在下载文件时，点击浏览器的“停止”按钮，就关闭了浏览器和服务器之间的HTTP 连接。

HTTP 请求

    HTTP 请求包含3 个组成部分：

  • Method-Uniform Resource Identifier (URI)-Protocol/Version
  • Request headers （请求头部）
  • Entity body （实体主体）

    下面是HTTP 请求的一个例子：

Html代码 复制代码
  1. POST /examples/default.jsp HTTP/1.1   
  2. Accept: text/plain; text/html   
  3. Accept-Language: en-gb   
  4. Connection: Keep-Alive   
  5. Host: localhost   
  6. User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)   
  7. Content-Length: 33   
  8. Content-Type: application/x-www-form-urlencoded   
  9. Accept-Encoding: gzip, deflate   
  10.   
  11. lastName=Franks&firstName=Michael    
    POST /examples/default.jsp HTTP/1.1
    Accept: text/plain; text/html
    Accept-Language: en-gb
    Connection: Keep-Alive
    Host: localhost
    User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)
    Content-Length: 33
    Content-Type: application/x-www-form-urlencoded
    Accept-Encoding: gzip, deflate
 
    lastName=Franks&firstName=Michael

 

    Method-URI-Protocol/Version 是请求的第一行

Html代码 复制代码
  1. POST /examples/default.jsp HTTP/1.1   
POST /examples/default.jsp HTTP/1.1

 

    POST 是Method ，/examples/default.jsp 是URI ，HTTP/1.1 就是Protocol/Version 。

    每个HTTP 请求都可以使用HTTP 标准中众多Method 中的一个。HTTP/1.1 共支持7 种Method : GET , POST , HEAD , OPTIONS , PUT , DELETE 和TRACE 。GET 和POST 是互联网应用使用最普遍的Method 。

     URI 标识了互联网上的资源。URI 的解析通常都是相对与服务器根目录的。因此，URI 总是从正斜线/ 开始。统一资源定位器（Uniform Resource Locator , URL ）实际上是一种URI （参见 http://www.ietf.org/rfc/rfc2396.txt ）。Protocol version 表示使用了哪个版本的HTTP 协议。

    Request header 包含了关于客户端环境和entity body的有用信息 。例如，headers 可能包括浏览器的语言，entity body 的长度等等。Header 之间通过回车/换行符（CRLF ）分隔。

    在headers 和entity body 之间，是一个空行（CRLF ）。这个CRLF 对于HTTP 请求内容的格式是相当重要的，它告诉HTTP 服务器：entify body 从哪开始。在一些介绍互联网编程的书中，该CRLF 被认为是HTTP 请求的第4 个组成部分。

    在前面的HTTP 请求中，entify body 仅仅只有这一行：

Html代码 复制代码
  1. lastName=Franks&firstName=Michael   
    lastName=Franks&firstName=Michael


    这里只是一个例子，实际的HTTP 请求中，entity body 当然可以更长一些。

HTTP 响应

    和HTTP请求一样，HTTP 响应也包含3 个组成部分：

  • Protocol—Status code—Description  
  • Response headers （响应头部）
  • Entity body （实体主体）

    下面是HTTP 响应的一个例子：

Html代码 复制代码
  1. HTTP/1.1 200 OK   
  2. Server: Microsoft-IIS/4.0   
  3. Date: Mon, 5 Jan 2004 13:13:33 GMT   
  4. Content-Type: text/html   
  5. Last-Modified: Mon, 5 Jan 2004 13:13:12 GMT   
  6. Content-Length: 112   
  7.   
  8. <html>  
  9. <head>  
  10. <title>HTTP Response Example</title>  
  11. </head>  
  12. <body>  
  13. Welcome to Brainy Software   
  14. </body>  
  15. </html>    
    HTTP/1.1 200 OK
    Server: Microsoft-IIS/4.0
    Date: Mon, 5 Jan 2004 13:13:33 GMT
    Content-Type: text/html
    Last-Modified: Mon, 5 Jan 2004 13:13:12 GMT
    Content-Length: 112
 
    <html>
    <head>
    <title>HTTP Response Example</title>
    </head>
    <body>
    Welcome to Brainy Software
    </body>
    </html>

 

    HTTP 响应的第一行类似于HTTP 请求的第一行。第一行告诉你：使用的HTTP 版本是HTTP/1.1 ，请求处理成功了（200 = 成功），一切运行正常。

    响应headers 和请求headers 类似，包含了很多有用的信息。响应数据中的entity body 是响应本身的HTML 内容。Headers 和entity body 之间通过CRLF 分隔。

Socket 类

    套接字是网络连接的一个端点（endpoint ）。应用程序使用套接字从网络上读取数据、向网络写入数据。两台不同机器上的应用，在同一个连接上以字节流的格式向（从）对方发送（接收）数据。 为了向一个应用发送消息，你需要知道该应用的IP 地址和端口。在Java 中，套接字用 java.net.Socket 类来表示。

    你可以使用 Socket 类众多构造函数中的一个来创建 套接字 对象。其中一个构造函数接收主机名和端口作为参数：

Java代码 复制代码
  1. public Socket (java.lang.String host, int port)  
public Socket (java.lang.String host, int port)


    其中，host 是远程机器的名称或IP 地址，port 是远程应用的端口号。例如，要连接上 yahoo.com 的80 端口，你可以创建下面的 Socket 对象：

Java代码 复制代码
  1. new Socket("yahoo.com", 80);   
new Socket("yahoo.com", 80);


    只要你成功创建了 Socket 的一个实例，就可以使用它发送和读取字节流。如果要发送字节流，你可以调用 Socket 类的 getOutputStream 方法获取一个 java.io.OutputStream 对象。如果要发送文本信息，你可以将上述 java.io.OutputStream 对象包装成一个 java.io.PrintWriter 对象。如果要读取字节流，你可以调用Socket 类的 getInputStream 方法获取一个 java.io.InputStream 对象

    下面的代码片段创建了一个能够与本地HTTP 服务器（127.0.0.1 表示本地主机）通信的 Socket 对象，发送了一个HTTP 请求，并 从服务器 接收了HTTP 响应。另外，这段代码还创建了一个 StringBuffer 对象来存储响应数据，并将其打印在控制台上。

Java代码 复制代码
  1. Socket socket = new Socket("127.0.0.1", "8080");   
  2. OutputStream os = socket.getOutputStream();   
  3. boolean autoflush = true;   
  4. PrintWriter out = new PrintWriter(socket.getOutputStream(), autoflush);   
  5. BufferedReader in = new BufferedReader(new InputStreamReader( socket.getInputstream() ));   
  6.   
  7. // send an HTTP request to the web server   
  8. out.println("GET /index.jsp HTTP/1.1");   
  9. out.println("Host: localhost:8080");   
  10.   
  11. out.println("Connection: Close");   
  12. out.println();   
  13.   
  14. // read the response   
  15. boolean loop = true;   
  16. StringBuffer sb = new StringBuffer(8096);   
  17. while (loop) {   
  18.   if ( in.ready() ) {   
  19.     int i=0;   
  20.     while (i!=-1) {   
  21.       i = in.read();   
  22.       sb.append((char) i);   
  23.     }   
  24.     loop = false;   
  25.   }   
  26.   Thread.currentThread().sleep(50);   
  27. }   
  28.   
  29. // display the response to the out console   
  30. System.out.println(sb.toString());   
  31. socket.close();  
    Socket socket = new Socket("127.0.0.1", "8080");
    OutputStream os = socket.getOutputStream();
    boolean autoflush = true;
    PrintWriter out = new PrintWriter(socket.getOutputStream(), autoflush);
    BufferedReader in = new BufferedReader(new InputStreamReader( socket.getInputstream() ));
 
    // send an HTTP request to the web server
    out.println("GET /index.jsp HTTP/1.1");
    out.println("Host: localhost:8080");
 
    out.println("Connection: Close");
    out.println();
 
    // read the response
    boolean loop = true;
    StringBuffer sb = new StringBuffer(8096);
    while (loop) {
      if ( in.ready() ) {
        int i=0;
        while (i!=-1) {
          i = in.read();
          sb.append((char) i);
        }
        loop = false;
      }
      Thread.currentThread().sleep(50);
    }
 
    // display the response to the out console
    System.out.println(sb.toString());
    socket.close();


    需要注意的是，为了从Web 服务器得到恰当的响应，你发送的HTTP 请求必须遵守HTTP 协议。如果你读了 前一节，超文本传输协议（HTTP ），应该就会理解上面代码中的HTTP 请求。

    提示：你可以使用本书源代码中的com.brainysoftware.pyrmont.util.HttpSniffer 类发送HTTP 请求和显示HTTP 响应。为了使用这个Java 程序，你必须连接到Internet 。不过，提醒一句，如果你在防火墙后面，那么这个类可能不能正常工作。

ServerSocket 类

    前面介绍的Socket 类，代表的是客户端套接字，即当你为了连接到远程服务程序而创建的 套接字 对象。现在，如果你想要实现一个服务器程序，比如HTTP 服务器或FTP 服务器，你需要一种不同的做法。因为，服务器程序必须一直驻守，它不知道客户端何时会连接过来。为了使你的程序能够驻守，你需要使用 java.net.ServerSocket 类。这是服务器端socket 的一个实现类。

    ServerSocket 类和 Socket 类并不相同。服务器套接字的职责是等待来自客户端的连接请求。当服务器套接字收到一个连接请求后，创建一个 Socket 对象来与客户端通信。 为了创建服务器套接字，你需要使用 ServerSocket 类提供的4 个构造函数之一。你需要指定服务器套接字将要监听的IP 地址和端口。通常，IP 地址是127.0.0.1 ，表示服务器套接字将监听本地机器。服务器套接字监听的IP 地址被称为绑定地址（binding address ）。服务器套接字的另一个重要属性是backlog ，服务器套接字有一个保存尚未处理的连接请求的队列，backlog 就是该队列的的最大长度。如果达到最大长度，服务器套接字将拒绝新的连接请求。

    下面是 ServerSocket 类的一个构造函数原型：

Java代码 复制代码
  1. public ServerSocket(int port, int backLog, InetAddress bindingAddress);   
public ServerSocket(int port, int backLog, InetAddress bindingAddress);


    注意这个构造函数，binding address 必须是一个 java.net.InetAddress 对象。创建 InetAddress 对象的一个简单方法就是调用该类的静态方法 getByName ，并把主机名作为 String 对象传给该方法，就像下面这样：

Java代码 复制代码
  1. InetAddress.getByName("127.0.0.1");   
InetAddress.getByName("127.0.0.1");


    下面这行代码创建了一个监听本地8080 端口的、backlog 为1 的ServerSocket 对象。

Java代码 复制代码
  1. new ServerSocket(8080, 1, InetAddress.getByName("127.0.0.1"));  
new ServerSocket(8080, 1, InetAddress.getByName("127.0.0.1"));

 

    有了ServerSocket 对象后，你就可以告诉它：在指定的端口上监听绑定地址的连接请求吧。告诉的办法就是调用 ServerSocket 的 accept 方法。当有一个连接请求到达时，该方法就会返回，返回值是一个 Socket 对象。这个Socket 对象就像 前一节， “Socket 类”，描述的那样，可以用来向（从）客户端发送（读取）数据。实际上，accept 方法也是本章应用程序唯一使用的（ ServerSocket 类的）方法。

应用程序

    本章的应用程序是一个Web服务器程序，放在 ex01.pyrmont 包中，由3 个类组成：

  • HttpServer
  • Request
  • Response  

    本章应用程序的入口（静态的 main 方法）在 HttpServer 类中。 main 方法创建了一个 HttpServer 对象，并调用了它的 await 方法。人如其名， await 方法在指定端口上等待HTTP 请求，然后处理HTTP 请求，最后将HTTP 响应发送回客户端。而且， await 方法保持等待，只有接收到 shutdown 命令，才退出运行。该应用只能发送静态资源，诸如特性目录下的HTTP 文件和图像文件。同时，还在控制台上显示HTTP 请求的字节流。然而，该应用不向浏览器发送任何header （date 、cookies 等）。

    下面各小节，我们将会看一看这3 个类。

HttpServer 类

    HttpServer 类表示了一个Web 服务器，代码在 Listing 1.1 中。需要注意的是，为了节省篇幅，await 方法没被列在 Listing 1.1 中，可以在 Listing 1.2 中找到。

Listing 1.1: The HttpServer class    

Java代码 复制代码
  1. package ex01.pyrmont;   
  2.     
  3. import java.net.Socket;   
  4. import java.net.ServerSocket;   
  5. import java.net.InetAddress;   
  6. import java.io.InputStream;   
  7. import java.io.OutputStream;   
  8. import java.io.IOException;   
  9. import java.io.File;   
  10.     
  11. public class HttpServer {   
  12.     
  13.   /** WEB_ROOT is the directory where our HTML and other files reside.  
  14.    *  For this package, WEB_ROOT is the "webroot" directory under the  
  15.    *  working directory.  
  16.    *  The working directory is the location in the file system  
  17.    *  from where the java command was invoked.  
  18.    */  
  19.   public static final String WEB_ROOT =   
  20.     System.getProperty("user.dir") + File.separator  + "webroot";   
  21.     
  22.   // shutdown command   
  23.   private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";   
  24.     
  25.   // the shutdown command received   
  26.   private boolean shutdown = false;   
  27.     
  28.   public static void main(String[] args) {   
  29.     HttpServer server = new HttpServer();     
  30.     server.await();   
  31.   }   
  32.     
  33.   public void await() {   
  34.     ...   
  35.   }   
  36. }   
package ex01.pyrmont;
 
import java.net.Socket;
import java.net.ServerSocket;
import java.net.InetAddress;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.File;
 
public class HttpServer {
 
  /** WEB_ROOT is the directory where our HTML and other files reside.
   *  For this package, WEB_ROOT is the "webroot" directory under the
   *  working directory.
   *  The working directory is the location in the file system
   *  from where the java command was invoked.
   */
  public static final String WEB_ROOT =
    System.getProperty("user.dir") + File.separator  + "webroot";
 
  // shutdown command
  private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
 
  // the shutdown command received
  private boolean shutdown = false;
 
  public static void main(String[] args) {
    HttpServer server = new HttpServer();  
    server.await();
  }
 
  public void await() {
    ...
  }
}

 
Listing 1.2: The HttpServer class's await method

Java代码 复制代码
  1. public void await() {   
  2.   ServerSocket serverSocket = null;   
  3.   int port = 8080;   
  4.   try {   
  5.     serverSocket =  new ServerSocket(port, 1,   
  6.       InetAddress.getByName("127.0.0.1"));   
  7.   }   
  8.   catch (IOException e) {   
  9.     e.printStackTrace();   
  10.     System.exit(1);   
  11.   }   
  12.   // Loop waiting for a request   
  13.   while (!shutdown) {   
  14.     Socket socket = null;   
  15.     InputStream input = null;   
  16.     OutputStream output = null;   
  17.     
  18.     try {   
  19.       socket = serverSocket.accept();   
  20.       input = socket.getInputStream();   
  21.       output = socket.getOutputStream();   
  22.       // create Request object and parse   
  23.       Request request = new Request(input);   
  24.       request.parse();   
  25.     
  26.       // create Response object   
  27.       Response response = new Response(output);   
  28.       response.setRequest(request);   
  29.       response.sendStaticResource();   
  30.     
  31.       // Close the socket   
  32.       socket.close();     
  33.       //check if the previous URI is a shutdown command   
  34.       shutdown = request.getUri().equals(SHUTDOWN_COMMAND);   
  35.     }   
  36.     catch (Exception e) {   
  37.       e.printStackTrace ();   
  38.       continue;   
  39.     }   
  40.   }   
  41. }  
public void await() {
  ServerSocket serverSocket = null;
  int port = 8080;
  try {
    serverSocket =  new ServerSocket(port, 1,
      InetAddress.getByName("127.0.0.1"));
  }
  catch (IOException e) {
    e.printStackTrace();
    System.exit(1);
  }
  // Loop waiting for a request
  while (!shutdown) {
    Socket socket = null;
    InputStream input = null;
    OutputStream output = null;
 
    try {
      socket = serverSocket.accept();
      input = socket.getInputStream();
      output = socket.getOutputStream();
      // create Request object and parse
      Request request = new Request(input);
      request.parse();
 
      // create Response object
      Response response = new Response(output);
      response.setRequest(request);
      response.sendStaticResource();
 
      // Close the socket
      socket.close();  
      //check if the previous URI is a shutdown command
      shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
    }
    catch (Exception e) {
      e.printStackTrace ();
      continue;
    }
  }
}

 

    这个Web 服务器可以提供静态资源服务，可访问的资源位于 public static final WEB_ROOT 表示的 目录及子目录下。WEB_ROOT 是这样初始化的：

Java代码 复制代码
  1. public static final String WEB_ROOT =  System.getProperty("user.dir") + File.separator + "webroot";  
public static final String WEB_ROOT =  System.getProperty("user.dir") + File.separator + "webroot";


    这段代码中有一个名为webroot 的目录，该目录包含了可以用于测试该应用的的静态资源。你还可以从该目录下找到几个用于测试下一章应用的servlet 。

    如果要请求一个静态资源，你可以在浏览器的地址栏中敲入以下URL ：

Html代码 复制代码
  1. http://machineName:port/staticResource   
    http://machineName:port/staticResource


    如果你从另一台机器上发送请求， machineName 应该是该应用所在机器的主机名或IP 地址。如果你的浏览器运行在同一台机器上，可以使用 localhost 作为 machineName 。端口是8080 ， staticResource 是被请求的文件（静态资源）名，该文件必须位于 WEB_ROOT 下。

    例如，你在同一台机器上测试该应用，想让HttpServer 发送文件index.html ，你可以使用下面的URL ：  

    如果要停止服务器，你可以通过特定的URL从浏览器发送shutdown命令：host:port的后面加上预先定义的、表示shutdown的字符串即可。 HttpServer 类的静态常量 SHUTDOWN 定义了 shutdown命令：

Java代码 复制代码
  1. private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";  
private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";


    因此，如果要停止服务器，你可以使用下面的URL ：

Html代码 复制代码
  1. http://localhost:8080/SHUTDOWN   
    http://localhost:8080/SHUTDOWN


    现在，我们看一看 Listing 1.2 中的await 方法。
   
    方法名使用await 而不用wait ，是因为wait 是java.lang.Object 类中一个重要的、与多线程紧密相关的方法。

    await 方法首先创建了一个ServerSocket 对象，然后进入一个 while 循环。

Java代码 复制代码
  1. serverSocket =  new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));   
  2. ...   
  3. // Loop waiting for a request   
  4.   
  5. while (!shutdown) {   
  6.   ...   
  7. }  
    serverSocket =  new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
    ...
    // Loop waiting for a request
 
    while (!shutdown) {
      ...
    }


    while 循环中的代码运行到 ServerSocket 的 accept 方法就停止下来，直到在8080 端口上收到HTTP 请求才返回：

Java代码 复制代码
  1. socket = serverSocket.accept();  
socket = serverSocket.accept();

 

    收到一个请求后， await 方法从 accept 方法返回的 Socket 对象中获取了 java.io.InputStream 对象和 java.io.OutputStream 对象。

Java代码 复制代码
  1. input = socket.getInputStream();   
  2. output = socket.getOutputStream();   
input = socket.getInputStream();
output = socket.getOutputStream();

 

    await 方法然后创建了一个 ex01.pyrmont.Request 对象，并调用它的 parse 方法来解析HTTP请求的原始数据（raw data ）。

Java代码 复制代码
  1. // create Request object and parse   
  2. Request request = new Request(input);   
  3. request.parse ();   
    // create Request object and parse
    Request request = new Request(input);
    request.parse ();


    之后， await 方法创建了一个 Response 对象，将上面的 Request 对象设置成 Response 对象的成员，并调用 Response 对象的 sendStaticResponse 方法。

Java代码 复制代码
  1. // create Response object   
  2.  Response response = new Response(output);   
  3.  response.setRequest(request);   
  4.  response.sendStaticResource();  
   // create Response object
    Response response = new Response(output);
    response.setRequest(request);
    response.sendStaticResource();

 

    最后， await 方法关闭了 Socket 对象，并调用了 Request 对象的 getUri 方法，检查本次HTTP 请求的URI 似乎否是shutdown 命令。如果是（shutdown 命令）的话， shutdown 变量会被设置成 true ，从而程序将退出 while 循环。

Java代码 复制代码
  1. // Close the socket   
  2. socket.close ();   
  3.   
  4. //check if the previous URI is a shutdown command   
  5. shutdown = request.getUri().equals(SHUTDOWN_COMMAND);   
    // Close the socket
    socket

  


  

    
    
分享到：
      
      
    

  


  

    

      
      |
      240个JQuery插件
    

  

  

        
  

    
  

    
评论

    
    
    
    
  


  

    
发表评论

            
   您还没有登录,请您登录后再发表评论

相关推荐

    WEB服务器工作机制由浅至深(2):【How Tomcat Works】1~4章翻译分析

    本篇文章将深入探讨Tomcat，一个广泛使用的Java Web服务器，通过翻译分析"How Tomcat Works"一书的前四章内容，来理解其工作机制。 首先，我们要了解Tomcat的基本架构。Tomcat是Apache软件基金会的Jakarta项目中的...

    译How Tomcat Works(第二章)

    《译How Tomcat Works(第二章)》这篇文章主要讲解了Apache Tomcat服务器的工作原理，它是一个开源的Java Servlet容器，广泛用于部署Web应用程序。在这一章中，我们将深入探讨Tomcat如何处理HTTP请求，以及其内部架构...

    HowTomcatWorks(书和源码)

    《How Tomcat Works》是...总的来说，《How Tomcat Works》是学习和理解Tomcat内部运作机制的重要资源，配合源码分析，能帮助开发者提升对Java Web服务器的理解和应用能力，从而更好地设计和优化高性能的Web应用程序。

    How Tomcat Works 读书笔记(第三章)

    《How Tomcat Works》这本书是理解Apache Tomcat服务器工作原理的重要资源，第三章主要探讨了Tomcat的架构和核心组件。以下是对这部分内容的详细解读： Tomcat作为一款开源的Java Servlet容器，其核心功能是解析...

    how tomcat works

    Apache Tomcat是一个开源的Java Servlet容器，它实现了Java Servlet和JavaServer Pages技术规范，提供了Java Web服务器的功能。对于Java Web开发者，尤其是那些希望深入了解Web容器工作原理的学习者而言，这本书是一...

    译How Tomcat Works(第一章)

    《译How Tomcat Works(第一章)》这篇文章是关于Apache Tomcat服务器的工作原理的翻译，它主要探讨了Tomcat如何处理HTTP请求以及内部架构的关键组成部分。Tomcat是一款开源的Java Servlet容器，广泛用于部署Java Web...

    WEB服务器工作机制由浅至深(3):【How Tomcat Works】7~9章翻译分析

    本篇文章将深入探讨Tomcat的工作机制，基于《How Tomcat Works》一书的第7至9章进行翻译和分析。 第7章主要讲解了Tomcat的启动过程和服务器的配置。Tomcat启动时，首先读取主配置文件`server.xml`，这个文件定义了...

    WEB服务器工作机制由浅至深(6):【How Tomcat Works】第12章StandardContext翻译分析

    通过阅读和分析《How Tomcat Works》的第12章，我们可以更深入地了解Tomcat如何处理请求，管理Web应用，并为开发者提供一个强大的平台来构建和运行Java Web应用程序。这有助于我们更好地利用Tomcat的特性，提高应用...

    WEB服务器工作机制由浅至深(8):【How Tomcat Works】第14章Server和Service

    《WEB服务器工作机制由浅至深(8):【How Tomcat Works】第14章Server和Service》 在深入探讨Web服务器的工作机制时，Tomcat作为Apache软件基金会的开源Java Servlet容器，扮演着至关重要的角色。本章将聚焦于Tomcat...

    WEB服务器工作机制由浅至深(5):【How Tomcat Works】第11章StandardWrapper翻译分析

    通过对《How Tomcat Works》一书第11章的翻译与分析，我们将揭示StandardWrapper如何工作，以及它对整个Web应用的影响。 首先，我们需要了解Servlet的生命周期。Servlet在Web应用中扮演着动态处理请求的角色，它们...

    译How Tomcat Works（第四章）

    《译How Tomcat Works（第四章）》这篇文章深入解析了Apache Tomcat服务器的工作原理，主要聚焦于Tomcat的内部机制，对于理解Web应用容器的运行方式具有重要意义。Tomcat是Java Servlet和JavaServer Pages（JSP）...

    WEB服务器工作机制由浅至深(4):【How Tomcat Works】第10章翻译分析及Tomcat安全性探讨

    在《How Tomcat Works》一书中，第10章主要介绍了Tomcat的内部工作流程。Tomcat接收到HTTP请求后，首先会通过网络层处理数据包，然后进入服务层解析请求。这一阶段涉及到解码URL、解析请求头和提取参数等步骤。接着...

    WEB服务器工作机制由浅至深(3):【How Tomcat Works】5~6章翻译分析

    本文将深入探讨Tomcat的工作机制，基于"How Tomcat Works"的第五章和第六章进行翻译和分析。 第五章主要讨论了Tomcat的生命周期管理和容器概念。在Tomcat中，每个应用都有一个对应的Context，它管理Servlet的加载、...

    WEB服务器工作机制由浅至深(9):【How Tomcat Works】第16章关闭钩子以及之后的章节简述

    【WEB服务器工作机制由浅至深(9):【How Tomcat Works】第16章 关闭钩子以及之后的章节简述】 在深入探讨Tomcat服务器的工作机制时，我们来到了第16章，这一章主要讨论了“关闭钩子”（Shutdown Hooks）的概念及其在...

    译How Tomcat Works(第三章)

    《译How Tomcat Works(第三章)》这篇文章深入解析了Apache Tomcat服务器的工作原理，Tomcat作为开源的Java Servlet容器，是许多Web应用程序的基础。在本章中，我们将聚焦于Tomcat如何处理HTTP请求，以及它如何加载和...

    howtomcatworks tomcat运行内幕

    本篇文章将深入剖析"HowTomcatWorks"，帮助读者全面理解Tomcat的内部工作机制。 1. **Tomcat架构概述** Tomcat由一系列组件构成，包括Catalina（核心Servlet容器）、Jasper（JSP引擎）、 Coyote（HTTP/HTTPS连接器...

    WEB服务器工作机制由浅至深(7):【How Tomcat Works】第13章Host和Engine

    Tomcat的源码是开放的，这对于开发者来说是一个宝贵的资源，可以学习到如何设计和实现一个高性能的WEB服务器。同时，工具如JMX（Java Management Extensions）可以帮助监控和管理Tomcat的运行状态，包括Engine、Host...

Magicbox
Global site tag (gtag.js) - Google Analytics