[Java知识库]JavaWeb | 七个步骤，完成一个servlet的hello world程序

Servlet 是一种实现动态页面的技术，是一组 Tomcat 提供给程序猿的 API，帮助程序猿简单高效的开发一
个 web app

动态页面 vs 静态页面：

• 静态页面也就是内容始终固定的页面，即使 用户不同/时间不同/输入的参数不同 , 页面内容也不会发生
  变化 (除非网站的开发人员修改源代码，否则页面内容始终不变)
• 对应的，动态页面指的就是 用户不同/时间不同/输入的参数不同，页面内容会发生变化

构建动态页面的技术有很多，每种语言都有一些相关的库 / 框架来做这件事
Servlet 就是 Tomcat 这个 HTTP 服务器提供给 Java 的一组 API，来完成构建动态页面这个任务

Servlet 主要做的工作：

• 允许程序猿注册一个类，在 Tomcat 收到某个特定的 HTTP 请求的时候，执行这个类中的一些代码
• 帮助程序猿解析 HTTP 请求，把 HTTP 请求从一个字符串解析成一个 HttpRequest 对象
• 帮助程序猿构造 HTTP 响应，程序猿只要给指定的 HttpResponse 对象填写一些属性字段，Servlet
• 就会自动的安装 HTTP 协议的方式构造出一个 HTTP 响应字符串，并通过 Socket 写回给客户端

简而言之，Servlet 是一组 Tomcat 提供的 API, 让程序猿自己写的代码能很好的和 Tomcat 配合起来，从而更简单的实现一个 web app
而不必关注 Socket，HTTP协议格式，多线程并发等技术细节，降低了 web app 的开发门槛，提高了开发效率

Hello World!

1、创建一个 maven 项目

2、引入依赖

需要在代码中引入 Servlet api，这个 api 不是 JDK 内置的，而是第三方 (Tomcat 提供的)
Tomcat 相对于 Java 官方来说，仍然属于第三方

借助 maven 直接就能引入，搜索 servlet 第一个就是，

使用此版本：

JDK，Tomcat，Servlet 版本要配套，如果版本不太配套，可能就存在一些问题~~
(不是完全用不了，大概率是大部分功能都正常，但是少数功能有 bug )

• JDK 8
• Tomcat 8.5
• Servlet 3.1

maven 默认仓库的位置：

3、创建目录结构

• 虽然当下 maven 帮我们创建了一些目录，但是还不够，还不足以支撑咱们写一个 Servlet 项目，
• 因此需要手动的再创建一些目录和文件出来~~
  也有更简单的办法，但是此处先不介绍，先用最朴素的方式，手动搞好

——在 main 下创建一个目录 webapp 。Tomcat 可以同时加载多个 webapp 的，因此目录是 webapps 的 (每个 webapp 就相当于一个网站了)，因为此处咱们写的是一个 webapp 就没有 s

——第二个目录 WEB-INF

——创建文件 web.xml

接下来，需要给 web.xml 中写点内容 (不能是空着的)

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <display-name>Archetype Created Web Application</display-name>
</web-app>

4、编写 Servlet 代码

// 如果代码中找不到 HttpServlet 这个类 说明依赖没有被正确引入
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // super.doGet(req, resp);
    }
}

do：处理
Get 对应到 HTTP 的 GET 方法
这个方法就是在 Tomcat 收到了一个 HTTP GET 请求 的时候，会被 Tomcat 调用到 (回调函数)

HttpServletRequest ：代表一个 HTTP 请求 (Tomcat 已经收到了，已经解析成对象了)

HttpServletResponse ：代表着 HTTP 响应 (当前这里的 resp 是一个空的响应对象，需要在代码中给这个对象设置一些属性的)

doGet 方法要做的工作，就是根据请求，计算生成响应~~

一个服务器的工作流程，就可以分成三个典型的步骤：

1. 接收请求并解析
2. 根据请求计算响应
3. 构造响应数据，并返回给客户端

其中，1 3 这两步，Tomcat 已经帮我们做好了，这个就是咱们程序猿自己要实现的逻辑，也就是 doGet 要实现的内容~~

服务器想象成一个餐馆~~
服务器上运行的代码，就要处理一个一个的请求~~

当老板收到 “来份炸酱面” 这个请求之后，后厨就行动起来了，根据客户提出的要求，来把这个炸酱面给做出来~

后厨这里，有个师傅负责切菜，有个师傅负责拉面，再有个师傅负责炸酱，再来个师傅把这里的结果给进行集成~~

服务员就可以把这份面端给我了~~

这三个师傅并发的工作，相当于三个线程!!

@WebServlet("/hello")
// 如果代码中找不到 HttpServlet 这个类 说明依赖没有被正确引入
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 这个代码一定要干掉！ 不能调用父类的 doGet！
        // super.doGet(req, resp);

        // 这是让服务器在自己的控制台里打印
        System.out.println("hello world!");

        // 在页面上也能打印，把 hello world! 字符串放到 http 响应的 body 中，浏览器就会把 body 的内容显示到页面上
        resp.getWriter().write("hello word!" + System.currentTimeMillis());
    }
}

resp 是响应对象
getWriter 其实是返回了一个 Writer 对象 (字符流对象)
此处 Writer 对象就不是往文件里写了，而是往 HTTP 响应的 body 中写入数据
write() 是真正的干活，写数据的方法

1、 @WebServlet("/hello")

把当前的这个 HelloServlet 这个类，和 HTTP 请求中的 URL 里面路径带有 /hello 这样的请求，给关联起来了

• Tomcat 可能会受到很多种形形色色的请求
  /123 http://123.123.123.123:8080/123
  /aaa http://123.123.123.123:8080/aaa
  /test http://123.123.123.123:8080/test
• 这么多请求，咱们的代码只管其中的一种情况：/hello http://123.123.123.123:8080/hello
  才会让 Tomcat 来调用 HelloServlet 这个类，来进行处理

2、 保证方法统一

• /hello 是和 HelloServlet 这个类关联起来了
• 但是要想执行到 doGet，还得保证方法也是 GET 方法~~
• 如果是 POST，/hello，仍然无法执行到doGet ~~

5、打包

• 当前的代码，是不能单独运行的 (没有 main 方法)
• 需要把当前的代码，打包，然后部署到 Tomcat 上，由 Tomcat 来进行调用

准备工作： 修改 pom.xml~~

jar 和 war 都是 java 发布程序用的压缩包格式
war 算是给 Tomcat 专门搞的，这里不光会包含一些 .class，还可以包含配置文件，以及依赖的第三方的 jar，还有 html css …

双击这个 package 触发打包

提示 BUILD SUCCESS 说明打包成功!!

6、部署

把 war 包 拷贝到 tomcat 的 webapps 目录下，启动 Tomcat

7、验证程序

咱们访问 Tomcat 的时候，是需要指定两级目录的

• Context Path：之所以，咱们的第一级路径叫做 hello102，是因为咱们 war 包名字就是 hello102，war 同时解压缩之后得到的路径也就是 hello102

• Servlet Path：@WebServlet("/hello") 这个注解 ，是和第二级路径相匹配的

可以这样认为：
一个 Tomcat 上可以同时部署多个网站，一个网站上又有多个页面~~
一个请求中的第一级路径，就告诉 Tomcat，要访问的网站是哪个，第二级路径，就告诉 Tomcat 要访问的页面是这个网站中的哪个页面

访问：http://127.0.0.1:8080/hello102/hello

没有成功，此时在 tomcat 控制台这里，敲了一下回车就出来了，显示的 hello world 就是返回的 HTTP 响应的 body 部分

这个情况是属于 cmd 的一个大坑!!!

CMD 有一个 “选择文本” 这样的模式

鼠标选中其中的一段文本，就会触发 CMD 的选中文本模式~~
当 CMD 被选中文本的时候，CMD 就会把里面运行的程序给挂起 (暂停了，不往下走了)

• 现在这个页面内容是通过 Java 代码生成的了，但是这和你直接创建一个 HTML，里面写个 hello world 有啥区别呢??
• 页面里的内容是固定死的，是静态的，是不变的~~
• 这里的内容是可变的!!
• 根据用户不同的输入，可以得到不同的结果!!!

修改代码：获取时间戳

resp.getWriter().write("hello word!" + System.currentTimeMillis());

上述这七个步骤，这是针对一个新的项目~~
项目创建好之后，后续修改代码，前三个步骤就不必重复了，直接从 4 - 7 进行操作即可~~
重新部署的时候，不一定要重启，tomcat (理论上来说，是不需要重启的，但是 Windows 系统多少有点不顺畅的地方~~ ，一般在 Linux上，这个都是能顺利自动重新加载的~~)

如果看到形如这样的提示~~ 就已经重新部署了，deploy：部署

显示结果：hello word!1653073391039

smart tomcat

1、介绍

上面介绍的步骤，其实都是最朴素的操作了~~
因此也有一些办法，来提高上述流程的效率，就可以通过一些第三方工具来简化 5 和 6 的操作，毕竟每次修改代码，都需要重新打包，重新部署~~

咱们是通过 IDEA 上的插件，直接把 Tomcat 给集成进来了~~ 做到 “一键式” 完成打包部署了~~

注意： Tomcat 和 IDEA 是两个独立的程序!!! Tomcat 不是 IDEA 功能的一部分!!

后面开发，主要还是通过 IDEA 调用 Tomcat 的方式来进行
用的时间长了之后，同学们就对于 Tomcat 的印象，就开始模糊~~

smart tomcat 是 idea 的一个插件
idea 本身虽然已经有很多功能了，但是也不能做到，面面俱到!!
因此，idea 还提供了一系列的扩展能力，允许第三方来开发一些程序，交给 idea 运行，相当于对 idea 进行了扩展~~

• smart tomcat 并不是真的打包了~～

• 其实相当于把 webapp 目录作为 tomcat 启动的一个参数，给设定进去了，让 tomcat 直接从这个指定目录中加载 webapp

• Tomcat 默认是从 webapps 中加载 war 包，也不是只有这一条路~~

• 因此当你去看 Tomcat 的 webapps 目录，就会发现其实没有你的 war~~(不像手动拷贝)

2、安装

3、使用 smart tomcat

• 在一个项目中，首次使用，需要先简单配置，后续就不必再配了~~

• 当使用 Smart Tomcat 之后，Context Path 就不是 war 包名字了，而是在 Smart Tomcat 配置页面中指定的名字

点击这里的三角号，就会自动完成打包部署重启 tomcat 这一系列操作

报错信息：Caused by: java.net.BindException: Address already in use: bind

如果一个端口，已经被服务器绑定了，再次启动一个程序绑定同一个端口，就会出现这个错误!!!

当下存在这个问题，是因为已经在命令行里启动了一个 Tomcat 了
如果在 idea 中再启动一个，显然端口是不能重复占用的

此时就没有问题，这些文字，在 cmd 中乱码，但是在 idea 的终端中就不再乱码了

org.apache.catalina.util.SessionIdGeneratorBase.createSecureRandom 使用[SHA1PRNG]创建会话ID生成的SecureRandom实例花费了[103]毫秒。
21-May-2022 03:36:58.905 信息 [main] org.apache.coyote.AbstractProtocol.start 开始协议处理句柄["http-nio-8080"]
21-May-2022 03:36:58.915 信息 [main] org.apache.catalina.startup.Catalina.start Server startup in 370 ms
http://localhost:8080/hello102

常见出错问题汇总

1、404

你要访问的资源在服务器上不存在

错误 1： 你请求的资源路径写的不对

错误 2： 路径虽然对，但是服务器没有正确把资源加载起来~~

少些了第一级路径 Context Path：

少写了第二级路径 Servlet Path：

错误 3： Servlet Path 写的和 URL 不匹配

请求的路径和服务器这边的配置不匹配：

错误 4： web.xml 写错了

当 web.xml 有问题的时候，tomcat 是不能正确加载到 webapp的~~
tomcat 发现这个目录中存在了 web.xml 且内容正确，tomcat 才能加载这个 webapp

2、405 —— Method Not Allowed

指 HTTP 中的方法

错误 1： 将 doGet 改成 doPost：

这样的用户操作，浏览器是构造了一个 GET 请求，而服务器这里写的是 doPost，不能处理 GET 请求~~

什么时候浏览器发的是 GET 请求?

1. 直接在地址栏里，输入 URL

2. 通过 a 标签跳转

3. 通过 img/link/script…

4. 通过 form 表单，method 指定为 GET

5. 通过 ajax，type 指定为 GET

什么时候浏览器发的是POST请求?

1. 通过form表单, method指定为POST
2. 通过ajax, type指定为POST

错误 2： 如果是代码中忘记注释掉 super.doGet(req, resp)，这样的情况也会出现 405 !!!

进入到 HttpServlet 源码中，就能看到，此处父类的 doGet，干的事就是直接返回一个 405 的响应!!!

3、500

500 也是一个非常高频的错误，5 开头，是服务器出了问题
一般 500 就意味着服务器代码里抛出异常了，并且咱们的代码没处理，异常抛到 Tomcat 这里了~~

比如：如果代码中出现异常，可以通过 catch 来捕获到
如果 catch 没捕获到(类型不匹配，压根没 catch)，异常就会沿着调用栈，向上传递

如果代码出现 500，就偷着乐吧，这种情况是最好解决的了!! 因为它直接告诉你,哪里有问题了!!!

异常的调用栈 (平时写代码的时候，IDEA 里出现的异常调用栈)，告诉了我们出现异常的准确位置

4、空白页面

如果不给响应对象中设置任何内容，就会出现 空白页面

5、无法访问此网站

• 如果是这个情况，证明，网络就不通 (TCP 的层次上就是不通)
• 其中一个很大的可能性，就是 Tomcat 没有正确启动 (比如 Tomcat 端口被占用、启动失败……)

Servlet 运行原理

Servlet 是属于上层建筑，下面的传输层，网络层，数据链路层… 属于经济基础

• 当浏览器给服务器发送请求的时候，Tomcat 作为 HTTP 服务器，就可以接收到这个请求

HTTP 协议作为一个应用层协议，需要底层协议栈来支持工作，如下图所示：

Tomcat 其实是一个应用程序，运行在用户态的普通进程 (Tomcat 其实也是一个 Java进程)
用户写的代码 (根据请求计算相应)，通过 Servlet 和 Tomcat 进行交互~~
Tomcat 进一步的和浏览器之间的网络传输，仍然是走的网络原理中的那一套：封装和分用

更详细的交互过程可以参考下图：

1. 接收请求:

   • 用户在浏览器输入一个 URL, 此时浏览器就会构造一个 HTTP 请求.
   • 这个 HTTP 请求会经过网络协议栈逐层进行 封装 成二进制的 bit 流, 最终通过物理层的硬件设备转换成光信号/电信号传输出去.
   • 这些承载信息的光信号/电信号通过互联网上的一系列网络设备, 最终到达目标主机(这个过程也需要网络层和数据链路层参与).
   • 服务器主机收到这些光信号/电信号, 又会通过网络协议栈逐层进行 分用, 层层解析, 最终还原成HTTP 请求. 并交给 Tomcat 进程进行处理(根据端口号确定进程)
   • Tomcat 通过 Socket 读取到这个请求(一个字符串), 并按照 HTTP 请求的格式来解析这个请求, 根据
     请求中的 Context Path 确定一个 webapp, 再通过 Servlet Path 确定一个具体的 类. 再根据当前请
     求的方法 (GET/POST/…), 决定调用这个类的 doGet 或者 doPost 等方法. 此时我们的代码中的
     doGet / doPost 方法的第一个参数 HttpServletRequest 就包含了这个 HTTP 请求的详细信息

2. 根据请求计算响应:

   • 在我们的 doGet / doPost 方法中, 就执行到了我们自己的代码. 我们自己的代码会根据请求中的一
     些信息, 来给 HttpServletResponse 对象设置一些属性. 例如状态码, header, body 等.

3. 返回响应:

   • 我们的 doGet / doPost 执行完毕后, Tomcat 就会自动把 HttpServletResponse 这个我们刚设置好的对象转换成一个符合 HTTP 协议的字符串, 通过 Socket 把这个响应发送出去.
   • 此时响应数据在服务器的主机上通过网络协议栈层层 封装, 最终又得到一个二进制的 bit 流, 通过物理层硬件设备转换成光信号/电信号传输出去.
   • 这些承载信息的光信号/电信号通过互联网上的一系列网络设备, 最终到达浏览器所在的主机(这个过程也需要网络层和数据链路层参与).
   • 浏览器主机收到这些光信号/电信号, 又会通过网络协议栈逐层进行 分用, 层层解析, 最终还原成HTTP 响应, 并交给浏览器处理.
   • 浏览器也通过 Socket 读到这个响应(一个字符串), 按照 HTTP 响应的格式来解析这个响应. 并且把body 中的数据按照一定的格式显示在浏览器的界面上.

浏览器和服务器之间交互数据，这个过程中是否会涉及到 TCP 三次握手，确认应答…，是否会涉及到IP的分包组包… 是否会涉及到以太网的MTU 呢…

都是会的!!!

Tomcat 的伪代码

• 下面的代码通过 “伪代码” 的形式描述了 Tomcat 初始化 / 处理请求 两部分核心逻辑
• 所谓 “伪代码”，并不是一些语法严谨，功能完备的代码，只是通过这种形式来大概表达某种逻辑

1、Tomcat 初始化流程

• Tomcat 的代码中内置了 main 方法， 当我们启动 Tomcat 的时候, 就是从 Tomcat 的 main 方法开始执行的，
• 被 @WebServlet 注解修饰的类会在 Tomcat 启动的时候就被获取到，并集中管理，

1). 让 Tomcat 先从指定的目录中找到所有要加载的 Servlet 类~~

前面部署的时候，是把 Servlet 代码编译成了 .class，然后打了 war 包，然后拷贝到了 webapps 里面。Tomcat 就会从 webapps 里来找到哪些 .class 对应的 Servlet 类，并且需要进行加载 (当然啦，这里的加载不一定是 Tomcat 一启动就立即执行，也可能是 “懒加载”
但是此处伪代码中就假设立即加载了~~)

2). 根据刚才类加载的结果，给这些类创建 Servlet 实例~~

// 这里要做的的是实例化出所有的 Servlet 对象出来;
for (Class<Servlet> cls : allServletClasses) {
    // 这里是利用 java 中的反射特性做的
    // 实际上还得涉及一个类的加载问题，因为我们的类字节码文件，是按照约定的
    // 方式（全部在 WEB-INF/classes 文件夹下）存放的，所以 tomcat 内部是
    // 实现了一个自定义的类加载器(ClassLoader)用来负责这部分工作。
    Servlet ins = cls.newInstance(); // 反射
    instanceList.add(ins);
}

3). 实例创建好之后，就可以调用当前 Servlet 实例的 init 方法了

Servlet 自带的方法，默认情况下 init 啥都不干
咱们在继承一个 HttpServlet 的时候，也可以自己重写 init，就可以在这个阶段，帮我们做一些初始化工作了

// 调用每个 Servlet 对象的 init() 方法，这个方法在对象的生命中只会被调用这一次;
for (Servlet ins : instanceList) {
	ins.init();
}

4). 创建 TCP socket，监听 8080 端口，等待有客户端来连接

Tomcat 为了能同时相应多个 HTTP 请求, 采取了多线程的方式实现， 因此 Servlet 是运行在 多线程环境 下的， Tomcat 内部也是通过 Socket API 进行网络通信，

每次有连接过来了，accept 就会返回，然后就给当前的线程池里，加个任务
doHttpRequest(socket); 这个任务里，就要负责处理这个请求了

此处这个主循环，和咱们之前讲过的 TCP 回显服务器，本质上没啥区别
Tomcat 工作的大部分时间都是在这个循环里完成的~~

// 利用我们之前学过的知识，启动一个 HTTP 服务器
// 并用线程池的方式分别处理每一个 Request
ServerSocket serverSocket = new ServerSocket(8080);
// 实际上 tomcat 不是用的固定线程池，这里只是为了说明情况
ExecuteService pool = Executors.newFixedThreadPool(100);

while (true) {
    Socket socket = ServerSocket.accept();
    // 每个请求都是用一个线程独立支持，这里体现了我们 Servlet 是运行在多线程环境下的
    pool.execute(new Runnable() {
        doHttpRequest(socket);
    });
}

5). 如果循环退出了，Tomcat 也要结束了，就会依次循环调用每个 Servlet 的 destroy 方法

这个是属于收尾工作 (Tomcat 退出之前的事情)

// 调用每个 Servlet 对象的 destroy() 方法，这个方法在对象的生命中只会被调用这一次;
for (Servlet ins : instanceList) {
    ins.destroy();
}

没有 break 为啥还能走到下面的代码?
那是因为咱们当下写的是一个伪代码，只包含了核心逻辑，没有太多的实现细节~~
实际上 Tomcat 里面会有一些条件来退出这个主循环
和 init 类似，这里的 destroy 默认也是啥都不干的，可以在用户代码中重写这个 destroy ~~

虽然这里有 5) 这个调用 destroy 这个环节，但是这个环节不一定可靠~~
如果 Tomcat 是通过 “正常流程" 退出的，才能主动结束循环，调用这里的 destroy。如果是通过 “非正常流程" 退出的，此时就来不及调用 destroy

比如，Tomcat，8005 端口 (管理端口，通过这个端口可以对这个 Tomcat 发号施令)，通过这个方式来关闭 Tomcat，就属于 “正常流程"

非正常流程：直接结束进程 (大部分是这种情况)

class Tomcat {
    // 用来存储所有的 Servlet 对象
    private List<Servlet> instanceList = new ArrayList<>()

    public void start() {
        // 根据约定，读取 WEB-INF/web.xml 配置文件;
        // 并解析被 @WebServlet 注解修饰的类

        // 假定这个数组里就包含了我们解析到的所有被 @WebServlet 注解修饰的类.
        Class<Servlet>[] allServletClasses = ...;

        // 这里要做的的是实例化出所有的 Servlet 对象出来;
        for (Class<Servlet> cls : allServletClasses) {
            // 这里是利用 java 中的反射特性做的
            // 实际上还得涉及一个类的加载问题，因为我们的类字节码文件，是按照约定的
            // 方式（全部在 WEB-INF/classes 文件夹下）存放的，所以 tomcat 内部是
            // 实现了一个自定义的类加载器(ClassLoader)用来负责这部分工作。
            Servlet ins = cls.newInstance();
            instanceList.add(ins);
        }

        // 调用每个 Servlet 对象的 init() 方法，这个方法在对象的生命中只会被调用这一次;
        for (Servlet ins : instanceList) {
            ins.init();
        }

        // 利用我们之前学过的知识，启动一个 HTTP 服务器
        // 并用线程池的方式分别处理每一个 Request
        ServerSocket serverSocket = new ServerSocket(8080);
        // 实际上 tomcat 不是用的固定线程池，这里只是为了说明情况
        ExecuteService pool = Executors.newFixedThreadPool(100);

        while (true) {
            Socket socket = ServerSocket.accept();
            // 每个请求都是用一个线程独立支持，这里体现了我们 Servlet 是运行在多线程环境下的
            pool.execute(new Runnable() {
                doHttpRequest(socket);
            });
        }

        // 调用每个 Servlet 对象的 destroy() 方法，这个方法在对象的生命中只会被调用这一次;
        for (Servlet ins : instanceList) {
            ins.destroy();
        }
    }
        
    public static void main(String[] args) {
        new Tomcat().start();
    }
}

2、Tomcat 处理请求流程

class Tomcat {
    void doHttpRequest(Socket socket) {
        // 参照我们之前学习的 HTTP 服务器类似的原理，进行 HTTP 协议的请求解析，和响应构建
        HttpServletRequest req = HttpServletRequest.parse(socket); // 1) 
        HttpServletRequest resp = HttpServletRequest.build(socket);
        
        // 判断 URL 对应的文件是否可以直接在我们的根路径上找到对应的文件，如果找到，就是静态内容
        // 直接使用我们学习过的 IO 进行内容输出
        if (file.exists()) { // 2)
            // 返回静态内容
            return;
        }
        
        // 走到这里的逻辑都是动态内容了
        
        // 根据我们在配置中说的，按照 URL -> servlet-name -> Servlet 对象的链条
        // 最终找到要处理本次请求的 Servlet 对象
        Servlet ins = findInstance(req.getURL()); // 3)
        
        // 调用 Servlet 对象的 service 方法
        // 这里就会最终调用到我们自己写的 HttpServlet 的子类里的方法了
        try {
            ins.service(req, resp); // 4)
        } catch (Exception e) {
            // 返回 500 页面，表示服务器内部错误
        }
    }
}

1). req ：是通过读取 socket 中的数据，然后再按照 HTTP 协议的请求格式来解析的，构造成了一个 HttpServletRequest 对象
resp ：这里则是相当于 new 了一个空的对象

2). 是判定当前要请求的资源是否是静态文件~~
如果是静态文件，就读取文件内容，把文件内容构造到 resp 对象的 body 中，并且返回这个 resp 对象

例如可以再 webapp 目录中，创建一个静态文件 test.html，启动，访问：http://127.0.0.1:8080/hello102/test.html

3). 根据请求的 URL，来获取到使用哪个类来处理
URL 里要有两级路径：

• 第一级路径：Context Path，确定一个 webapp

• 第二级路径：Servlet Path，确定一个 Servlet 类，如果没有找到匹配的 Servlet 类，就会返回 404

4). 根据刚才找到的 Servlet 对象，来调用 service 方法~~ 在 service 方法内部，又会进一步的调用 doGet / doPost

3、Servlet 的 service 方法的实现

如果在执行 Servlet 的 service 方法过程中出现未处理的异常就会返回500

class Servlet {
    public void service(HttpServletRequest req, HttpServletResponse resp) {
        String method = req.getMethod();
        if (method.equals("GET")) {
            doGet(req, resp);
        } else if (method.equals("POST")) {
            doPost(req, resp);
        } else if (method.equals("PUT")) {
            doPut(req, resp);
        } else if (method.equals("DELETE")) {
            doDelete(req, resp);
        }
        ......
    }
}

在讨论到上面这整套流程过程中，涉及到了关于 Servlet 的关键方法，主要有三个：

• init：初始化阶段，对象创建好了之后，就会执行到，用户可以重写这个方法，来执行一些初始化逻辑
• service：在处理请求阶段来调用，每次来个请求都要调用一次 service
• destroy：退出主循环，tomcat 结束之前会调用，用来释放资源

他们的调用时机就称 Servlet 的生命周期，生命周期这个词是计算机里一个挺常见的术语 “啥时候,该做啥事”

Servlet 的 service 方法内部会根据当前请求的方法，决定调用其中的某个 doXXX 方法
在调用 doXXX 方法的时候，就会触发 多态 机制，从而执行到我们自己写的子类中的 doXXX 方法

理解此处的 多态 ：

• 我们前面自己写的 HelloServlet 类, 继承自 HttpServlet 类. 而 HttpServlet 又继承自 Servlet. 相当于 HelloServlet 就是 Servlet 的子类.

• 接下来, 在 Tomcat 启动阶段, Tomcat 已经根据注解的描述, 创建了 HelloServlet 的实例, 然后把这个实例放到了 Servlet 数组中.

• 后面我们根据请求的 URL 从数组中获取到了该 HelloServlet 实例, 但是我们是通过 Servlet ins这样的父类引用来获取到 HelloServlet 实例的.

• 最后, 我们通过 ins.doGet() 这样的代码调用 doGet 的时候, 正是 “父类引用指向子类对象”, 此时就会触发多态机制, 从而调用到我们之前在 HelloServlet 中所实现的 doGet 方法

• 等价代码:

  Servlet ins = new HelloServlet();
  ins.doGet(req, resp);