手写简单版Tomcat（三）——解析servlet

最新推荐文章于 2024-08-11 23:54:45 发布
最新推荐文章于 2024-08-11 23:54:45 发布
阅读量214 收藏
点赞数
分类专栏： tomcat 文章标签： tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32069155/article/details/88933904
版权

到目前为止，我们手写的tomcat已经具备了基本的读取静态资源文件、读取web.xml文件来进行配置的功能，接下来就是对servlet的解析。

<web-app>

      <welcome-file-list>
          <welcome-file>../index.html</welcome-file>
          <welcome-file>index.html</welcome-file>
          <welcome-file>index.html</welcome-file>
      </welcome-file-list>

    <servlet>
        <servlet-name>helllo</servlet-name>
        <servlet-class>Server.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>helllo</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

</web-app>

在web.xml中，把servlet的配置写进去，同时，我也对整个项目的路径进行了一些修改：

我把这几个目录，都统统改在了servlet的目录下

在Server下建一个Servlet父类，定义post和get方法

package Server;

public abstract class Servlet {

    public abstract  void doGet(Request request, Response response);

    public abstract  void doPost(Request request, Response response);

    public void service (Request request, Response response){

        if ("GET".equals(request.getMethod())){
            doGet(request,response);
        }else if ("POST".equals(request.getMethod())){
            doPost(request,response);
        }else{
            throw new RuntimeException();
        }

    }

}

接着写一个 HelloServlet 继承于Servlet

package Server.servlet;

import Server.Request;
import Server.Response;
import Server.Servlet;

public class HelloServlet extends Servlet {

    @Override
    public void doGet(Request request, Response response) {

        System.out.println("doGet");

    }

    @Override
    public void doPost(Request request, Response response) {

        System.out.println("doPost");

    }
}

然后在Resonse中用一个变量存放在web.xml中读取到的servlet，

public static List<Map> servletList = new ArrayList<Map>();

这在tomcat中对应的是Web Application，每个Web Application 由一个或多个Servlet 组成。当一个Web Application 被初始化的时候，它将用自己的ClassLoader 对象载入部署配置文件web.xml 中定义的每个Servlet 类。

之后，在xmlUtil中把servlet的相关配置加载进来

package Server;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class XmlUtil {

    /*
    *   用Map封装XML实体
    *   一个标准的XML节点有3个参数：节点名String，参数名List<Map<String,Object>>，子节点List<Map>
    * */

    public static Object read(String path) throws Exception {

        //SAXReader就是一个管道，用一个流的方式，把xml文件读出来
        SAXReader reader = new SAXReader();
        File file = new File(path);
        Document document = reader.read(file);
        Element root = document.getRootElement();
        return root;

    }

    //解析Web.xml   analysis 英文解析
    public static boolean analysisWeb(){

        File directory = new File("src/main/resources/web.xml");
        try {
            Element root = (Element) read(directory.getAbsolutePath());
            if (!"web-app".equals(root.getName())){
                return false;
            }else{
                List<Element> elements = root.elements();

                for ( Element element : elements ) {

                    //welcome-file-list     欢迎文件页配置
                    if ("welcome-file-list".equals(element.getName())){
                        List<Element> welcome_file_list = element.elements();
                        if (welcome_file_list.size() > 0){
                            for ( Element welcome_file : welcome_file_list ){
                                if ("welcome-file".equals(welcome_file.getName()))
                                    Response.indexPages.add(welcome_file.getText());
                            }
                        }
                    }

                    if ("servlet".equals(element.getName())){
                        List<Element> servlet = element.elements();
                        if (servlet.size() > 0){
                            for ( Element servlet_children : servlet ){
                                if ("servlet-name".equals(servlet_children.getName())) {
                                    //如果servletName不存在，则新建,否则直接put对应的值
                                    List<Map> servletList = Response.servletList;
                                    if (servletList.size() > 0) {
                                        for (int i = 0; i < servletList.size(); i++) {
                                            Map servletMap = servletList.get(i);
                                            if (!servlet_children.getText().equals(servletMap.get("name"))) {
                                                Map map = new HashMap();
                                                map.put("name", servlet_children.getText());
                                                map.put("class", null);
                                                for (Element servlet_children2 : servlet) {
                                                    if ("servlet-class".equals(servlet_children2.getName())) {
                                                        map.put("class", servlet_children2.getText());
                                                    }
                                                }
                                                Response.servletList.add(map);
                                            } else {
                                                servletMap.put("class", null);
                                                for (Element servlet_children2 : servlet) {
                                                    if ("servlet-class".equals(servlet_children2.getName())) {
                                                        servletMap.put("class", servlet_children2.getText());
                                                    }
                                                }
                                                Response.servletList.set(i, servletMap);
                                            }
                                        }
                                    }else {
                                        Map map = new HashMap();
                                        map.put("name", servlet_children.getText());
                                        map.put("class", null);
                                        for (Element servlet_children2 : servlet) {
                                            if ("servlet-class".equals(servlet_children2.getName())) {
                                                map.put("class", servlet_children2.getText());
                                            }
                                        }
                                        Response.servletList.add(map);
                                    }
                                }
                            }
                        }
                    }

                    if ("servlet-mapping".equals(element.getName())){
                        List<Element> servletMapping = element.elements();
                        if (servletMapping.size() > 0){
                            for ( Element servletMapping_children : servletMapping ){
                                if ("servlet-name".equals(servletMapping_children.getName())) {
                                    //如果servletName不存在，则新建
                                    List<Map> servletList = Response.servletList;
                                    if (servletList.size() > 0) {
                                        for (int i = 0; i < servletList.size(); i++) {
                                            Map servletMap = servletList.get(i);
                                            if (!servletMapping_children.getText().equals(servletMap.get("name"))) {
                                                Map map = new HashMap();
                                                map.put("name", servletMapping_children.getText());
                                                map.put("url", null);
                                                for (Element servlet_children2 : servletMapping) {
                                                    if ("url-pattern".equals(servlet_children2.getName())) {
                                                        map.put("url", servlet_children2.getText());
                                                    }
                                                }
                                                Response.servletList.add(map);
                                            } else {
                                                servletMap.put("url", null);
                                                for (Element servlet_children2 : servletMapping) {
                                                    if ("url-pattern".equals(servlet_children2.getName())) {
                                                        servletMap.put("url", servlet_children2.getText());
                                                    }
                                                }
                                                Response.servletList.set(i, servletMap);
                                            }
                                        }
                                    }else {
                                        Map map = new HashMap();
                                        map.put("name", servletMapping_children.getText());
                                        map.put("url", null);
                                        for (Element servlet_children2 : servletMapping) {
                                            if ("url-pattern".equals(servlet_children2.getName())) {
                                                map.put("url", servlet_children2.getText());
                                            }
                                        }
                                        Response.servletList.add(map);
                                    }
                                }
                            }
                        }
                    }

                    //error-page   通过错误码来配置error-page
//                    if ("error-page".equals(elements)){
//                        List<Element> welcome_file_list = element.elements();
//                        if (welcome_file_list.size() > 0){
//                            for ( Element welcome_file : welcome_file_list ){
//                                if ("welcome-file".equals(welcome_file.getName()))
//                                    Server.Response.Index.add(welcome_file.getText());
//                            }
//                        }
//                    }

                }

            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return false;
    }

}

我解析servlet配置的思路是这样的：首先判断“Response.servletList”中是否有值，如果没有，那么直接新建一个map用于保存servlet的name、url、class，如果有，那就先取出来遍历，看看serlvet的name存不存在，如果存在，就直接覆盖对应的class或者url，否则新建一个servlet。

把配置中的servlet加载成功后，就在Response做判断，如果是访问的servlet，就根据访问的Url与servlet中的url做对比，找到就通过反射调用对应的POST、GET方法

package Server;

import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import Server.Servlet.*;

public class Response {
    public static final int BUFFER_SIZE = 2048;

    //根路径
    private static final String RESOURCE = "";

    private Request request;
    private OutputStream output;
    public static List<String> indexPages = new ArrayList<String>();
    public static List<Map> servletList = new ArrayList<Map>();

    public Response(OutputStream output) {
        this.output = output;
    }

    public void setRequest(Request request) {
        this.request = request;
    }

    public void sendStaticResource() throws IOException {
        byte[] bytes = new byte[BUFFER_SIZE];
        FileInputStream fis = null;
        try {
            //====================================访问的如果是首页
            if ("/".equals(request.getUrL())) {
                if (indexPages.size() > 0) {
                    for (int i = 0; i < indexPages.size(); i++) {
                        File file = new File(RESOURCE + "src/main/resources", indexPages.get(i));
                        if (null != getFile(file)) {
                            String retMessage = (String) getFile(file);
                            output.write(retMessage.getBytes());
                            return;
                        } else {
                            continue;
                        }
                    }
                }

                String retMessage = "<h1> 主页被吃了! </h1>";
                String returnMessage = "HTTP/1.1 404 File Not Found\r\n" +
                        "Content-Type: text/html;charset=utf-8\r\n" +
                        "Content-Length: " + retMessage.getBytes().length + "\r\n" +
                        "\r\n" +
                        retMessage;
                output.write(returnMessage.getBytes());
                return;
            }
            //====================================首页结束

            //如果是serlvet
            if (request.getUrL().split("\\.").length == 1){
                for ( Map map : servletList){
                    if (map.get("url").equals(request.getUrL())){
                        if (map.get("class") != null){
                            if ("POST".equals(request.getMethod())){
                                Method aClass = Class.forName((String) map.get("class")).getMethod("doPost", request.getClass(), this.getClass());
                                aClass.invoke(Class.forName((String) map.get("class")).newInstance(), request, this);
                            }else if ("GET".equals(request.getMethod())){
                                Method aClass = Class.forName((String) map.get("class")).getMethod("doGet", request.getClass(), this.getClass());
                                System.out.println(aClass);
                                aClass.invoke(Class.forName((String) map.get("class")).newInstance(), request, this);
                            }
                        }
                    }
                }
            }

            //如果是静态资源
            if (request.getUrL().endsWith(".html") || request.getUrL().endsWith(".css") || request.getUrL().endsWith(".js")) {
                File file = new File(RESOURCE + "src/main/resources", request.getUrL());
                String retMessage = (String) getFile(file);
                if (null != retMessage) {
                    output.write(retMessage.getBytes());
                } else {
                    //文件不存在，返回给浏览器响应提示,这里可以拼接HTML任何元素
                    retMessage = "<h1>" + file.getName() + " Page or directory not exists</h1>";
                    String returnMessage = "HTTP/1.1 404 Page Not Found\r\n" +
                            "Content-Type: text/html\r\n" +
                            "Content-Length: " + retMessage.getBytes().length + "\r\n" +
                            "\r\n" +
                            retMessage;
                    output.write(returnMessage.getBytes());
                }
            }
        } catch (Exception e) {
            System.out.println(e.toString());
        } finally {
            if (fis != null)
                fis.close();
        }
    }

    public Object getFile(File file) throws Exception {
        FileInputStream fis = null;
        String retMessage = null;
        //如果文件存在，且不是个目录
        if (file.exists() && !file.isDirectory()) {
            fis = new FileInputStream(file);
            InputStreamReader reader = new InputStreamReader(fis, "UTF-8"); //最后的"GBK"根据文件属性而定，如果不行，改成"UTF-8"试试
            BufferedReader br = new BufferedReader(reader);
            String line;
            StringBuilder readLine = new StringBuilder();
            while ((line = br.readLine()) != null) {
                readLine.append(line);
            }
            retMessage = "HTTP/1.1 200 OK\r\n" +
                    "Content-Type: text/html;charset=utf-8\r\n" +
                    "Content-Length: " + readLine.toString().getBytes().length + "\r\n" +
                    "\r\n" +
                    readLine;
        } else {
            return null;
        }
        return retMessage;
    }

}

最后贴一张图

 

 

 至此，一个简陋版的tomcat就完成了。

如果有问题，可以留言交流。

鱼阿鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tomcat请求处理分析(六)servlet的处理过程
jack_Zheng的博客
08-19 1019
1.1.1.1  servlet的解析过程 servlet的解析分为两步实现，第一个是匹配到对应的Wrapper,第二个是加载对应的servlet并进行数据，这些数据是怎么到界面的，response.getWrite()获取对应的流，然后写入这个流中，这个流中就有上文的outputBuffer。 匹配到对应Wrapper        在上文中我们曾经走到过了doRun方法，现在就直接从
《深入剖析tomcat》读书笔记3--servlet容器
randyjiawenjie的专栏
04-05 3182
主要是《深入剖析tomcat》的第五章和第十一章。个人觉得如下3点是关键： 1. pipeline相关概念及其执行valve的顺序； 2. standardwrapper的接受http请求时候的调用序列； 3. standardwrapper基础阀加载servlet的过程（涉及到STM）； 顺便问一句，应该每一个servlet程序员都知道filter。但是你知道Filter在tomcat的
ServletContext【JavaWeb】
一切随缘的博客
12-29 1619
注意：以后我们编写Servlet类的时候，实际上是不会去直接继承GenericServlet类的，因为我们是B/S结构的系统，这种系统是基于HTTP超文本传输协议的，在Servlet规范当中，提供了一个类叫做HttpServlet，它是专门为HTTP协议准备的一个Servlet类。Tomcat服务器中有一个webapps，这个webapps下可以存放webapp，可以存放多个webapp，假设有100个webapp，那么就有100个ServletContext对象。（Servlet对象的四周环境对象。
servlet与tomcat的关系
热门推荐
baidu_36583119的博客
03-21 3万+
Servlet 工作原理解析:https://www.ibm.com/developerworks/cn/java/j-lo-servlet/ JSP九大内置对象的作用和用法总结？http://blog.csdn.net/sona_shi555/article/details/7797068 Servlet简介与Servlet和HttpServlet运行的流程：https://www.cnblo...
tomcat源码分析（4）—>servlet深入分析
m47838704的专栏
01-01 589
servlet是什么 在JavaEE中用于处理动态http请求的实例。 1、tomcat首先获取了http请求的url，解析url中的path，在path中的最后一个名字即为servlet名字（该名字不是servlet的类名，而是在web.xml或者是基于注解配置的path中的名字）。 2、根据该名字找到相应的servlet的类名，然后根据类名到自定义的类加载器中寻找该类的实例是否已经存在，
干货分享：深入剖析——tomcat中servlet的创建方式
Melodrammaaaaa的博客
10-13 266
一、 什么是servlet 1.1、用官方的话解释： Servlet是oracle公司提供的一门用于开发动态web资源的技术，属于javaEE体系中的一种核心规范。 通俗解释一下：就是我们开发人员所编写的一个类，必须直接或者间接实现这个javaEE的核心规范，也就是实现Servlet接口，因为这种类产生的对象可以被浏览器访问到，因此称之为Servlet,并且javaEE中规定了只有Servlet的实现类产生的对象才可以被浏览器访问，就是Servlet.(也就是说这个类要直接或者间接实现了Servlet接口)
tomcat 目录分解和手写servlet
weixin_57667101的博客
10-21 152
tomcat 目录分解和手写servlet
手写 tomcat nio
01-22
【标题】：“手写 Tomcat NIO” 在深入探讨手写Tomcat NIO之前，我们首先需要理解NIO（Non-blocking I/O）的概念。NIO是Java提供的一个用于替代传统I/O模型（即BIO，Blocking I/O）的库。在BIO中，每个连接都需要一...
手写tomcat
06-03
在手写Tomcat时，我们需要实现Servlet容器的基本功能，包括Servlet的加载、初始化、请求分发等。 2. **HTTP协议**：理解HTTP协议是构建Tomcat的基础，需要了解HTTP请求头、请求体、响应状态码、响应头等内容，并能...
手写简易tomcat
05-15
【标题】"手写简易tomcat"涉及到的知识点主要集中在如何构建一个小型的Web服务器，这个过程可以帮助我们深入理解Web服务器的工作原理，特别是Tomcat这样的Servlet容器。下面将详细阐述这些知识点。 首先，Tomcat是...
2020面试说明Tomcat源码手写.rar
02-22
【标题】"2020面试说明Tomcat源码手写.rar" 提供的是一个针对2020年面试准备的资源，特别是针对Java开发者，它聚焦于理解Tomcat服务器的源代码，帮助求职者提升自己的技术深度和面试竞争力。 【描述】中提到的情况...
吴京《信号与系统分析 第二版》课后题答案解析，全手写
06-30
吴京《信号与系统分析 第二版》课后题答案解析，国防科技大学出版社，ISBN号为：7-81024-552-X。答案解析全部手写，都是自己做过一遍并整理的，这本教材很好，但网上没有这版教材的答案解析学起来很头疼
Tomcat&Servlet 运行原理讲解
weixin_46103589的博客
03-20 1964
文章目录一、客户端（浏览器）与服务器之间的交互二、Tomcat启动过程三、Tomcat处理请求过程四、Servlet的service方法 在从前的时候，想要运行一个Java代码，就必须要实现main方法，这是程序的入口，通过初识 Servlet 就会发现没有实现 main 方法，程序就被成功调用，并且还能够在浏览器除看见想要看见的结果，这是为什么呢？ 事实就是，main 方法在Tomcat 中，Servlet 程序是配合Tomcat上运行的，Tomcat 就有了main 方法，就会拖着 Servlet 运行
tomcat原理解析(七)：执行servlet
qiangcai的专栏
06-07 2714
一 概述   前面章节已经说到http的请求到达了管道处理。最后的一个管道是StandardWrapper中的管道，它最后的阀门是StandardWrapperValve，阀门中的invoke代码 主要做了两件事情：1.执行过滤器链，2调用http请求servlet的service方法。 二过滤器 这里再次贴下invoke中的代码，部分省略掉： @Override p
Tomcat集成eclipse
qq_42856620的博客
08-01 206
Tomcat学习 讲师：莫凡 课程回顾 1.预编译对象操作数据库 (1)注册驱动 (2)获取连接 (3)获取语句执行对象 ①连接对象.preparedStatement ②在创建的时候就有SQL语句【参数化】 1)值或者条件中使用到值的部分，使用？占位 (4)执行SQL语句 ①DQL 1)executeQuery ②DDL/DML 1)executeUpdate (5...
深入理解Tomcat系列之六：Servlet工作原理
weixin_34195546的博客
03-27 2849
前言 Servlet是Web开发中的核心技术，作为一名合格的开发人员，就必须清楚Servlet的工作原理。本章没有对Servlet技术本身进行详细的说明，只是针对开发过程中一次Servlet的请求的处理过程进行分析的。Servlet实际上就是一个java类，只不过可以和浏览器进行一些数据的交换。有Servlet类就有管理Servlet...
Servlet和Tomcat的基础知识
胡同里的庇护所(Pirate Leo's Shelter)
02-25 2万+
前言： Servlet是什么？Servlet容器是什么？Tomcat是什么？Tomcat的组成结构以及Tomcat的工作模式。 最近没事在翻《Tomcat与Java Web开发技术详解》，本文随记一篇。 题外话：前几天做了一幅漫画，发到微博上，效果还不错~ 回归正题…… 正文： Servlet是什么 为了能让Web服务器与Web应用这两个不同的软件系统协作，需要一
Tomcat源码学习第4篇 - Servlet请求分析
CJG753951的博客
05-04 744
前段时间家里有事忙，停更了好长一段时间，这里跟等待更新的小伙伴们说一声抱歉，没能提前说明一下，让小伙伴们等了这么久，真的不好意思！ 前面说完了Tomcat的初始化和启动步骤，那么接下来就要进入重头戏了！在本篇文章中，我会跟前面一样，通过图文的方式来带着小伙伴们了解一个 Servlet是如何被tomcat处理的，具体的处理链路都有哪些。 一、请求分析 在《Tomcat源码学习第2篇》中备注了各个组件的说明。 当一个servlet请求到来的时候，首先经过的是connector组件，它是用来接收请求的。 该组.
影院订票系统/电影院售票系统/电影院购票系统的设计与实现/影院管理系统
最新发布
m0_73706453的博客
08-11 762
“互联网+”的战略实施后，很多行业的信息化水平都有了很大的提升。但是目前很多电影院日常业务仍是通过人工管理的方式进行，需要在影院订票投入大量的人力进行很多重复性工作，这样就浪费了许多的人力物力，工作效率较低，同时为后续的影院订票带来了隐患。影院订票系统的部署与应用，实现管理员对用户、影院信息、影厅信息、电影信息等功能，进行管理，这可以简化工作程序、降低劳动成本、提高影院订票效率和工作效率。为了有效推动电影院资源的合理配置和使用，迫切需要研发一套更加全面的影院订票系统。
手写简单版tomcat
05-16
要手写一个简单版的Tomcat，可以按照以下步骤进行： 1.创建一个Socket服务器，监听特定端口，等待客户端请求。 2.解析HTTP请求，获取请求方法、请求路径、请求参数等信息。 3.根据请求路径，获得对应的Servlet，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值