脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Tomcat底层机制和Servlet运行原理

JavaWeb中Tomcat底层机制和Servlet运行原理详解

 更新时间：2023年10月17日 09:55:08   作者：边境矢梦°  
这篇文章主要介绍了JavaWeb中Tomcat底层机制和Servlet运行原理详解,Tomcat是一个开源的Java Web服务器,它是基于Java Servlet和JavaServer Pages(JSP)技术的,下面是关于Tomcat底层机制和Servlet运行原理的简要说明,需要的朋友可以参考下

一. 一图明理

二. 概念

Tomcat是一个开源的Java Web服务器，它是基于Java Servlet和JavaServer Pages（JSP）技术的。下面是关于Tomcat底层机制和Servlet运行原理的简要说明：

  • Tomcat底层机制：
    • 网络通信：Tomcat使用Java的Socket API来监听特定的端口（通常是8080），接收来自客户端的HTTP请求。
    • 线程池：Tomcat使用线程池来处理并发的请求。当有新的请求到达时，Tomcat会从线程池中获取一个空闲线程来处理该请求，这样可以提高处理效率。
    • 生命周期管理：Tomcat负责管理Servlet和其他Web组件的生命周期，包括初始化、请求处理和销毁等阶段。(init(), run())
    • 请求处理管道：Tomcat通过请求处理管道来处理HTTP请求。请求经过一系列的处理器，如身份验证、日志记录和安全检查等，最终被交给适当的Servlet进行处理。(handle())
    • 连接池：Tomcat使用连接池来管理与数据库的连接。这样可以提高性能，并避免频繁地创建和销毁数据库连接。(handle())
  • Servlet运行原理：
    • Servlet容器：Tomcat是一个Servlet容器，它负责加载、初始化和管理Servlet。当Tomcat启动时，它会读取配置文件（如web.xml）来确定需要加载的Servlet类。
    • 生命周期：每个Servlet都有自己的生命周期，包括初始化、请求处理和销毁等阶段。Tomcat会在适当的时间调用Servlet的生命周期方法（如init()、service()和destroy()）。
    • 请求处理：当Tomcat接收到HTTP请求时，它会根据请求的URL找到对应的Servlet，并将请求转发给该Servlet进行处理。Servlet通过HttpServletRequest对象获取请求的信息，并通过HttpServletResponse对象发送响应给客户端。
    • 多线程处理：Tomcat使用多线程来处理并发请求。每个请求都被分配给一个独立的线程进行处理，这样可以同时处理多个请求，提高服务器的性能。

三. 容器的理解

在tomcat底层实现中, servlet作为容器, 实现可以理解为HashMap, 键是servlet-name值是servlet-class, 而HashMap就是一个容器, 从容器中得到一个servlet实例, 对其进行初始化, 供web使用, 调用其中的service()方法, service()方法对HTTP请求的method进行判断, 对每个相应的method都有相应的do方法, 可以使用.

四. 案例

不用tomcat以及servlet实现

五. 代码分析和代码实现

LxbRequestHandle类

package com.lxb.tomcat.handle;
//-*- code = utf-8 -*-
//@Time : 2023-07-20 13:22:00
//@Authors : 罗雄波
//@File : LxbRequestHandle.java
//@Software : IntelliJ IDEA
 
import com.lxb.tomcat.LxbTomcatV3;
import com.lxb.tomcat.http.LxbHttpRequest;
import com.lxb.tomcat.http.LxbHttpResponse;
import com.lxb.tomcat.servlet.LxbHttpServlet;
import com.lxb.tomcat.utils.WebUtils;
 
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
 
public class LxbRequestHandle implements Runnable{
    private Socket accept;
 
    public LxbRequestHandle(Socket socket) {
        this.accept = socket;
    }
 
    public void run() {
        try {
            LxbHttpRequest request = new LxbHttpRequest(accept);
            LxbHttpResponse response = new LxbHttpResponse(accept.getOutputStream());
 
            String uri = request.getUri();
            if(WebUtils.isHtml(uri)) {
                System.out.println(uri.substring(1));
                String resp = WebUtils.readFile(uri.substring(1));
                String responseInfo = LxbHttpResponse.respHeader + resp;
 
                OutputStream outputStream = response.getOutputStream();
                outputStream.write(responseInfo.getBytes());
 
                outputStream.flush();
                outputStream.close();
                accept.close();
                return;
            }
 
 
            String servletName = LxbTomcatV3.servletMapping.get(uri);
            if(servletName == null) {
                servletName = "";
            }
 
            LxbHttpServlet servlet = LxbTomcatV3.servlet.get(servletName);
 
            if(servlet != null) {
                servlet.service(request, response);
            } else {
                String resp = LxbHttpResponse.respHeader + "<h1>404 not found!!!</h>";
                OutputStream responseOutputStream = response.getOutputStream();
                responseOutputStream.write(resp.getBytes());
                responseOutputStream.flush();
                responseOutputStream.close();
            }
 
            accept.close();
 
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (accept != null) {
                try {
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

LxbHttpRequest和LxbHttpResponse

package com.lxb.tomcat.http;
//-*- code = utf-8 -*-
//@Time : 2023-07-20 14:59:24
//@Authors : 罗雄波
//@File : LxbHttpRequest.java
//@Software : IntelliJ IDEA
 
 
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.HashMap;
 
public class LxbHttpRequest {
    private Socket socket;
    private String method;
    private String uri;
    private HashMap<String, String> parameterMapping = new HashMap<String, String>();
 
    public LxbHttpRequest(Socket socket) {
        this.socket = socket;
        try {
            ParseProcess();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
 
    public void ParseProcess() throws Exception {
        BufferedReader reader =
                new BufferedReader(new InputStreamReader(socket.getInputStream(), "utf-8"));
 
        String temp;
 
        temp = reader.readLine();
 
//        GET /cal.html HTTP/1.1
        String[] request = temp.split(" ");
        method = request[0];
        int index = request[1].indexOf("?");
 
        if (index == -1) {
            uri = request[1];
        } else {
            uri = request[1].substring(0, index);
 
            String parameterPair = request[1].substring(index + 1);
            String[] parameters = parameterPair.split("&");
 
            if (parameters[0] != null && !parameters[0].equals("")) {
                for (String parameter : parameters) {
                    String[] split = parameter.split("=");
 
                    if(split.length == 2) {
                        parameterMapping.put(split[0], split[1]);
                    }
                }
            }
        }
    }
 
    public String getMethod() {
        return method;
    }
 
    public String getUri() {
        return uri;
    }
 
    public String getParameter(String key) {
        if(parameterMapping.get(key) != null) {
            return parameterMapping.get(key);
        } else {
            return "";
        }
    }
 
    @Override
    public String toString() {
        return "LxbHttpRequest" +
                "{ method = " + method +
                ", uri = " +  uri +
                ", parameter = " + parameterMapping +
                "}";
    }
}
package com.lxb.tomcat.http;
//-*- code = utf-8 -*-
//@Time : 2023-07-20 15:49:29
//@Authors : 罗雄波
//@File : LxbHttpResponse.java
//@Software : IntelliJ IDEA
 
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
 
public class LxbHttpResponse {
    private OutputStream outputStream = null;
    public static final String respHeader = "HTTP/1.1 200 OK\r\n" +
            "Content-Type: text/html;charset=utf-8\r\n\r\n";
    public LxbHttpResponse(OutputStream outputStream) {
        this.outputStream = outputStream;
    }
 
    public OutputStream getOutputStream() {
        return outputStream;
    }
}

LxbTomcat

package com.lxb.tomcat;
//-*- code = utf-8 -*-
//@Time : 2023-07-20 15:37:29
//@Authors : 罗雄波
//@File : LxbTomcatV3.java
//@Software : IntelliJ IDEA
 
import com.lxb.tomcat.handle.LxbRequestHandle;
import com.lxb.tomcat.servlet.LxbHttpServlet;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.junit.Test;
 
import java.io.File;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
 
public class LxbTomcatV3 {
    public static ConcurrentHashMap<String, LxbHttpServlet> servlet =
            new ConcurrentHashMap<String, LxbHttpServlet>();
 
    public static ConcurrentHashMap<String, String> servletMapping =
            new ConcurrentHashMap<String, String>();
 
    public static void main(String[] args) throws Exception {
        LxbTomcatV3 lxbTomcatV3 = new LxbTomcatV3();
        lxbTomcatV3.Init();
        lxbTomcatV3.run();
    }
 
    public void run() {
        try {
            ServerSocket socket = new ServerSocket(8080);
            while (!socket.isClosed()) {
                Socket accept = socket.accept();
 
                LxbRequestHandle requestHandle = new LxbRequestHandle(accept);
 
                new Thread(requestHandle).start();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
 
    @Test
    public void Init() {
        String path = LxbTomcatV3.class.getResource("/").getPath();
//        System.out.println(path);
//   该类的路径 /D:/NewExecllction/exicese%20code/lxb-tomcat/target/classes/com/lxb/tomcat/
//   根路径    /D:/NewExecllction/exicese%20code/lxb-tomcat/target/classes/
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(new File(path + "web.xml"));
//            System.out.println(document);
 
            Element rootElement = document.getRootElement();
            List<Element> elements = rootElement.elements();
            for (Element element : elements) {
                if ("servlet".equalsIgnoreCase(element.getName())) {
                    Element servletName = element.element("servlet-name");
                    Element servletClass = element.element("servlet-class");
                    servlet.put(servletName.getText(), (LxbHttpServlet) Class.forName(servletClass.getText().trim()).newInstance());
                } else if ("servlet-mapping".equalsIgnoreCase(element.getName())) {
                    Element servletName = element.element("servlet-name");
                    Element servletUrl = element.element("url-pattern");
                    servletMapping.put(servletUrl.getText(), servletName.getText());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        System.out.println(servlet);
        System.out.println(servletMapping);
    }
 
    @Test
    public void test() {
        String path = LxbTomcatV3.class.getResource("/").getPath();
        System.out.println(path + "web.xml");
    }
}

WebUtils

package com.lxb.tomcat.utils;
//-*- code = utf-8 -*-
//@Time : 2023-07-19 16:00:33
//@Authors : 罗雄波
//@File : WebUtils.java
//@Software : IntelliJ IDEA
 
import org.junit.Test;
 
import java.io.*;
 
public class WebUtils {
    public static int parseInt(String strNum, int defaultVal) {
        try {
            return Integer.parseInt(strNum);
        } catch (NumberFormatException e) {
            System.out.println(strNum + "数字格式异常, 无法包装");
        }
        return defaultVal;
    }
 
    public static boolean isHtml(String uri) {
        return uri.endsWith(".html");
    }
 
    public static String readFile(String filename) {
        String path = com.lxb.tomcat.utils.WebUtils.class.getResource("/").getPath();
        StringBuilder stringBuffer = new StringBuilder();
 
        try {
            System.out.println(path + filename);
            BufferedReader bufferedReader = new BufferedReader(new FileReader(path + filename));
            String buffer = null;
            while ((buffer = bufferedReader.readLine()) != null && !buffer.equals("")) {
                stringBuffer.append(buffer);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return stringBuffer.toString();
    }
}

LxbCalServlet

package com.lxb.tomcat.servlet;
//-*- code = utf-8 -*-
//@Time : 2023-07-20 16:14:24
//@Authors : 罗雄波
//@File : LxbCalServlet.java
//@Software : IntelliJ IDEA
 
import com.lxb.tomcat.http.LxbHttpRequest;
import com.lxb.tomcat.http.LxbHttpResponse;
import com.lxb.tomcat.utils.WebUtils;
 
import java.io.IOException;
import java.io.OutputStream;
 
public class LxbCalServlet extends LxbHttpServlet {
    @Override
    public void doGet(LxbHttpRequest request, LxbHttpResponse response) {
        doPost(request, response);
    }
 
    @Override
    public void doPost(LxbHttpRequest request, LxbHttpResponse response) {
        int num1 = WebUtils.parseInt(request.getParameter("num1"), 0);
        int num2 = WebUtils.parseInt(request.getParameter("num2"), 0);
 
        int result = num1 + num2;
 
        OutputStream outputStream = response.getOutputStream();
 
        String resp = LxbHttpResponse.respHeader + "<h1>求和: " + num1 + "+" + num2 + " = " + result + "</h>";
 
        try {
            outputStream.write(resp.getBytes());
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
 
    public void init() throws Exception {
 
    }
 
    public void destroy() {
 
    }
}

LxbServlet

package com.lxb.tomcat.servlet;
//-*- code = utf-8 -*-
//@Time : 2023-07-20 16:09:43
//@Authors : 罗雄波
//@File : LxbServlet.java
//@Software : IntelliJ IDEA
 
import com.lxb.tomcat.http.LxbHttpRequest;
import com.lxb.tomcat.http.LxbHttpResponse;
 
import java.io.IOException;
 
public interface LxbServlet {
    void init() throws Exception;
 
    void service(LxbHttpRequest request, LxbHttpResponse response) throws IOException;
 
    void destroy();
}

LxbHttpServlet

package com.lxb.tomcat.servlet;
//-*- code = utf-8 -*-
//@Time : 2023-07-20 16:11:02
//@Authors : 罗雄波
//@File : lxbHttpServlet.java
//@Software : IntelliJ IDEA
 
import com.lxb.tomcat.http.LxbHttpRequest;
import com.lxb.tomcat.http.LxbHttpResponse;
 
import java.io.IOException;
 
public abstract class LxbHttpServlet implements LxbServlet{
    public void service(LxbHttpRequest request, LxbHttpResponse response) throws IOException {
        if(request.getMethod().equals("GET")) {
            this.doGet(request, response);
        } else if(request.getMethod().equals("POST")) {
            this.doPost(request, response);
        }
    }
 
    public void doGet(LxbHttpRequest request, LxbHttpResponse response) {
 
    }
    public void doPost(LxbHttpRequest request, LxbHttpResponse response) {
 
    }
}

六. 注意

到此这篇关于JavaWeb中Tomcat底层机制和Servlet运行原理详解的文章就介绍到这了,更多相关Tomcat底层机制和Servlet运行原理内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • SpringBoot自定义注解验证枚举的实现

    SpringBoot自定义注解验证枚举的实现

    本文主要介绍了SpringBoot自定义注解验证枚举的实现,数据校验,需要对枚举类型的数据传参,进行数据校验,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2024-01-01
  • java使用dbcp2数据库连接池

    java使用dbcp2数据库连接池

    这篇文章主要为大家详细介绍了java使用dbcp2数据库连接池的相关资料,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2016-10-10
  • SpringBoot LocalDateTime格式转换方案详解(前端入参)

    SpringBoot LocalDateTime格式转换方案详解(前端入参)

    这篇文章主要介绍了SpringBoot LocalDateTime格式转换(前端入参),本文用示例介绍SpringBoot全局格式配置，将前端传过来的时间自动转化为LocalDateTime,需要的朋友可以参考下
    2023-04-04
  • Tomcat+JDK安装和配置教程

    Tomcat+JDK安装和配置教程

    这篇文章主要为大家详细介绍了Tomcat+JDK安装和配置教程，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2017-03-03
  • springboot整合Shiro的步骤

    springboot整合Shiro的步骤

    这篇文章主要介绍了springboot整合Shiro的步骤，帮助大家更好的理解和使用springboot框架，感兴趣的朋友可以了解下
    2021-01-01
  • Java代理模式实例分析

    Java代理模式实例分析

    这篇文章主要介绍了Java代理模式,结合实例形式对比分析了java代理模式的使用方法与相关操作技巧,需要的朋友可以参考下
    2019-07-07
  • 实例讲述Java IO文件复制

    实例讲述Java IO文件复制

    本篇文章通过实例给大家详细讲述Java IO文件复制的相关知识点，需要的读者们学习下吧。
    2018-02-02
  • java开发主流定时任务解决方案全横评详解

    java开发主流定时任务解决方案全横评详解

    这篇文章主要为大家介绍了java开发主流定时任务解决方案全横评详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-09-09
  • Java 处理树形结构数据的过程

    Java 处理树形结构数据的过程

    这篇文章主要介绍了Java 处理树形结构数据的过程，本文给大家分析具体实现过程，结合实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2022-08-08
  • Java Spring Boot消息服务万字详解分析

    Java Spring Boot消息服务万字详解分析

    在实际项目开发中，有时需要与其他系统进行集成完成相关业务功能，这种情况最原始做法是程序内部相互调用，除此之外，还可以用消息服务中间件进行业务处理，用消息服务中间件处理业务能够提升系统的异步通信和扩展解耦能力。Spring Boot对消息服务管理提供了非常好的支持
    2021-10-10

最新评论