Servlet底层源码理解

最新推荐文章于 2023-02-09 23:08:23 发布
最新推荐文章于 2023-02-09 23:08:23 发布
阅读量251 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Servlet 文章标签： servlet http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49491001/article/details/120139897
当一个类继承HttpServlet，它首先调用service方法，通过参数转型调用HttpServlet的重载方法，降低与HTTP协议的耦合。在service方法内部，根据请求类型执行DoGet或DoPost等方法，进一步调用开发者自定义的处理方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

如果一个类继承了HttpServlet，那么他的实现过程是怎样的？

 我的理解：一个类继承了HttpServlet类之后，首先会去调用实现父类的 service(ServletRequest req,ServletResponse res)方法通 过 参 数 的 向 下 转 型 ， 然 后 调 用 重 载的 service(HttpservletRequest,HttpServletResponse)方法，目的是减少与http协议之间产生的耦合性，然后在service方法中进行判断提交方式的Do Get 还是Do Post 或者是其他提交方式，之后再通过调用我们自己重写的do get 和do post方法执行。

public HttpServlet() {
    }

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String msg = lStrings.getString("http.method_get_not_supported");
        this.sendMethodNotAllowed(req, resp, msg);
    }

    protected long getLastModified(HttpServletRequest req) {
        return -1L;
    }

    protected void doHead(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        if (DispatcherType.INCLUDE.equals(req.getDispatcherType())) {
            this.doGet(req, resp);
        } else {
            HttpServlet.NoBodyResponse response = new HttpServlet.NoBodyResponse(resp);
            this.doGet(req, response);
            if (req.isAsyncStarted()) {
                req.getAsyncContext().addListener(new HttpServlet.NoBodyAsyncContextListener(response));
            } else {
                response.setContentLength();
            }
        }

    }

    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String msg = lStrings.getString("http.method_post_not_supported");
        this.sendMethodNotAllowed(req, resp, msg);
    }

    protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String msg = lStrings.getString("http.method_put_not_supported");
        this.sendMethodNotAllowed(req, resp, msg);
    }

    protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String msg = lStrings.getString("http.method_delete_not_supported");
        this.sendMethodNotAllowed(req, resp, msg);
    }

    private void sendMethodNotAllowed(HttpServletRequest req, HttpServletResponse resp, String msg) throws IOException {
        String protocol = req.getProtocol();
        if (protocol.length() != 0 && !protocol.endsWith("0.9") && !protocol.endsWith("1.0")) {
            resp.sendError(405, msg);
        } else {
            resp.sendError(400, msg);
        }

    }

    private static Method[] getAllDeclaredMethods(Class<?> c) {
        if (c.equals(HttpServlet.class)) {
            return null;
        } else {
            Method[] parentMethods = getAllDeclaredMethods(c.getSuperclass());
            Method[] thisMethods = c.getDeclaredMethods();
            if (parentMethods != null && parentMethods.length > 0) {
                Method[] allMethods = new Method[parentMethods.length + thisMethods.length];
                System.arraycopy(parentMethods, 0, allMethods, 0, parentMethods.length);
                System.arraycopy(thisMethods, 0, allMethods, parentMethods.length, thisMethods.length);
                thisMethods = allMethods;
            }

            return thisMethods;
        }
    }

    protected void doOptions(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Method[] methods = getAllDeclaredMethods(this.getClass());
        boolean ALLOW_GET = false;
        boolean ALLOW_HEAD = false;
        boolean ALLOW_POST = false;
        boolean ALLOW_PUT = false;
        boolean ALLOW_DELETE = false;
        boolean ALLOW_TRACE = true;
        boolean ALLOW_OPTIONS = true;
        Class clazz = null;

        try {
            clazz = Class.forName("org.apache.catalina.connector.RequestFacade");
            Method getAllowTrace = clazz.getMethod("getAllowTrace", (Class[])null);
            ALLOW_TRACE = (Boolean)getAllowTrace.invoke(req, (Object[])null);
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | ClassNotFoundException var14) {
        }

        for(int i = 0; i < methods.length; ++i) {
            Method m = methods[i];
            if (m.getName().equals("doGet")) {
                ALLOW_GET = true;
                ALLOW_HEAD = true;
            }

            if (m.getName().equals("doPost")) {
                ALLOW_POST = true;
            }

            if (m.getName().equals("doPut")) {
                ALLOW_PUT = true;
            }

            if (m.getName().equals("doDelete")) {
                ALLOW_DELETE = true;
            }
        }

        String allow = null;
        if (ALLOW_GET) {
            allow = "GET";
        }

        if (ALLOW_HEAD) {
            if (allow == null) {
                allow = "HEAD";
            } else {
                allow = allow + ", HEAD";
            }
        }

        if (ALLOW_POST) {
            if (allow == null) {
                allow = "POST";
            } else {
                allow = allow + ", POST";
            }
        }

        if (ALLOW_PUT) {
            if (allow == null) {
                allow = "PUT";
            } else {
                allow = allow + ", PUT";
            }
        }

        if (ALLOW_DELETE) {
            if (allow == null) {
                allow = "DELETE";
            } else {
                allow = allow + ", DELETE";
            }
        }

        if (ALLOW_TRACE) {
            if (allow == null) {
                allow = "TRACE";
            } else {
                allow = allow + ", TRACE";
            }
        }

        if (ALLOW_OPTIONS) {
            if (allow == null) {
                allow = "OPTIONS";
            } else {
                allow = allow + ", OPTIONS";
            }
        }

        resp.setHeader("Allow", allow);
    }

    protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String CRLF = "\r\n";
        StringBuilder buffer = (new StringBuilder("TRACE ")).append(req.getRequestURI()).append(" ").append(req.getProtocol());
        Enumeration reqHeaderEnum = req.getHeaderNames();

        while(reqHeaderEnum.hasMoreElements()) {
            String headerName = (String)reqHeaderEnum.nextElement();
            buffer.append(CRLF).append(headerName).append(": ").append(req.getHeader(headerName));
        }

        buffer.append(CRLF);
        int responseLength = buffer.length();
        resp.setContentType("message/http");
        resp.setContentLength(responseLength);
        ServletOutputStream out = resp.getOutputStream();
        out.print(buffer.toString());
        out.close();
    }

    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getMethod();
        long lastModified;
        if (method.equals("GET")) {
            lastModified = this.getLastModified(req);
            if (lastModified == -1L) {
                this.doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader("If-Modified-Since");
                } catch (IllegalArgumentException var9) {
                    ifModifiedSince = -1L;
                }

                if (ifModifiedSince < lastModified / 1000L * 1000L) {
                    this.maybeSetLastModified(resp, lastModified);
                    this.doGet(req, resp);
                } else {
                    resp.setStatus(304);
                }
            }
        } else if (method.equals("HEAD")) {
            lastModified = this.getLastModified(req);
            this.maybeSetLastModified(resp, lastModified);
            this.doHead(req, resp);
        } else if (method.equals("POST")) {
            this.doPost(req, resp);
        } else if (method.equals("PUT")) {
            this.doPut(req, resp);
        } else if (method.equals("DELETE")) {
            this.doDelete(req, resp);
        } else if (method.equals("OPTIONS")) {
            this.doOptions(req, resp);
        } else if (method.equals("TRACE")) {
            this.doTrace(req, resp);
        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[]{method};
            errMsg = MessageFormat.format(errMsg, errArgs);
            resp.sendError(501, errMsg);
        }

    }

    private void maybeSetLastModified(HttpServletResponse resp, long lastModified) {
        if (!resp.containsHeader("Last-Modified")) {
            if (lastModified >= 0L) {
                resp.setDateHeader("Last-Modified", lastModified);
            }

        }
    }

    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        HttpServletRequest request;
        HttpServletResponse response;
        try {
            request = (HttpServletRequest)req;
            response = (HttpServletResponse)res;
        } catch (ClassCastException var6) {
            throw new ServletException(lStrings.getString("http.non_http"));
        }

        this.service(request, response);
    }

【JavaWeb】Servlet系列 --- HttpServlet【底层源码分析】
weixin_46312449的博客
11-30 864
协议实际上是某些人，或者某些组织提前制定好的一套规范，大家都按照这个规范来，这样可以做到沟通无障碍。协议就是一套规范，就是一套标准。由其他人或其他组织来负责制定的。比如：我说的话你能听懂，你说的话，我也能听懂，这说明我们之间是有一套规范的，一套协议的，这套协议就是：中国普通话协议。我们都遵守这套协议，我们之间就可以沟通无障碍。HTTP协议：是W3C制定的一种超文本传输协议。（通信协议：发送消息的模板提前被制定好。）W3C：■万维网联盟组织...
Servlet源码
weixin_45064346的博客
07-31 1190
2、GenericServlet源码。1、HttpServlet源码。3、Servlet源码。
Servlet底层源码分析
姓程名序种族猿
04-29 221
Servlet底层源码分析 若想看Servlet源码 创建一个maven项目，去maven仓库搜索servlet，选择javaServlet™Specification，将其导入项目 创建一个项目，继承HttpServlet,就能看HttpServlet源码了 1.Servlet 结构图 Servlet 和 ServletConfig 都是顶层接口,而 GenericServlet 实现了这...
servlet 源码
04-24
Serlvet的源代码，方便阅读servlet的底层的实现
Tomcat8.0底层源码
08-20
《深入剖析Tomcat 8.0底层源码》 Tomcat作为一款广泛应用的开源Java Servlet容器，其8.0版本的源码对于开发者来说是一份宝贵的教育资源。通过深入学习Tomcat 8.0的源码，我们可以理解Web服务器的工作原理，提升对...
深入理解Servlet源码：底层实现与机制
- **提高技术深度**：阅读和理解Servlet的源码能够帮助开发者深入学习Java Web技术，尤其是对于请求处理流程、生命周期管理、线程安全等问题有更深刻的认识。 - **解决实际问题**：在遇到性能瓶颈或bug时，通过...
过滤器底层源码解析
Ciao's blog
02-09 945
过滤器底层源码解析
Servlet 源码
zhuhaoyu6666的博客
10-23 187
package javax.servlet; import java.io.IOException; public interface Servlet { void init(ServletConfig var1) throws ServletException; ServletConfig getServletConfig(); void service(Ser...
servlet源码
09-24
解决servlet.jar包导入没用的问题，包含servlet源码。
servlet源码包
11-27
javax.servlet的源码包包括javax.servlet.http、javax.servlet.jsp(只是源码包)
Servlet基础源代码
12-20
java web 的学习最基础篇章，全部是基础代码，通俗易懂。 *
servlet-api源码
03-07
servlet-api源码
Servlet源码理解。深入分析。
czlpf的博客
08-19 569
一般写servlet只需要继承HttpServlet类，重写doGet/doPost方法。 包含了Servlet生命周期4要素：创建（构造器），初始化（init），运行（service），销毁（destory） 要想了解Servlet，必须先了解两个类： javax.servlet.Servlet.（接口） javax.servlet.http.HttpServlet（抽象
浏览器到Servlet的HttpServlet的简单实现、底层实现
a511718727的专栏
05-27 1919
简单实现直接复制csdyhhah
servlet源码查看
weixin_30784141的博客
03-22 262
1，下载源码，点击此处可下载 2，创建web项目 我这里以jdbc这个web项目为例讲解 在javaee libraries中有个javaee.jar包，选中它-->右击--》Properties 找到你下载的jar包 打开---apply 即可】 在任意一个.java文件中，编写servlet，按住ctrl键，鼠标单击类（或接口）名，即可查看源码 下面...
【Servlet】（1）Servlet简介、Servlet底层原理、Servlet实现方式、Servlet生命周期
热门推荐
07-26 1万+
一、Servlet简介1、Servlet定义： Servlet（Server Applet）是Java Servlet的简称，是为小服务程序或服务连接器，用Java编写的服务器端程序，主要功能在于交互式地浏览和修改数据，生成动态Web内容。 2、Servlet定义： A servlet is a small Java program that runs within a Web server
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值