Servlet-http协议、模版方法设计模式、HttpServlet源码分析

发布于：2025-03-29 ⋅ 阅读:(29) ⋅ 点赞:(0)

一、HTTP协议

1.什么是协议？

  • 协议实际上是某些人，或者某些组织提前制定好的一套规范，大家都按照这个规范来，这样可以做到沟通无障碍。

  • 协议就是一套规范，就是一套标准。由其他人或其他组织来负责制定的。

  • 我说的话你能听懂，你说的话，我也能听懂，这说明我们之间是有一套规范的，一套协议的，这套协议就是：中国普通话协议。我们都遵守这套协议，我们之间就可以沟通无障碍。

2.什么是HTTP协议？

  • HTTP协议：是W3C制定的一种超文本传输协议。（通信协议：发送消息的模板提前被制定好。）

  • W3C：

    • 万维网联盟组织

    • 负责制定标准的：HTTP HTML4.0 HTML5 XML DOM等规范都是W3C制定的。

    • 万维网之父：蒂姆·伯纳斯·李

  • 什么是超文本？

    • 超文本说的就是：不是普通文本，比如流媒体：声音、视频、图片等。

    • HTTP协议支持：不但可以传送普通字符串，同样支持传递声音、视频、图片等流媒体信息。

  • 这种协议游走在B和S之间。B向S发数据要遵循HTTP协议。S向B发数据同样需要遵循HTTP协议。这样B和S才能解耦合。

  • 什么是解耦合？

    • B不依赖S。

    • S也不依赖B。

  • B/S表示：B/S结构的系统（浏览器访问WEB服务器的系统）

  • 浏览器 向 WEB服务器发送数据，叫做：请求（request)

  • WEB服务器 向 浏览器发送数据，叫做：响应（response）

  • HTTP协议包括：

    • 请求协议

      • 浏览器 向 WEB服务器发送数据的时候，这个发送的数据需要遵循一套标准，这套标准中规定了发送的数据具体格式。

    • 响应协议

      • WEB服务器 向 浏览器发送数据的时候，这个发送的数据需要遵循一套标准，这套标准中规定了发送的数据具体格式。

  • HTTP协议就是提前制定好的一种消息模板。

    • 不管你是哪个品牌的浏览器，都是这么发。

    • 不管你是哪个品牌的WEB服务器，都是这么发。

    • FF浏览器 可以向 Tomcat发送请求，也可以向Jetty服务器发送请求。浏览器不依赖具体的服务器品牌。

    • WEB服务器也不依赖具体的浏览器品牌。可以是FF浏览器，也可以是Chrome浏览器，可以是IE，都行。

3.怎么查看的协议内容？

  • 使用chrome浏览器：F12。然后找到network，通过这个面板可以查看协议的具体内容。

4.HTTP的响应协议（S （服务器）--> B（游览器））

⑴HTTP的响应协议包括：4部分

  • 状态行

  • 响应头

  • 空白行

  • 响应体

GetServlet类

package oop1;

import jakarta.servlet.GenericServlet;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class GetServlet extends GenericServlet {
    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
        // 响应一些内容到浏览器上。
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();

        // out.println() 是输出信息到浏览器，最终源代码中换行。（不是网页上有换行效果，网页上有换行效果必须使用<br>）
        out.println("<!doctype html>");
        out.println("<html>");
        out.println("    <head>");
        out.println("        <title>from get servlet</title>");
        out.println("    </head>");
        out.println("    <body>");
        out.println("        <h1>from get servlet</h1>");
        out.println("    </body>");
        out.println("</html>");
    }
}

PostServlet 类

package oop1;

import jakarta.servlet.GenericServlet;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class PostServlet extends GenericServlet {
    @Override
    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
        // 响应一些内容到浏览器上。
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();

        out.println("<!doctype html>");
        out.println("<html>");
        out.println("    <head>");
        out.println("        <title>from post servlet</title>");
        out.println("    </head>");
        out.println("    <body>");
        out.println("        <h1>from post servlet</h1>");
        out.println("    </body>");
        out.println("</html>");
    }
}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>getServlet</servlet-name>
        <servlet-class>oop1.GetServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>getServlet</servlet-name>
        <url-pattern>/getServlet</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>pServlet</servlet-name>
        <servlet-class>oop1.PostServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>pServlet</servlet-name>
        <url-pattern>/postServlet</url-pattern>
    </servlet-mapping>


</web-app>

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>http协议</title>
</head>
<body>

<!--注意：浏览器上编写的这个请求路径还是要带上应用的根路径。-->
<h1>get请求：</h1>
<form action="/Servlet06/getServlet" method="get">
    username<input type="text" name="username" /><br>
    password<input type="password" name="userpwd" /><br>
    <input type="submit" value="login">
</form>

<h1>post请求：</h1>
<form action="/Servlet06/postServlet" method="post">
    username<input type="text" name="username" /><br>
    password<input type="password" name="userpwd" /><br>
    <input type="submit" value="login">
</form>

</body>
</html>

⑵.HTTP响应协议的具体报文：

HTTP/1.1 200     ok                                                             状态行

Content-Type: text/html;charset=UTF-8                               响应头

Content-Length: 160

Date: Fri, 28 Mar 2025 02:41:14 GMT

Keep-Alive: timeout=20 Connection: keep-alive 

                                                                                             空白行

<!doctype html>                                                                    响应体
<html>
    <head>
        <title>from get servlet</title>
    </head>
    <body>
        <h1>from get servlet</h1>
    </body>
</html>

①状态行

  • 三部分组成

    • 第一部分：协议版本号（HTTP/1.1）

    • 第二部分：状态码（HTTP协议中规定的响应状态号。不同的响应结果对应不同的号码。）

      • 200 表示请求响应成功，正常结束。

      • 404表示访问的资源不存在，通常是因为要么是你路径写错了，要么是路径写对了，但是服务器中对应的资源并没有启动成功。总之404错误是前端错误。

      • 405表示前端发送的请求方式与后端请求的处理方式不一致时发生：

        • 比如：前端是POST请求，后端的处理方式按照get方式进行处理时，发生405

        • 比如：前端是GET请求，后端的处理方式按照post方式进行处理时，发生405

      • 500表示服务器端的程序出现了异常。一般会认为是服务器端的错误导致的。

      • 以4开始的，一般是浏览器端的错误导致的。

      • 以5开始的，一般是服务器端的错误导致的。

    • 第三部分：状态的描述信息

      • ok 表示正常成功结束。

      • not found 表示资源找不到。

②响应头：

  • 响应的内容类型

  • 响应的内容长度

  • 响应的时间

  • ....

③空白行：

用来分隔“响应头”和“响应体”的。

④响应体：

  • 响应体就是响应的正文，这些内容是一个长的字符串，这个字符串被浏览器渲染，解释并执行，最终展示出效果。

5.HTTP的请求协议（B（游览器） --> S（服务器））

⑴.HTTP的请求协议包括：4部分

- 请求行
- 请求头
- 空白行
- 请求体

⑵.HTTP请求协议的具体报文：GET请求

GET /Servlet06/getServlet?username=admin&userpwd=123 HTTP/1.1                    请求行

Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,请求头

image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7                                    

Accept-Encoding: gzip, deflate, br, zstd

Accept-Language: en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7

Cache-Control: max-age=0

Connection: keep-alive

Host: 127.0.0.1:8080

Referer: http://127.0.0.1:8080/Servlet06/index.html

Sec-Fetch-Dest: document

Sec-Fetch-Mode: navigate

Sec-Fetch-Site: same-origin

Sec-Fetch-User: ?1

Upgrade-Insecure-Requests: 1

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36

sec-ch-ua: "Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"

sec-ch-ua-mobile: ?0

sec-ch-ua-platform: "Windows"

                                                                                                                                       空白行

                                                                                                                                       请求体

⑶HTTP请求协议的具体报文：POST请求

                                                                                                                                       空白行

                                                                                                                                       请求体

①请求行

  • 包括三部分：

    • 第一部分：请求方式（7种）

      • get（常用的）

      • post（常用的）

      • delete

      • put

      • head

      • options

      • trace

    • 第二部分：URI

      • 什么是URI？ 统一资源标识符。代表网络中某个资源的名字。但是通过URI是无法定位资源的。

      • 什么是URL？统一资源定位符。代表网络中某个资源，同时，通过URL是可以定位到该资源的。

URI（Uniform Resource Identifier）即统一资源标识符，而 URL（Uniform Resource Locator）是统一资源定位符。下面为你详细介绍二者的概念、联系和区别。

概念

  • URI：是一种用于标识某一互联网资源名称的字符串。该种标识允许用户对任何（包括本地和互联网）的资源通过特定的协议进行交互操作。
  • URL：是 URI 的一个子集，它不仅标识了一个资源，还指明了如何访问该资源的具体位置和方式。例如，通过 HTTP、FTP 等协议来获取资源。

联系

URL 属于 URI 的范畴，每个 URL 都是一个 URI，但并非每个 URI 都是 URL。也就是说，URL 是一种具体的、能够定位资源位置的 URI。

区别

  • 功能范围：
    • URI 的功能是对资源进行唯一标识，不关注资源的获取方式。
    • URL 不仅要标识资源，还要提供资源的具体位置和访问方式。
  • 示例差异：
    • URI 示例：mailto:info@example.com，它只是标识了一个邮件地址资源，没有说明如何获取邮件内容。
    • URL 示例：https://www.example.com/index.html，不仅标识了网页资源，还说明了通过 HTTPS 协议在www.example.com服务器上获取index.html文件。
②请求头

  • 请求的主机

  • 主机的端口

  • 浏览器信息

  • 平台信息

  • cookie等信息

  • ....

③空白行

  • 空白行是用来区分“请求头”和“请求体”

④请求体

  • 空白行是用来区分“请求头”和“请求体”

6.怎么向服务器发送GET请求，怎么向服务器发送POST请求？

  • 到目前为止，只有一种情况可以发送POST请求：使用form表单，并且form标签中的method属性值为：method="post"。

  • 其他所有情况一律都是get请求：

    • 在浏览器地址栏上直接输入URL，敲回车，属于get请求。

    • 在浏览器上直接点击超链接，属于get请求。

    • 使用form表单提交数据时，form标签中没有写method属性，默认就是get

    • 或者使用form的时候，form标签中method属性值为：method="get"

    • ....

7.GET请求和POST请求有什么区别？

  • get请求发送数据的时候，数据会挂在URI的后面，并且在URI后面添加一个“?”，"?"后面是数据。这样会导致发送的数据回显在浏览器的地址栏上。（get请求在“请求行”上发送数据）

  • post请求发送数据的时候，在请求体当中发送。不会回显到浏览器的地址栏上。也就是说post发送的数据，在浏览器地址栏上看不到。（post在“请求体”当中发送数据）

  • get请求只能发送普通的字符串。并且发送的字符串长度有限制，不同的浏览器限制不同。这个没有明确的规范。

  • get请求无法发送大数据量。

  • post请求可以发送任何类型的数据，包括普通字符串，流媒体等信息：视频、声音、图片。

  • post请求可以发送大数据量，理论上没有长度限制。

  • get请求在W3C中是这样说的：get请求比较适合从服务器端获取数据。

  • post请求在W3C中是这样说的：post请求比较适合向服务器端传送数据。

  • get请求是安全的。get请求是绝对安全的。为什么？因为get请求只是为了从服务器上获取数据。不会对服务器造成威胁。（get本身是安全的，你不要用错了。用错了之后又冤枉人家get不安全，你这样不好（太坏了），那是你自己的问题，不是get请求的问题。）

  • post请求是危险的。为什么？因为post请求是向服务器提交数据，如果这些数据通过后门的方式进入到服务器当中，服务器是很危险的。另外post是为了提交数据，所以一般情况下拦截请求的时候，大部分会选择拦截（监听）post请求。

  • get请求支持缓存。

  • post请求不支持缓存。（POST是用来修改服务器端的资源的。）

    • post请求之后，服务器“响应的结果”不会被浏览器缓存起来。因为这个缓存没有意义。

8.GET请求和POST请求如何选择，什么时候使用GET请求，什么时候使用POST请求？

  • 怎么选择GET请求和POST请求呢？衡量标准是什么呢？你这个请求是想获取服务器端的数据，还是想向服务器发送数据。如果你是想从服务器上获取资源，建议使用GET请求，如果你这个请求是为了向服务器提交数据，建议使用POST请求。

  • 大部分的form表单提交，都是post方式，因为form表单中要填写大量的数据，这些数据是收集用户的信息，一般是需要传给服务器，服务器将这些数据保存/修改等。

  • 如果表单中有敏感信息，还是建议适用post请求，因为get请求会回显敏感信息到浏览器地址栏上。（例如：密码信息）

  • 做文件上传，一定是post请求。要传的数据不是普通文本。

  • 其他情况都可以使用get请求。

9.不管你是get请求还是post请求，发送的请求数据格式是完全相同的，只不过位置不同，格式都是统一的：

  • name=value&name=value&name=value&name=value

  • name是什么？

    • 以form表单为例：form表单中input标签的name。

  • value是什么？

    • 以form表单为例：form表单中input标签的value。

二、模板方法设计模式

1.什么是设计模式？

  • 某个问题的固定的解决方案。(可以被重复使用。)

2.你知道哪些设计模式？

    • GoF设计模式：

      • 通常我们所说的23种设计模式。（Gang of Four：4人组提出的设计模式）

      • 单例模式

      • 工厂模式

      • 代理模式

      • 门面模式

      • 责任链设计模式

      • 观察者模式

      • 模板方法设计模式

      • .....

    • JavaEE设计模式：

      • DAO

      • DTO

      • VO

      • PO

      • pojo

      • ....

    • ....

  • 什么是模板方法设计模式？

    • 在模板类的模板方法当中定义核心算法骨架，具体的实现步骤可以延迟到子类当中完成。

  • 模板类通常是一个抽象类，模板类当中的模板方法定义核心算法，这个方法通常是final的（但也可以不是final的）

  • 模板类当中的抽象方法就是不确定实现的方法，这个不确定怎么实现的事儿交给子类去做。

抽象类Person

package template2;

/**
 * Teacher和Student都是Person
 * 1. Person就是模板方法设计模式当中的模板类。
 * 2. day()方法就是模板方法设计模式当中的模板方法。
 */
public abstract class Person { // 模板类通常是抽象类。

    // 模板方法
    // 添加了final之后，这个方法无法被覆盖，这样核心的算法也可以得到保护。
    // 模板方法定义核心的算法骨架，具体的实现步骤可以延迟到子类当中去实现。
    // 核心算法一方面是得到了保护，不能被改变。另外一方面就是算法得到了重复使用。
    // 另外代码也得到了服用，因为算法中某些步骤的代码是固定的。这些固定的代码不会随着子类的变化而变换，这一部分代码可以写到模板类当中。
    public final void day(){
        // 第一步
        qiChuang();
        // 第二步
        xiShu();
        // 第三步
        chiZaoCan();
        // 第四步
        doSome();
        // 第五步
        chiWanFan();
        // 第六步
        shuiJiao();
    }

    // 其中的某些步骤，不会随着子类的变化而变化，这些代码可以写到父类中，得到代码复用。
    public void qiChuang(){
        System.out.println("起床");
    }

    public void xiShu(){
        System.out.println("洗漱");
    }

    public void chiZaoCan(){
        System.out.println("吃早餐");
    }

    // 这一步是要做，但是具体这一步怎么做，子类说了算。
    public abstract void doSome();

    public void chiWanFan(){
        System.out.println("吃晚饭");
    }

    public void shuiJiao(){
        System.out.println("睡觉");
    }
}

Student类

package template2;

public class Student extends Person {

    public void doSome(){
        System.out.println("学生上学，学习");
    }

}

Teacher类

package template2;

public class Teacher extends Person{

    public void doSome(){
        System.out.println("老师正在课堂上授课，教授学生知识");
    }

}

测试类Test

package template2;

public class Test {
    public static void main(String[] args) {
        Person p1 = new Teacher();
        p1.day();
        System.out.println("-----------------");
        Person p2 = new Student();
        p2.day();
    }
}

三、HttpServlet源码分析

  • HttpServlet类是专门为HTTP协议准备的。比GenericServlet更加适合HTTP协议下的开发。

  • HttpServlet在哪个包下？

    • jakarta.servlet.http.HttpServlet

1.到目前为止我们接触了servlet规范中哪些接口？

  • jakarta.servlet.Servlet 核心接口（接口）

  • jakarta.servlet.ServletConfig Servlet配置信息接口（接口）

  • jakarta.servlet.ServletContext Servlet上下文接口（接口）

  • jakarta.servlet.ServletRequest Servlet请求接口（接口）

  • jakarta.servlet.ServletResponse Servlet响应接口（接口）

  • jakarta.servlet.ServletException Servlet异常（类）

  • jakarta.servlet.GenericServlet 标准通用的Servlet类（抽象类）

2.http包下都有哪些类和接口呢？jakarta.servlet.http.*;

  • jakarta.servlet.http.HttpServlet （HTTP协议专用的Servlet类，抽象类）

  • jakarta.servlet.http.HttpServletRequest （HTTP协议专用的请求对象）

  • jakarta.servlet.http.HttpServletResponse （HTTP协议专用的响应对象）

3.HttpServletRequest对象中封装了什么信息？

  • HttpServletRequest，简称request对象。

  • HttpServletRequest中封装了请求协议的全部内容。

  • Tomcat服务器（WEB服务器）将“请求协议”中的数据全部解析出来，然后将这些数据全部封装到request对象当中了。

  • 也就是说，我们只要面向HttpServletRequest，就可以获取请求协议中的数据。

4.HttpServletResponse对象是专门用来响应HTTP协议到浏览器的。

5.回忆Servlet生命周期？

  • 用户第一次请求

    • Tomcat服务器通过反射机制，调用无参数构造方法。创建Servlet对象。(web.xml文件中配置的Servlet类对应的对象。)

    • Tomcat服务器调用Servlet对象的init方法完成初始化。

    • Tomcat服务器调用Servlet对象的service方法处理请求。

  • 用户第二次请求

    • Tomcat服务器调用Servlet对象的service方法处理请求。

  • 用户第三次请求

    • Tomcat服务器调用Servlet对象的service方法处理请求。

  • ....

    • Tomcat服务器调用Servlet对象的service方法处理请求。

  • 服务器关闭

    • Tomcat服务器调用Servlet对象的destroy方法，做销毁之前的准备工作。

    • Tomcat服务器销毁Servlet对象。

6.HttpServlet源码分析：

public class HelloServlet extends HttpServlet {
	// 用户第一次请求，创建HelloServlet对象的时候，会执行这个无参数构造方法。
	public HelloServlet() {
    }
    
    //override 重写 doGet方法
    //override 重写 doPost方法
}

public abstract class GenericServlet implements Servlet, ServletConfig,
        java.io.Serializable {
           
	// 用户第一次请求的时候，HelloServlet对象第一次被创建之后，这个init方法会执行。
    public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }
	// 用户第一次请求的时候，带有参数的init(ServletConfig config)执行之后，会执行这个没有参数的init()
	public void init() throws ServletException {
        // NOOP by default
    }
}

// HttpServlet模板类。
public abstract class HttpServlet extends GenericServlet {
    // 用户发送第一次请求的时候这个service会执行
    // 用户发送第N次请求的时候，这个service方法还是会执行。
    // 用户只要发送一次请求，这个service方法就会执行一次。
    @Override
    public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {

        HttpServletRequest  request;
        HttpServletResponse response;

        try {
            // 将ServletRequest和ServletResponse向下转型为带有Http的HttpServletRequest和HttpServletResponse
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            throw new ServletException(lStrings.getString("http.non_http"));
        }
        // 调用重载的service方法。
        service(request, response);
    }
    
    // 这个service方法的两个参数都是带有Http的。
    // 这个service是一个模板方法。
    // 在该方法中定义核心算法骨架，具体的实现步骤延迟到子类中去完成。
    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 获取请求方式
        // 这个请求方式最终可能是：""
        // 注意：request.getMethod()方法获取的是请求方式，可能是七种之一：
        // GET POST PUT DELETE HEAD OPTIONS TRACE
        String method = req.getMethod();

        // 如果请求方式是GET请求，则执行doGet方法。
        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                } catch (IllegalArgumentException iae) {
                    // Invalid date header - proceed as if none was set
                    ifModifiedSince = -1;
                }
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            // 如果请求方式是POST请求，则执行doPost方法。
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);

        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }
    
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException{
        // 报405错误
        String msg = lStrings.getString("http.method_get_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 报405错误
        String msg = lStrings.getString("http.method_post_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
}

/*
通过以上源代码分析：
	假设前端发送的请求是get请求，后端程序员重写的方法是doPost
	假设前端发送的请求是post请求，后端程序员重写的方法是doGet
	会发生什么呢？
		发生405这样的一个错误。
		405表示前端的错误，发送的请求方式不对。和服务器不一致。不是服务器需要的请求方式。
	
	通过以上源代码可以知道：只要HttpServlet类中的doGet方法或doPost方法执行了，必然405.

怎么避免405的错误呢？
	后端重写了doGet方法，前端一定要发get请求。
	后端重写了doPost方法，前端一定要发post请求。
	这样可以避免405错误。
	
	这种前端到底需要发什么样的请求，其实应该后端说了算。后端让发什么方式，前端就得发什么方式。
	
有的人，你会看到为了避免405错误，在Servlet类当中，将doGet和doPost方法都进行了重写。
这样，确实可以避免405的发生，但是不建议，405错误还是有用的。该报错的时候就应该让他报错。
如果你要是同时重写了doGet和doPost，那还不如你直接重写service方法好了。这样代码还能
少写一点。
*/

  • 我们编写的HelloServlet直接继承HttpServlet，直接重写HttpServlet类中的service()方法行吗？

    • 可以，只不过你享受不到405错误。享受不到HTTP协议专属的东西。

⑴示例代码：HelloServlet直接继承HttpServlet，直接重写HttpServlet类中的service()方法

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>helloServlet</servlet-name>
        <servlet-class>oop1.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>helloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>loginServlet</servlet-name>
        <servlet-class>oop1.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>loginServlet</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>
    
    
</web-app>

HelloServlet类：重写HttpServlet类中的service()方法

package oop1;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class HelloServlet extends HttpServlet {
    // 通过无参数构造方法创建对象。
    /*public HelloServlet() {
    }*/
    // 没有提供init方法，那么必然执行父类HttpServlet的init方法。
    // HttpServlet类中没有init方法，会继续执行GenericServlet类中的init方法。

    // 没有提供service方法。那么必然执行父类HttpServlet类service方法。

        @Override
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.print("<h1>hello servlet</h1>");
    }



}

⑵不重写HttpServlet类中的service()方法，发get请求，而后端只有dopost的方法，会出现的问题如下。

HelloServlet类;只有dopost方法

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class HelloServlet extends HttpServlet {
    // 通过无参数构造方法创建对象。
    /*public HelloServlet() {
    }*/
    // 没有提供init方法，那么必然执行父类HttpServlet的init方法。
    // HttpServlet类中没有init方法，会继续执行GenericServlet类中的init方法。

    // 没有提供service方法。那么必然执行父类HttpServlet类service方法。


    // 当前端发送的请求是post请求的时候，我这里重写doPost方法。
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException{
        PrintWriter out = response.getWriter();
        out.print("<h1>doPost</h1>");
    }



}

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>index page</title>
</head>
<body>

<h1>get请求</h1>
<a href="/servlet066/hello">hello(get请求)</a><br>

<h1>post请求</h1>
<form action="/servlet066/hello" method="post">
    <input type="submit" value="hello">
</form>

</body>
</html>

doGet方法是 Servlet 中处理 HTTP GET 请求的方法。此方法的作用是告知客户端当前 Servlet 不支持 HTTP GET 请求

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // 获取提示消息，表明不支持GET方法
    String msg = lStrings.getString("http.method_get_not_supported");
    // 调用sendMethodNotAllowed方法，向客户端发送不支持GET方法的响应
    this.sendMethodNotAllowed(req, resp, msg);
}

直接重写 service() 方法的问题 —— 通俗解释

直接重写 HttpServlet 的 service() 方法是可以的，但会导致两个关键问题：

1. 你失去了“405 Method Not Allowed”错误（HTTP协议专属的错误）

通俗比喻：
假设你开了一家餐厅，服务员（service() 方法）负责接收客人的点餐请求。

  • 正常流程：
    服务员会根据客人需求（GET、POST等HTTP方法）把订单分发给对应的厨师（doGet()、doPost()方法）。
    如果客人点了一道没有厨师能做的菜（比如用 DELETE 方法请求一个只支持 GET 的接口），服务员会直接拒绝：“我们没有这项服务！”（返回 405 错误）。

  • 直接重写 service() 的后果：
    你亲自当服务员，但没有分发给厨师的逻辑。无论客人要什么（任何HTTP方法），你都自己处理。
    如果客人点了 DELETE，但你根本不会做这道菜，你可能会硬着头皮随便上盘菜（比如返回200，但逻辑混乱），而不是明确告诉客人“我们不做这个”（405错误）。

2. 你失去了HTTP协议专属的分发逻辑

核心问题：
HttpServlet 的 service() 方法内部已经帮你实现了HTTP协议的分发逻辑：

// HttpServlet 的源码逻辑（简化版）
protected void service(HttpServletRequest req, HttpServletResponse resp) {
    String method = req.getMethod();
    if (method.equals("GET")) {
        doGet(req, resp);  // 调用你的 doGet()
    } else if (method.equals("POST")) {
        doPost(req, resp); // 调用你的 doPost()
    }
    // ...其他方法（PUT、DELETE等）
}

  • 直接重写 service()：
    你会覆盖这段分发逻辑，所有HTTP方法（GET、POST等）都会直接进入你的 service() 方法，而不会自动调用 doGet()、doPost()。
    HTTP协议的方法分派机制完全失效。

正确的做法：重写 doGet()、doPost() 等具体方法

为什么？

  • 你只需关注具体的业务逻辑（比如处理GET请求的代码写在 doGet() 中）。

  • HttpServlet 的 service() 会自动帮你处理HTTP协议细节（比如检查方法是否支持、返回405错误）。

代码示例：

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        // 处理GET请求
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        // 处理POST请求
    }
}
总结
做法 结果
直接重写 service() 手动处理所有HTTP方法，失去协议支持（如405错误）。
重写 doGet()、doPost() 自动享受HTTP协议的分发和错误处理，代码更简洁、更专业。

除非你有特殊需求（比如统一处理所有HTTP方法），否则不要重写 service()！

通俗解释：为什么方法不匹配会导致405？如何避免？

1. 为什么方法不匹配会导致405错误？

类比场景：
假设你点外卖时：

  • **你点的是“红烧肉”（GET请求），但商家（后端）只做了“清蒸鱼”（只重写了 doPost()）。

  • 商家说：“我们没有红烧肉这道菜！”（返回 405错误）。

代码逻辑：

  • HttpServlet 的 service() 方法会根据请求类型（GET/POST）调用对应的 doGet() 或 doPost()。

  • 如果后端没有重写对应的方法（比如前端发GET，但后端只重写了 doPost()），则会调用父类（HttpServlet）的默认 doGet() 方法，而它的默认实现就是直接返回 405错误。

结论：

  • 405错误是HTTP协议的保护机制，明确告诉前端：“你发来的请求方式，我不支持！”

2. 如何正确避免405错误？

核心原则：
前后端HTTP方法必须一致！

  • 后端重写 doGet() → 前端必须发GET请求。

  • 后端重写 doPost() → 前端必须发POST请求。

代码示例：

public class MyServlet extends HttpServlet {
    // 只处理GET请求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        System.out.println("处理GET请求！");
    }
}

前端配合：

<!-- 前端必须用GET方式请求 -->
<a href="/myServlet">GET请求</a>  <!-- 超链接默认是GET -->
3. 为什么“同时重写doGet和doPost”不是好主意？

问题：

  • 假设你同时重写了 doGet() 和 doPost()，无论前端发什么方法，都会处理。

  • 掩盖了错误：如果前端错误地用了PUT/DELETE等不支持的方法，本该返回405，但现在不会报错（因为你只处理了GET/POST）。

代码示例（反面教材）：

public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(...) { /* 处理GET */ }
    @Override
    protected void doPost(...) { /* 处理POST */ }
}

后果：

  • 前端发 DELETE 请求 → 父类 HttpServlet 的 doDelete() 被调用 → 默认返回405。

  • 但如果你想让这个Servlet支持 DELETE，应该重写 doDelete()，而不是同时重写GET/POST。

4. 直接重写service()方法可行吗？

直接重写 service() 的优缺点：

  • 优点：代码更少，一个方法处理所有请求。

public class MyServlet extends HttpServlet {
    @Override
    protected void service(...) {
        // 手动处理所有GET/POST/PUT...
    }
}

  • 缺点：

    1. 失去HTTP方法自动分发：需要自己写 if-else 判断请求类型（GET/POST）。

    2. 可能隐藏错误：比如前端发 DELETE，但你在 service() 中没有处理，却返回200，而不是405。

结论：

  • 除非你有特殊需求（比如统一处理所有请求），否则不要重写 service()！

  • 遵循HTTP协议的标准做法（重写 doGet()/doPost()）更专业、更安全。

最终总结表

做法 优点 缺点
只重写 doGet() 或 doPost() 自动支持405错误，符合HTTP协议规范 需要前后端方法一致
同时重写 doGet() 和 doPost() 支持GET/POST两种请求 掩盖其他方法的错误（如DELETE该报405时不报错）
直接重写 service() 代码量少，自由度高 需要手动处理所有方法，容易出错

最佳实践：

  • 该报错时就报错：405错误是HTTP协议的重要反馈，不要掩盖它！

  • 前后端协商一致：后端定义支持的请求方式，前端严格遵守。

  • 到今天我们终于得到了最终的一个Servlet类的开发步骤：

    • 第一步：编写一个Servlet类，直接继承HttpServlet

    • 第二步：重写doGet方法或者重写doPost方法，到底重写谁，javaweb程序员说了算。

    • 第三步：将Servlet类配置到web.xml文件当中。

    • 第四步：准备前端的页面（form表单），form表单中指定请求路径即可。

LoginServlet 类

package oop1;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class LoginServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 代码随意
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.print("<h1>登录成功...</h1>");
    }
}

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>helloServlet</servlet-name>
        <servlet-class>oop1.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>helloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>loginServlet</servlet-name>
        <servlet-class>oop1.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>loginServlet</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>


</web-app>

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>login page</title>
</head>
<body>

<form action="/servlet066/login" method="post">
    <input type="submit" value="login">
</form>

</body>
</html>

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布