手动实现 Tomcat 底层机制+自己设计 Servlet

已于 2023-03-09 09:22:41 修改
阅读量546 收藏 1
点赞数 1
分类专栏： javaWeb 文章标签： tomcat java 开发语言
于 2022-03-12 15:34:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44981526/article/details/123444668
版权

手动实现 Tomcat 底层机制+自己设计 Servlet

1.Tomcat 整体架构分析

●说明: Tomcat 有三种运行模式（BIO, NIO, APR）, 这里主要说明Tomcat 如何接收客户端请求，解析请求, 调用 Servlet , 并返回结果的机制流程, 采用 BIO 线程模型来模拟.[绘图]

image-20220308210120313

2.实现任务阶段 1- 编写自己 Tomcat, 能给浏览器返回 hi llp,你好tomcat

1.基于 socket 开发服务端-流程

image-20220308220845668

2.需求分析/图解

需求分析如图, 浏览器请求 http://localhost:8080/??, 服务端返回 hi llp,你好tomcat

image-20220308221024682

3.分析+代码实现

客户端（浏览器）请求tomcat，建立socket链接；服务端处理请求并响应给服务端。

image-20220308221052813

tcp协议的数据没有封装成http协议的格式就返回给浏览器会出现解析问题，火狐支持直接解析

public class TomcatV1 {
    public static void main(String[] args) throws IOException {

        //1. 创建ServerSocket, 在 8080端口监听
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("=======mytomcat在8080端口监听======");
        while (!serverSocket.isClosed()) {

            //等待浏览器/客户端的连接
            //如果有连接来，就创建一个socket
            //这个socket就是服务端和浏览器端的连接/通道
            Socket socket = serverSocket.accept();

            //先接收浏览器发送的数据
            //inputStream 是字节流=> BufferedReader(字符流)
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader =
                    new BufferedReader(new InputStreamReader(inputStream, "utf-8"));

            String mes = null;
            System.out.println("=======接收到浏览器发送的数据=======");
            //循环的读取
            while ((mes = bufferedReader.readLine()) != null) {
                //判断mes的长度是否为0，不做判断当读取到的数据长度为0时无法退出循环
                if (mes.length() == 0) {
                    break;//退出while
                }
                System.out.println(mes);
            }

            //我们的tomcat会送-http响应方式
            OutputStream outputStream = socket.getOutputStream();
            //构建一个http响应的头
            //\r\n 表示换行
            //http响应体，需要前面有两个换行 \r\n\r\n
            String respHeader = "HTTP/1.1 200 OK\r\n" +
                    "Content-Type: text/html;charset=utf-8\r\n\r\n";
            String resp = respHeader + "hi, llp";

            System.out.println("========我们的tomcat 给浏览器会送的数据======");
            System.out.println(resp);

            outputStream.write(resp.getBytes());//将resp字符串以byte[] 方式返回

            outputStream.flush();
            outputStream.close();
            //关闭外层流即可关闭底层流
            bufferedReader.close();
            socket.close();
        }
    }
}

image-20230309091100791

3.实现任务阶段 2- 使用 BIO 线程模型，支持多线程

1.BIO 线程模型介绍

image-20220309223210400

2.需求分析/图解

需求分析如图, 浏览器请求 http://localhost:8080, 服务端返回 hi , 孙悟空~, 后台tomcat 使用 BIO 线程模型,支持多线程=> 对前面的开发模式进行改造

image-20220309223424040

3.分析+代码实现

TomcatV2

public class TomcatV2 {
    public static void main(String[] args) throws IOException {
        //在8080端口监听
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("=======tomcatV2 在8080监听=======");
        //只要 serverSocket没有关闭，就一直等待浏览器/客户端的连接
        while (!serverSocket.isClosed()) {
            //1. 接收到浏览器的连接后，如果成功，就会得到socket
            //2. 这个socket 就是 服务器和 浏览器的数据通道
            Socket socket = serverSocket.accept();
            //3. 创建一个线程对象，并且把socket给该线程
            RequestHandler requestHandler =
                    new RequestHandler(socket);
            new Thread(requestHandler).start();

        }
    }
}

RequestHandler线程对象

public class RequestHandler implements Runnable{
    private Socket socket;
    public RequestHandler(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        InputStream inputStream = null;
        try {
            inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String readLine = null;
            System.out.println("请求部分： "+Thread.currentThread().getName()+"-"+Thread.currentThread().hashCode());
            while ((readLine = bufferedReader.readLine())!=null){
                if(readLine.length() == 0){
                    break;
                }
                System.out.println(readLine);
            }

            OutputStream outputStream = socket.getOutputStream();
            //这里两个换行，响应头和响应体之间必须有换一行否则响应体内容无法正常解析
            String respHeader = "HTTP/1.1 200 OK\r\n"+"Content-Type: text/html;charset=utf-8\r\n\r\n";
            String respBody = "hi ,孙悟空~";
            String resp = respHeader+respBody;
            System.out.println("响应部分=========");
            System.out.println(resp);
            outputStream.write(resp.getBytes());
            outputStream.flush();
            outputStream.close();
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

image-20220309223516447

4.实现任务阶段 3- 处理 Servlet

1.Servlet 生命周期-回顾

image-20220309224041101

2.需求分析/图解

●需求分析如图, 浏览器请求 http://localhost:8080/hspCalServlet, 提交数据，完成计算任务，如果 servlet 不存在，返回 404

image-20220310225343036

image-20220310225502410

image-20220310225511883

3.分析+代码实现

●分析示意图

image-20220310225601475

image-20220310225611745

开发流程-一图胜千言

image-20220312150222005

image-20220312151023845

1.Tomcat启动类
public class Tomcat3 {

    /**
     * 定义一个map用于存放web.xml中读取到的Servlet实例；
     * key为ServletName
     * value为HttpServlet实例
     */
    public static final ConcurrentMap<String, LlpHttpServlet> servletMap = new ConcurrentHashMap<>();

    /**
     * 用于存放Servlet-Mapping部分内容
     * key为：ServletPattern
     * value为ServletName
     * 浏览器访问时，可通过uri即map的key直接获取到对应的vlue-ServletName
     * 从而从servletMap中获取对应的HttpServlet实例，如果Servlet实例不存在则返回404
     */
    public static final ConcurrentMap<String,String> servletMappingMap = new ConcurrentHashMap<>();


    public static void main(String[] args) throws Exception {
        init();
        run();
    }

    public static void init() throws Exception {
        SAXReader saxReader = new SAXReader();
        //llp-tomcat\target\classes\web.xml 这里我将web.xml直接拷贝到了\target\classes\目录下
        String path = Tomcat3.class.getResource("/").getPath();
        Document document = saxReader.read(new File(path+"web.xml"));
        //获取根本标签
        Element rootElement = document.getRootElement();
        List<Element> elements = rootElement.elements();
        for (Element element : elements) {
            /**
             *     <servlet>
             *         <servlet-name>LlpCalServlet</servlet-name>
             *         <servlet-class>com.llp.tomcat.servlet.LlpCalServlet</servlet-class>
             *     </servlet>
             *     <servlet-mapping>
             *         <servlet-name>LlpCalServlet</servlet-name>
             *         <url-pattern>/llpCalServlet</url-pattern>
             *     </servlet-mapping>
             */
            String name = element.getName();
            if("servlet".equals(name)){
                String classFullPath = element.element("servlet-class").getText().trim();
                Class<?> aClass = Class.forName(classFullPath);
                 LlpHttpServlet llpHttpServlet = (LlpHttpServlet) aClass.newInstance();
                servletMap.put(element.element("servlet-name").getText().trim(),llpHttpServlet);
            }
            if("servlet-mapping".equals(name)){
                String servletName = element.element("servlet-name").getText().trim();
                String urlPattern = element.element("url-pattern").getText().trim();
                servletMappingMap.put(urlPattern,servletName);
            }
        }
        System.out.println(servletMap);
        System.out.println(servletMappingMap);
    }

    public static  void run() throws Exception {
        ServerSocket serverSocket = new ServerSocket(8080);
        while (!serverSocket.isClosed()) {
            Socket socket = serverSocket.accept();
            new Thread(new RequestHandler(socket)).start();
        }
        serverSocket.close();
    }
}
2.处理请求线程类RequestHandler
public class RequestHandler implements Runnable {
    private Socket socket;

    public RequestHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {

            LlpRequest llpRequest = new LlpRequest(socket.getInputStream());
            LlpResponse llpResponse = new LlpResponse(socket.getOutputStream());
            // LlpCalServlet llpCalServlet = new LlpCalServlet();
            // llpCalServlet.doGet(llpRequest,llpResponse);

            //通过反射动态获取LlpHttpServlet对象执行Service方法，这里利用java多态的特性进行了值传递
            //eg: uri = /llpCalServlet
            String uri = llpRequest.getUri();
            //判断请求的是不是静态资源,以.html为例
            if(WebUtil.isHtml(uri)){
                String url = uri.substring(1);
                String content = WebUtil.readHtml(url);
                System.out.println("content: "+content);
                OutputStream outputStream = llpResponse.getOutputStream();
                outputStream.write((LlpResponse.responseHeader+content).getBytes());
                outputStream.flush();
                return;
            }
            String servletName = Tomcat3.servletMappingMap.get(uri);
            if (servletName == null) {
                servletName = "";
            }
            LlpHttpServlet llpHttpServlet = Tomcat3.servletMap.get(servletName);
            if (llpHttpServlet != null) {
                llpHttpServlet.service(llpRequest, llpResponse);
            } else {
                OutputStream outputStream = llpResponse.getOutputStream();
                outputStream.write((LlpResponse.responseHeader +  "404 Not Found").getBytes());
                outputStream.flush();
            }

            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
3.自定义Servlet
1.自定义Servlet接口-LlpServlet
public interface LlpServlet {
    void init();

    void service(LlpRequest request, LlpResponse response);

    void destroy();

}
2.自定义Servlet抽象类-LlpHttpServlet
public abstract class LlpHttpServlet implements LlpServlet{

    @Override
    public void service(LlpRequest request, LlpResponse response) {
        if("GET".equalsIgnoreCase(request.getMethod())){
            doGet(request,response);
        }else if("POST".equalsIgnoreCase(request.getMethod())){
            doPost(request,response);
        }
        
    }



    protected abstract void doPost(LlpRequest request, LlpResponse response);

    protected abstract void doGet(LlpRequest request, LlpResponse response);

    @Override
    public void init() {

    }

    @Override
    public void destroy() {

    }

}
3.自定义HttpServletRequest、HttpServletResponse
public class LlpRequest {


    private String method; //GET

    private String uri; // /cal

    private Map<String, String> paramterMap = new HashMap<>(); //num1=12&num2=12

    private InputStream inputStream = null;

    //GET /cal?num1=12&num2=21 HTTP/1.1
    public LlpRequest(InputStream inputStream) {
        this.inputStream = inputStream;
        encapHttpRequest();
    }

    public String getParameter(String key){
        return paramterMap.get(key);
    }


    /**
     * 将http请求相关的数据进行封装
     */
    public void encapHttpRequest(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            //请求行
            //GET /cal?num1=12&num2=21 HTTP/1.1
            String requestLine = bufferedReader.readLine();
            String[] requestLineArr = requestLine.split(" ");
            method = requestLineArr[0];
            System.out.println("method: "+method);
            /**
             * /cal?num1=12&num2=21
             * 1.判断是否含有参乎上
             * 2.无参则取出uri
             * 3.有参则分成两段： /cal  num1=12&num2=21
             */
            String url = requestLineArr[1];
            if(url.indexOf("?")==-1){
                uri = url;
            }else {
                uri = url.substring(0, url.indexOf("?"));
                String paramters = url.substring(url.indexOf("?") + 1);
                //防止用户输入 /cal?
                if(paramters!=null && !"".equals(paramters)){
                    String[] split = paramters.split("&");
                    if(split!=null && split.length!=0){
                        for (String s : split) {
                            // num1=12  num2=21
                            String[] split1 = s.split("=");
                            paramterMap.put(split1[0],split1[1]);
                        }
                    }
                }
                System.out.println("uri: "+uri);
                System.out.println("paramterMap: "+paramterMap);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String getMethod() {
        return method;
    }

    public String getUri() {
        return uri;
    }
}

public class LlpResponse {

    public static final String responseHeader = "HTTP/1.1 200 OK\r\n"+"Content-Type: text/html;charset=utf-8\r\n\r\n";

    private OutputStream outputStream = null;

    public LlpResponse(OutputStream outputStream){
        this.outputStream = outputStream;
    }

    public OutputStream getOutputStream() {
        return outputStream;
    }

}
4.自定义Servlet业务类
public class LlpCalServlet  extends LlpHttpServlet{

    @Override
    public void doPost(LlpRequest request, LlpResponse response) {
    }

    @Override
    public void doGet(LlpRequest request, LlpResponse response) {
        try {
            Integer num1 = WebUtil.parseInteger(request.getParameter("num1"),0);
            Integer num2 = WebUtil.parseInteger(request.getParameter("num2"),0);

            OutputStream outputStream = response.getOutputStream();
            //这里两个换行，响应头和响应体之间必须有换一行否则响应体内容无法正常解析
            String respHeader = LlpResponse.responseHeader;
            String resp = respHeader +"<h1>"+num1+"+"+num2+"="+(num1+num2)+" llp Tomcat</h1>";
            outputStream.write(resp.getBytes());
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}
4.工具类
public class WebUtil {
    public static  Integer parseInteger(String value,Integer deafultValue){
        int num;
        try {
            num  = Integer.parseInt(value);
        } catch (NumberFormatException e) {
            System.out.println("value不能转换为数字类型");
            return deafultValue;
        }
        return num;
    }

    public static boolean isHtml(String uri){
        return uri.endsWith(".html");
    }

    public static String readHtml(String url){
        BufferedReader bufferedReader = null;
        StringBuilder builder = new StringBuilder();
        try {
            String path = WebUtil.class.getResource("/").getPath()+url;
            bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(path)));
            String readLine = null;
            while ((readLine= bufferedReader.readLine())!=null){
                builder.append(readLine);
            }
        } catch (Exception e) {
            return  "404 Not Found";
        }finally {
            if(bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return builder.toString();
    }

}
5.测试效果

image-20220312151451371

image-20220312151544631

HTML+CSS+Servlet
Null_Kun
04-15 1067
HTML 一、HTML简介 1.1 HTML概述 HTML全称：Hyper Text Markup Language（超文本标记语言） ​ HTML是一门用户创建网页文档的标记语言，网页本身是一种文本文件，在文本文件中添加标记符 ​ 浏览器解析HTML标记的内容（文字的处理，排版的安排，图片如何显示、音频、视频等等） ​ HTML是用来创建网页的标记语言 1.2 HTML特点 1.简易性：...
JavaWeb---Tomcat---Servlet
weixin_45467873的博客
03-04 573
JavaWeb 1、基本概念 静态网页无法与人工交互 动态网页可以人工交互 技术栈：Servlet、JSP、PHP 简介：在Java中，动态web资源开发的技术统称为JavaWeb. 2、web应用 web应用程序“可以提供浏览器访问的程序。 注意：网上可以访问的资源，都是储存在摸个计算机（服务器）上。通过URL（地址）去访问这个地址。 这个统一的web资源会被放置在同一个文件夹上，web应用程序–>Tomcat(服务器)，将web应用部署在服务器上。 web应用程序编写完毕后，若想提供给外界访问：需
自己实现Tomcat
06-23
此篇博客Mytomcat实现的功能只能访问静态资源(图片处理点问题)，我们把项目部署到Mytomcat的webapps目录下，开启MyTomcat服务后，就可以进行访问了！博客：https://blog.csdn.net/m0_37499059/article/details/80779823
实现一个简单的Tomcat
weixin_34216196的博客
11-06 151
实现一个简单的Tomcat 1. Tomcat作用 我们的web应用会运行在Tomcat中，那么显然请求必定是先到达Tomcat的，Tomcat对于请求实际上会进行如下的处理： 提供Socket服务：Tomcat的启动，必然是Socket服务，支持http协议。 进行请求的分发：一个Tomcat可以为多个web应用提供服务，那么就需要把...
Tomcat——手动实现tomcat2
武汉小喽啰
12-28 210
1. 案例需求 当客户端发送请求到服务端的时候，可以运行服务端的一段java代码，而且可以向客户端响应数据 2. 代码实现 工程目录结构图 2.1 定义一个接口Servlet 该接口是所有服务端运行的Java小程序都要遵循的接口 package cn.bjc.mytomcat.v2; import java.io.InputStream; import java.io.Outp...
手动实现一个tomcat
m0_52012606的博客
07-11 1999
此图就是tomcat的实现原理，搞懂此图你也可以自己实现一个tomcat了！这是我实现的一个tomcat tomcat: 手动实现tomcat需要放在路径没有空格。MyTomcat类是启动类
手动实现tomcat功能
当时只道是平常
05-23 1947
Tomcat服务器是一个免费的开放源代码的Web应用服务器。Tomcat是Apache软件基金会（Apache Software Foundation）的Jakarta项目中的一个核心项目，由Apache、Sun和其他一些公司及个人共同开发而成。既然是免费的，我们为什么要手动实现？ 我们只是简单实现tomcat的一部分功能，使我们更加了解tomcat。 手动实现： 首先创建HttpReque...
Java学生课程成绩教师信息-管理系统【JavaWeb】Servlet+Mysql+Jsp+Tomcat.zip
03-03
Java是一种高性能、跨平台的面向...自动内存管理（垃圾回收）： Java具有自动内存管理机制，通过垃圾回收器自动回收不再使用的对象，使得开发者不需要手动管理内存，减轻了程序员的负担，同时也减少了内存泄漏的风险。
tomcat8+solr7直装版
11-19
【Apache Tomcat】：Apache Tomcat是一款开源的Servlet容器，它实现了Java Servlet和JavaServer Pages（JSP）规范，用于部署和运行Java Web应用程序。Tomcat 8.5是Tomcat的一个稳定版本，提供了许多性能改进和新特性...
Servlet详解
weixin_42199626的博客
03-09 276
Servlet介绍 百科资料 Servlet与Tomcat关系 在创建web工程的时候，默认是需要导入服务器的Jar文件到项目中，为什么要导入呢？ 这里有对web工程的一些支持jar包，如果不导入很多功能是无法实现的 例如： servlet-api.jar 支持Servlet 环境 el-api.jar 对EL表达式的支持 jsp-api.jar 对JSP文件的支持 … Servlet实际是To...
自己实现Tomcat-完善版
06-24
该包含Mytomcat源码和Mytomcat使用安装包。MyTomcat.zip是使用文件，就像我们下的tomcat一样 解压后，配置环境变量MT_HOME 然后启动服务器即可 里面有测试文件.....
【Tomcat】——纯手写实现一个简单的Tomcat
我爱吃土豆
07-26 7473
前言 心血来潮，记得上大学时老师曾经简单讲过Tomcat底层的实现原理，并给我们演示过简单的实现，趁着刚毕业还没有全部忘记，回温一下记录在这里，在这里纯底层实现一个简单可以访问静态文件以及动态请求的Tomcat服务器。 实现功能： 1：静态资源请求 2：动态请求处理 3：session及cookie信息存储，为方便下文的理解不了解的同学可以先自行了解一下session和cookie ...
从零手动实现简易Tomcat
weixin_34183910的博客
01-30 231
Hello大家好，本章我们自己实现一个简易版的tomcat 。有问题可以联系我mr_beany@163.com。另求各路大神指点，感谢程序的运行少不了服务器的支持，而tomcat因其性能稳定，免费等优点，深受 Java 爱好者的喜爱并得到了部分软件开发商的认可，为目前比较流行的 Web 应用服务器。那么到底它是怎么运行的呢？今天我们来实现一个简化版tomcat来感受一下。一：导入解析xml的jar...
netty 手动实现tomcat的简单功能
weixin_43881309的博客
08-15 722
Tomcat是Apache 软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，由Apache、Sun 和其他一些公司及个人共同开发而成。由于有了Sun 的参与和支持，最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现。现在我们通过netty来实现一些Tomcat的简单功能。 //1、启动端口（IP），默认8080 ， S...
自己动手实现Tomcat
weixin_45739339的博客
05-11 158
javaweb学习（day07-手动实现tomcat)
weixin_51580177的博客
03-07 932
在本节，主要是理解了tomcat底层的具体实现逻辑，跟着学习也在一定程度上巩固了java基础
手动实现Tomcat底层机制+自己设计Servlet
最新发布
Sun的个人博客
04-06 1983
在Request.java中获取完参数顺便把inputStream关闭了，导致了Socket也一起关闭了，使得主线程在使用socket的时候出现了已经关闭的错误。
Tomcat——常识介绍与手动实现tomcat1
武汉小喽啰
12-28 252
1. HTTP协议 1.1 特点 1.支持客户/服务器模式。 2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。 3.灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。 4.无连接：无...
Tomcat手写实现
weixin_44971379的博客
10-26 118
Tomcat 服务流程 1:浏览器发出请求，访问服务器，发送一个请求头信息 2:根据Http协议解析对应的请求头信息 3:获取请求头中的资源地址 4:判断资源的类型，静态/动态 5:将资源通过通道(流)返回给浏览器端 手写实现 import com.example.springbootstart.tomcat.servlet.*; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; impo
Eclipse与Tomcat配置教程：运行Servlet的两种方法
而JDK+Tomcat的方式则适用于更底层的服务器配置和管理，适合了解服务器运行机制的开发者。 通过学习这两种方法，开发者可以灵活地根据项目需求和自身偏好选择合适的开发环境。理解并熟练掌握Servlet的运行方式对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值