Skip to content

B
beginnersbook-zh

OpenDocCN / beginnersbook-zh
9 个月 前同步成功

通知 0
Star 107
Fork 30
B
beginnersbook-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 c408e1bd 编写于 作者: W wizardforcel
浏览文件
操作

2019-10-14 20:18:05

上级 ec74910e
隐藏空白更改
内联 并排
Showing with 168 addition and 163 deletion
docs/servlet/2.md
浏览文件 @ c408e1bd
......@@ -5,9 +5,9 @@
Servlet 是一个在 Web 服务器上的 JVM 内运行的 java 程序。它用于开发动态 Web 应用。
在我们继续之前，让我们了解什么是**动态 Web 应用？** Web 应用可以被描述为网页集合（例如网站），当我们称之为动态时，它只是意味着所有用户的网页都不相同，网页将在服务器端生成根据客户端（用户的浏览器）的请求。
静态和动态网页之间的主要**区别在于，名称建议的静态页面对于所有用户保持相同，但是动态网页基于来自客户端（用户的浏览器）的请求而改变。例如，考虑一个 Web 应用，它向您显示两个输入字段&添加按钮，当您输入两个数字并单击添加时，它会显示另一个网页，其中包含两个数字的结果，此 Web 应用本质上是动态的，作为第二个网页，显示结果更改基于用户输入，对所有用户都不是静态的。**
静态和动态网页之间的主要区别在于，名称建议的静态页面对于所有用户保持相同，但是动态网页基于来自客户端（用户的浏览器）的请求而改变。例如，考虑一个 Web 应用，它向您显示两个输入字段和添加按钮，当您输入两个数字并单击添加时，它会显示另一个网页，其中包含两个数字的结果，此 Web 应用本质上是动态的，作为第二个网页，显示结果更改基于用户输入，对所有用户都不是静态的。
但是你可以很好地说，一个 servlet 可以通过 CGI（通用网关接口）完成什么，这是真的，但这就是事情 - **CGI 有一些限制，如性能，可伸缩性，可重用性等等。没有**。我不打算详细讨论 CGI，但我要告诉你，servlet 如何比 CGI 更好。
但是你可以很好地说，一个 servlet 可以通过 CGI（通用网关接口）完成什么，这是真的，但这就是事情 - CGI 有一些限制，如性能，可伸缩性，可重用性等等。我不打算详细讨论 CGI，但我要告诉你，servlet 如何比 CGI 更好。
### CGI 的局限性
......@@ -17,11 +17,11 @@ Servlet 是一个在 Web 服务器上的 JVM 内运行的 java 程序。它用
每次发出新请求时，CGI 程序都由新进程处理。与 CGI 不同，servlet 程序由可以更高效地并发运行的单独线程处理。
CGI 程序可以用任何编程语言编写，使其主要依赖于平台，因为并非所有编程语言都是独立于平台的。 Servlet 仅使用 Java 作为编程语言，使其与平台无关且可移植。使用 java 的另一个好处是 servlet 可以利用 java 的面向对象编程功能。
CGI 程序可以用任何编程语言编写，使其主要依赖于平台，因为并非所有编程语言都是独立于平台的。Servlet 仅使用 Java 作为编程语言，使其与平台无关且可移植。使用 java 的另一个好处是 servlet 可以利用 java 的面向对象编程功能。
#### Servlet 如何工作
正如我上面提到的，对服务器的并发请求由线程处理，这里是相同的图形表示 -
正如我上面提到的，对服务器的并发请求由线程处理，这里是相同的图形表示：
![How Servlet Works](img/a8dbd21e8cce7f38300dd2b190ed9583.jpg)
......@@ -31,7 +31,7 @@ CGI 程序可以用任何编程语言编写，使其主要依赖于平台，因
**1.便携式：**
正如我上面提到的，Servlet 使用 Java 作为编程语言，因为 java 是独立于平台的，所以对于 servlet 也是如此。例如，您可以在 Windows 操作系统上创建一个 servlet，用户将 GlassFish 作为 Web 服务器，然后在任何其他操作系统（如 Unix，Linux 和 Apache tomcat Web 服务器）上运行它，此功能使 servlet 可移植，这是 servlet 的主要优点通过 CGI。
正如我上面提到的，Servlet 使用 Java 作为编程语言，因为 java 是独立于平台的，所以对于 servlet 也是如此。例如，您可以在 Windows 操作系统上创建一个 servlet，用户将 GlassFish 作为 Web 服务器，然后在任何其他操作系统（如 Unix，Linux 和 Apache tomcat Web 服务器）上运行它，此功能使 servlet 可移植，这是 servlet 优于 CGI 的主要优点。
**2.高效且可扩展：**
......
docs/servlet/3.md
浏览文件 @ c408e1bd
......@@ -2,7 +2,7 @@
> 原文： [https://beginnersbook.com/2013/05/servlet-api/](https://beginnersbook.com/2013/05/servlet-api/)
您需要使用 Servlet API 来创建 servlet。使用 API​​时必须记住两个包，包含支持通用 servlet（独立于协议的 servlet）的类的`javax.servlet`包和包含支持 http servlet 的类的`javax.servlet.http`包。你可能想知道什么是泛型和 http servlet，我在本文后面已经解释过了。
您需要使用 Servlet API 来创建 servlet。使用 API ​​时必须记住两个包，包含支持通用 servlet（独立于协议的 servlet）的类的`javax.servlet`包和包含支持`httpServlet`的类的`javax.servlet.http`包。你可能想知道什么是泛型和 http Servlet，我在本文后面已经解释过了。
**让我们看看包的层次结构：**
......@@ -13,7 +13,7 @@ java.lang.Object
```
每个 Servlet 必须实现`java.servlet.Servlet`接口，您可以通过扩展以下两个类之一来实现：`javax.servlet.GenericServlet`或`javax.servlet.http.HttpServlet`。第一个用于协议无关的 Servlet，第二个用于 http Servlet。
每个 Servlet 必须实现`java.servlet.Servlet`接口，您可以通过扩展以下两个类之一来实现：`javax.servlet.GenericServlet`或`javax.servlet.http.HttpServlet`。第一个用于协议无关的 Servlet，第二个用于`httpServlet`。
**servlet 如何工作？**
......@@ -21,86 +21,87 @@ java.lang.Object
## 通用 Servlet
如上所述，如果要创建 Generic Servlet，则必须扩展`javax.servlet.GenericServlet`类。 GenericServlet 类有一个抽象的 service（）方法。这意味着 GenericServlet 的子类应始终覆盖 service（）方法。
**签名服务（）方法：**
如上所述，如果要创建`GenericServlet`，则必须扩展`javax.servlet.GenericServlet`类。`GenericServlet`类有一个抽象的`service()`方法。这意味着`GenericServlet`的子类应始终覆盖`service()`方法。
**`service()`方法的签名：**
```java
public abstract void service(ServletRequest request, ServletResponse response)
throws ServletException, java.io.IOException
```
service（）方法接受两个参数 ServletRequest 对象和 ServletResponse 对象。请求对象告诉 servlet 客户端发出的请求，而响应对象用于将响应返回给客户端。
`service()`方法接受两个参数`ServletRequest`对象和`ServletResponse`对象。请求对象告诉 servlet 客户端发出的请求，而响应对象用于将响应返回给客户端。
![Generic Servlet](img/2a17e9eab90c167770ab355ca40fbe9f.jpg)
## HTTP Servlet
## `HTTPServlet`
如果您创建 Http Servlet，则必须扩展`javax.servlet.http.HttpServlet`类，这是一个抽象类。与 Generic Servlet 不同，HTTP Servlet 不会覆盖 service（）方法。相反，它会覆盖以下一种或多种方法。它必须覆盖以下列表中的至少一个方法：
如果您创建`HttpServlet`，则必须扩展`javax.servlet.http.HttpServlet`类，这是一个抽象类。与`GenericServlet`不同，`HTTPServlet`不会覆盖`service()`方法。相反，它会覆盖以下一种或多种方法。它必须覆盖以下列表中的至少一个方法：
* **doGet（）** - 这个方法由 servlet 服务方法调用，用于处理来自客户端的 HTTP GET 请求。 Get 方法用于从服务器获取信息
* **doPost（）** - 用于向服务器发布信息
* **doPut（）** - 这个方法类似于 doPost 方法，但与我们向服务器发送信息的 doPost 方法不同，此方法将文件发送到服务器，这类似于从客户端到服务器的 FTP 操作
* **doDelete（）** - 允许客户端从服务器删除文档，网页或信息
* **init（）和 destroy（）** - 用于管理 servlet 生命周期内持有的资源
* **getServletInfo（）** - 返回有关 servlet 的信息，例如作者，版本和版权。
* `doGet()` - 这个方法由 servlet 服务方法调用，用于处理来自客户端的 HTTP `GET`请求。`Get`方法用于从服务器获取信息
* `doPost()` - 用于向服务器发布信息
* `doPut()` - 这个方法类似于`doPost`方法，但与我们向服务器发送信息的`doPost`方法不同，此方法将文件发送到服务器，这类似于从客户端到服务器的 FTP 操作
* `doDelete()` - 允许客户端从服务器删除文档，网页或信息
* `init()和 destroy()` - 用于管理 servlet 生命周期内持有的资源
* `getServletInfo()` - 返回有关 servlet 的信息，例如作者，版本和版权。
**在 Http Servlet 中，不需要覆盖 service（）方法**，因为此方法将 Http 请求分派给正确的方法处理程序，例如，如果它接收到 HTTP GET 请求，它会将请求分派给 doGet（）方法。
**在`HttpServlet`中，不需要覆盖`service()`方法**，因为此方法将 Http 请求分派给正确的方法处理程序，例如，如果它接收到 HTTP `GET`请求，它会将请求分派给`doGet()`方法。
![Http Servlet](img/800e239048bf09e4171bc1a7b1b429a7.jpg)
#### javax.servlet 包中的接口
* Servlet 的
* ServletRequest 中
* ServletResponse 的
* 的 ServletConfig
* ServletContext 中
* SingleThreadModel 的
* RequestDispatcher 的
* ServletRequestListener
* ServletRequestAttributeListener
* 的 ServletContextListener
* ServletContextAttributeListener
* 过滤
* 一个 FilterConfig
* FilterChain
#### javax.servlet 包中的类
* GenericServlet 类
* ServletInputStream
* ServletOutputStream 的
* 的 ServletException
* 了 ServletRequestWrapper
* ServletRequestEvent
* 了 ServletResponseWrapper
* ServletContextEvent
* ServletRequestAttributeEvent
* ServletContextAttributeEvent
* 用 UnavailableException
#### javax.servlet.http 包中的接口
* HttpSession 中
* HttpServletRequest 的
* HttpServletResponse 的
* HttpSessionAttributeListener
* HttpSessionListener
* 了 HttpSessionBindingListener
* HttpSessionActivationListener
* HttpSessionContext
#### javax.servlet.http 包中的类
* HttpServlet 的
* 曲奇饼
* HttpSessionEvent
* HttpSessionBindingEvent
* 了 HttpServletRequestWrapper
* HttpServletResponseWrapper
* HttpUtils
**参考文献：**
1. [javax.servlet 官方 Servlet API 文档](https://docs.oracle.com/cd/E17802_01/products/products/servlet/2.5/docs/servlet-2_5-mr2/javax/servlet/package-summary.html)
2. [java.servlet.http API 文档](https://docs.oracle.com/cd/E17802_01/products/products/servlet/2.5/docs/servlet-2_5-mr2/javax/servlet/http/package-tree.html)
\ No newline at end of file
#### `javax.servlet`包中的接口
* `Servlet`
* `ServletRequest`
* `ServletResponse`
* `ServletConfig`
* `ServletContext`
* `SingleThreadModel`
* `RequestDispatcher`
* `ServletRequestListener`
* `ServletRequestAttributeListener`
* `ServletContextListener`
* `ServletContextAttributeListener`
* `Filter`
* `FilterConfig`
* `FilterChain`
#### `javax.servlet`包中的类
* `GenericServlet`
* `ServletInputStream`
* `ServletOutputStream`
* `ServletException`
* `ServletRequestWrapper`
* `ServletRequestEvent`
* `ServletResponseWrapper`
* `ServletContextEvent`
* `ServletRequestAttributeEvent`
* `ServletContextAttributeEvent`
* `UnavailableException`
#### `javax.servlet.http`包中的接口
* `HttpSession`
* `HttpServletRequest`
* `HttpServletResponse`
* `HttpSessionAttributeListener`
* `HttpSessionListener`
* `HttpSessionBindingListener`
* `HttpSessionActivationListener`
* `HttpSessionContext`
#### `javax.servlet.http`包中的类
* `HttpServlet`
* `Cookie`
* `HttpSessionEvent`
* `HttpSessionBindingEvent`
* `HttpServletRequestWrapper`
* `HttpServletResponseWrapper`
* `HttpUtils`
**参考：**
1. [官方 Servlet API 文档：`javax.servlet`](https://docs.oracle.com/cd/E17802_01/products/products/servlet/2.5/docs/servlet-2_5-mr2/javax/servlet/package-summary.html)
2. [API 文档：`java.servlet.http`](https://docs.oracle.com/cd/E17802_01/products/products/servlet/2.5/docs/servlet-2_5-mr2/javax/servlet/http/package-tree.html)
\ No newline at end of file
docs/servlet/4.md
浏览文件 @ c408e1bd
# Servlet 接口用 Example 解释
# `Servlet`接口解释
> 原文： [https://beginnersbook.com/2014/04/servlet-interface/](https://beginnersbook.com/2014/04/servlet-interface/)
在我关于 [Servlet API](https://beginnersbook.com/2013/05/servlet-api/) 的上一篇指南中，我已经解释过要创建任何 Servlet，你必须直接或间接地实现 Servlet 接口（间接实现意味着扩展那些实现 Servlet 接口的类，这些类是 GenericServlet 和 HttpServlet） 。
在我关于 [Servlet API](https://beginnersbook.com/2013/05/servlet-api/) 的上一篇指南中，我已经解释过要创建任何 Servlet，你必须直接或间接地实现`Servlet`接口（间接实现意味着扩展那些实现`Servlet`接口的类，这些类是`GenericServlet`和`HttpServlet`） 。
如果您正在创建协议相关的 servlet，例如 http servlet，那么您应该扩展 HttpServlet 类，以便扩展 GenericServlet 类的协议无关的 Servlet。
在本指南中，我不打算详细解释 GenericServlet 和 HttpServlet，因为我已经在单独的指南中介绍了它们。
**编辑：**以下是这些指南的链接： [GenericServlet](https://beginnersbook.com/2014/04/genericservlet-class/) | [HttpServlet](https://beginnersbook.com/2013/05/http-servlet/) 。
如果您正在创建协议相关的 servlet，例如`httpServlet`，那么您应该扩展`HttpServlet`类，以便扩展`GenericServlet `类的协议无关的`Servlet`。
在本指南中，我不打算详细解释`GenericServlet`和`HttpServlet`，因为我已经在单独的指南中介绍了它们。
**编辑**：以下是这些指南的链接： [`GenericServlet`](https://beginnersbook.com/2014/04/genericservlet-class/)，[`HttpServlet`](https://beginnersbook.com/2013/05/http-servlet/) 。
> 总之，你有 3 种方法来创建一个 servlet：
> 1）通过扩展 HttpServlet 类
> 2）通过扩展 GenericServlet 类
> 3）通过实现 Servlet 接口
> 注意：但是你应该总是喜欢第一个创建 servlet 的方法，即通过扩展 HttpServlet 类。
>
> 1）通过扩展`HttpServlet`类
>
> 2）通过扩展`GenericServlet`类
>
> 3）通过实现`Servlet`接口
>
> 注意：但是你应该总是喜欢第一个创建 servlet 的方法，即通过扩展`HttpServlet`类。
### Servlet 接口方法
### `Servlet`接口方法
以下是 Servlet 界面中可用的方法列表。
以下是`Servlet`接口中可用的方法列表。
1） **void destroy（）**：这个方法在 [servlet 生命周期](https://beginnersbook.com/2013/05/servlet-life-cycle/)结束时由 Servlet 容器调用。与在生命周期中多次调用的 service（）方法不同，此方法在整个生命周期中仅由 Servlet 容器调用一次。一旦调用了 destroy（）方法，servlet 容器就不会为该 servlet 调用 service（）方法。
1） `void destroy()`：这个方法在 [servlet 生命周期](https://beginnersbook.com/2013/05/servlet-life-cycle/)结束时由 Servlet 容器调用。与在生命周期中多次调用的`service()`方法不同，此方法在整个生命周期中仅由 Servlet 容器调用一次。一旦调用了`destroy()`方法，servlet 容器就不会为该 servlet 调用`service()`方法。
2） **void init（ServletConfig config）**：当 Servlet 容器启动时（在 Web 服务器启动时发生），它加载所有 servlet 并实例化它们。在为每个实例化的 servlet 调用此 init（）方法之后，此方法初始化 servlet。
2） `void init(ServletConfig config)`：当 Servlet 容器启动时（在 Web 服务器启动时发生），它加载所有 servlet 并实例化它们。在为每个实例化的 servlet 调用此`init()`方法之后，此方法初始化 servlet。
3） **void 服务（ServletRequest req，ServletResponse res）**：这是在 servlet 生命周期中多次调用的唯一方法。此方法为客户端请求提供服务，每次服务器收到请求时都会调用它。
3） `void service(ServletRequest req, ServletResponse res)`：这是在 servlet 生命周期中多次调用的唯一方法。此方法为客户端请求提供服务，每次服务器收到请求时都会调用它。
4） **ServletConfig getServletConfig（）**：返回一个 ServletConfig 对象，该对象包含该 servlet 的初始化和启动参数。
4） `ServletConfig getServletConfig()`：返回一个`ServletConfig`对象，该对象包含该 servlet 的初始化和启动参数。
5） **java.lang.String getServletInfo（）**：返回有关 servlet 的信息，例如作者，版本和版权。
5） `String getServletInfo()`：返回有关 servlet 的信息，例如作者，版本和版权。
## 例：
在这个例子中，我们通过扩展 Servlet 接口创建了一个 servlet 类。
在这个例子中，我们通过扩展`Servlet`接口创建了一个 servlet 类。
index.html
`index.html`
```java
<a href="welcome">Click here to call the servlet</a>
```
DemoServlet.java
`DemoServlet.java`
```java
import java.io.*;
......@@ -72,7 +76,7 @@ public class DemoServlet implements Servlet{
}
```
web.xml
`web.xml`
```java
<web-app>
......@@ -90,4 +94,4 @@ web.xml
#### 参考：
[接口 Servlet](https://docs.oracle.com/javaee/7/api/javax/servlet/Servlet.html)
\ No newline at end of file
[`Servlet` 接口](https://docs.oracle.com/javaee/7/api/javax/servlet/Servlet.html)
\ No newline at end of file
docs/servlet/5.md
浏览文件 @ c408e1bd
# GenericServlet 类与示例
# `GenericServlet`类
> 原文： [https://beginnersbook.com/2014/04/genericservlet-class/](https://beginnersbook.com/2014/04/genericservlet-class/)
在讨论 [Servlet API](https://beginnersbook.com/2013/05/servlet-api/) 时，我已经讨论了一些关于 Generic Servlet 的内容。在本文中，我将详细讨论 Generic Servlet。
在讨论 [Servlet API](https://beginnersbook.com/2013/05/servlet-api/) 时，我已经讨论了一些关于`GenericServlet`的内容。在本文中，我将详细讨论`GenericServlet`。
通用 servlet 是一个独立于协议的 Servlet，它应该始终覆盖 service（）方法来处理客户端请求。 service（）方法接受两个参数 ServletRequest 对象和 ServletResponse 对象。请求对象告诉 servlet 客户端发出的请求，而响应对象用于将响应返回给客户端。
`GenericServlet`是一个独立于协议的 Servlet，它应该始终覆盖`service()`方法来处理客户端请求。`service()`方法接受两个参数`ServletRequest`对象和`ServletResponse`对象。请求对象告诉 servlet 客户端发出的请求，而响应对象用于将响应返回给客户端。
### Generic Servlet 如何工作？
### `GenericServlet`如何工作？
![Generic Servlet](img/2a17e9eab90c167770ab355ca40fbe9f.jpg)
### 通用 Servlet 的层次结构
### `GenericServlet`的层次结构
```java
java.lang.Object
|_extended byjavax.servlet.GenericServlet
```
GenericServlet 是一个抽象类，它只有一个抽象方法，即 service（）。这就是为什么当我们通过扩展 GenericServlet 类来创建 Generic Servlet 时，我们必须覆盖 service（）方法。
`GenericServlet`是一个抽象类，它只有一个抽象方法，即`service()`。这就是为什么当我们通过扩展`GenericServlet`类来创建`GenericServlet`时，我们必须覆盖`service()`方法。
**使用 Generic Servlet 的优点：**
**使用`GenericServlet`的优点：**
1. 通用 Servlet 更容易编写
1. `GenericServlet`更容易编写
2. 具有简单的生命周期方法
3. 要编写 Generic Servlet，您只需要扩展 javax.servlet。 GenericServlet 并覆盖 service（）方法（请查看下面的示例）。
3. 要编写`GenericServlet`，您只需要扩展`javax.servlet.GenericServlet`并覆盖`service()`方法（请查看下面的示例）。
**使用 Generic Servlet 的缺点：**
**使用`GenericServlet`的缺点：**
使用 Generic Servlet 并不是那么容易，因为我们在 Generic Servlet 中没有像 doGet（），doPost（），doHead（）等方便的方法可以在 Http Servlet 中使用。
在 Http Servlet 中，我们需要为特定请求覆盖特定的便捷方法，例如，如果您需要获取信息，则覆盖 doGet（），如果要向服务器覆盖 doPost（）发送信息。但是在 Generic Servlet 中，我们只为每种类型的请求覆盖 service（）方法，这很麻烦。
使用`GenericServlet`并不是那么容易，因为我们在`GenericServlet`中没有像`doGet()`，`doPost()`，`doHead()`等方便的方法可以在`HttpServlet`中使用。
在`HttpServlet`中，我们需要为特定请求覆盖特定的便捷方法，例如，如果您需要获取信息，则覆盖`doGet()`，如果要向服务器发送信息覆盖`doPost()`。但是在`GenericServlet`中，我们只为每种类型的请求覆盖`service()`方法，这很麻烦。
我总是建议你使用 HttpServlet 而不是 GenericServlet。 HttpServlet 更易于使用，并且具有比 GenericServlet 更多的方法。
我总是建议你使用`HttpServlet`而不是`GenericServlet`。`HttpServlet`更易于使用，并且具有比`GenericServlet`更多的方法。
### GenericServlet 的示例
### `GenericServlet`的示例
我在这个例子中使用 Eclipse IDE。从 Eclipse 文件菜单中创建新的“Dynamic Web Project”。
我在这个例子中使用 Eclipse IDE。从 Eclipse 文件菜单中创建新的`Dynamic Web Project`。
> 我已经解释了在 Eclipse IDE 中创建 Servlet 的每一步，但是如果您刚接触 Eclipse 并且没有在系统上安装它，那么请参考本指南：[如何安装 Eclipse，设置 Tomcat 并运行第一个 servlet 程序使用 Eclipse IDE。](https://beginnersbook.com/2017/07/how-to-create-and-run-servlet-in-eclipse-ide/)
> 我已经解释了在 Eclipse IDE 中创建 Servlet 的每一步，但是如果您刚接触 Eclipse 并且没有在系统上安装它，那么请参考本指南：[如何安装 Eclipse，设置 Tomcat 并使用 Eclipse IDE运行第一个 servlet 程序](https://beginnersbook.com/2017/07/how-to-create-and-run-servlet-in-eclipse-ide/)。
完成后，在 IDE 中创建以下所有文件后，项目结构（或层次结构）将如下所示。
![Generic Servlet Project Structure](img/3a03fe804d0be295cd4786785347f611.jpg)
**index.html**
`index.htm`
我们正在创建一个 html 文件，一旦我们点击网页上的链接就会调用 servlet。在 WebContent 文件夹中创建此文件。该文件的路径应如下所示：WebContent / index.html
我们正在创建一个 html 文件，一旦我们点击网页上的链接就会调用 servlet。在`WebContent`文件夹中创建此文件。该文件的路径应如下所示：`WebContent/index.html`
```java
<!DOCTYPE html>
......@@ -59,9 +59,9 @@ GenericServlet 是一个抽象类，它只有一个抽象方法，即 service（
</html>
```
**ExampleGeneric.java**
`ExampleGeneric.java`
现在，我们通过扩展 GenericServlet 类来创建 Generic Servlet。创建 GenericServlet 时，应始终覆盖 service（）方法。右键单击 src 文件夹并创建一个新的类文件，将该文件命名为 ExampleGeneric。文件路径应如下所示：Java Resouces / src / default package / ExampleGeneric.java
现在，我们通过扩展`GenericServlet`类来创建`GenericServlet`。创建`GenericServlet`时，应始终覆盖`service()`方法。右键单击`src`文件夹并创建一个新的类文件，将该文件命名为`ExampleGeneric`。文件路径应如下所示：`Java Resouces/src/default package/ExampleGeneric.java`
```java
import java.io.*;
......@@ -83,9 +83,9 @@ throws IOException,ServletException{
```
**web.xml**
`web.xml`
此文件可在此路径 WebContent / WEB-INF / web.xml 中找到。在此文件中，我们将使用特定 URL 映射 Servlet。由于我们在单击 index.html 页面上的链接时调用欢迎页面，因此我们将欢迎页面映射到我们上面创建的 Servlet 类。
此文件可在此路径`WebContent/WEB-INF/web.xml`中找到。在此文件中，我们将使用特定 URL 映射 Servlet。由于我们在单击`index.html`页面上的链接时调用欢迎页面，因此我们将欢迎页面映射到我们上面创建的 Servlet 类。
```java
<web-app>
......@@ -119,33 +119,33 @@ throws IOException,ServletException{
![Generic Servlet outout2](img/fb2cc0275229be3d019d4339a3cfb7cd.jpg)
## GenericServlet 类的方法：
## `GenericServlet`类的方法：
以下是 GenericServlet 类的所有方法的列表。
1. **public void init（）**：这是一种方便的方法。可以重写此方法，因此无需调用 super.init（config）。
以下是`GenericServlet`类的所有方法的列表。
1. `public void init()`：这是一种方便的方法。可以重写此方法，因此无需调用`super.init(config)`。
2. **public void init（ServletConfig config）**：由 servlet 容器调用以指示 servlet 正在投入使用，此方法用于初始化 servlet。
2. `public void init(ServletConfig config)`：由 servlet 容器调用以指示 servlet 正在投入使用，此方法用于初始化 servlet。
3. **public String getInitParameter（String name）**：返回包含给定初始化参数值的 String，如果参数不存在，则返回 null。
3. `public String getInitParameter(String name)`：返回包含给定初始化参数值的`String`，如果参数不存在，则返回`null`。
4. **public Enumeration getInitParameterNames（）**：返回 web.xml 文件中定义的所有参数的名称，如果 web.xml 没有任何参数，则返回 null。
4. `public Enumeration getInitParameterNames()`：返回`web.xml`文件中定义的所有参数的名称，如果`web.xml`没有任何参数，则返回`null`。
5. **public abstract void service（ServletRequest request，ServletResponse response）**：由 Servlet 容器调用，允许 servlet 响应客户端发出的请求。
5. `public abstract void service(ServletRequest request, ServletResponse response)`：由 Servlet 容器调用，允许 servlet 响应客户端发出的请求。
6. **public void destroy（）**：servlet 容器在 servlet 生命周期结束时调用一次，表明 servlet 正在被销毁。
6. `public void destroy()`：servlet 容器在 servlet 生命周期结束时调用一次，表明 servlet 正在被销毁。
7. **public ServletConfig getServletConfig（）**：返回初始化此 servlet 的 ServletConfig 对象
7. `public ServletConfig getServletConfig()`：返回初始化此 servlet 的`ServletConfig`对象
8. **public String getServletInfo（）**：返回有关 servlet 的信息。
8. `public String getServletInfo()`：返回有关 servlet 的信息。
9. **public ServletContext getServletContext（）**：返回 ServletContext 对象，由 init 方法传递给这个 servlet
9. `public ServletContext getServletContext()`：返回`ServletContext`对象，由`init`方法传递给这个 servlet
10. **public String getServletName（）**：返回 servlet 实例的名称。
10. `public String getServletName()`：返回 servlet 实例的名称。
11. **public void log（String msg）**：在 servlet 日志文件中写入给定的消息。
11. `public void log(String msg)`：在 servlet 日志文件中写入给定的消息。
12. **public void log（String msg，Throwable t）**：在 servlet 日志文件中写入解释性消息，包括描述错误或异常的 String。
12. `public void log(String msg, Throwable t)`：在 servlet 日志文件中写入解释性消息，包括描述错误或异常的`String`。
#### 参考：
[GenericServlet 官方文档](https://docs.oracle.com/javaee/7/api/javax/servlet/GenericServlet.html)
\ No newline at end of file
[`GenericServlet`官方文档](https://docs.oracle.com/javaee/7/api/javax/servlet/GenericServlet.html)
\ No newline at end of file
docs/servlet/6.md
浏览文件 @ c408e1bd
# HttpServlet 类有例子
# `HttpServlet`类
> 原文： [https://beginnersbook.com/2013/05/http-servlet/](https://beginnersbook.com/2013/05/http-servlet/)
在 [Servlet API](https://beginnersbook.com/2013/05/servlet-api/) 中，我对 Http Servlet 进行了一些讨论。在本文中，我将详细讨论 Http Servlet。
在 [Servlet API](https://beginnersbook.com/2013/05/servlet-api/) 中，我对`HttpServlet`进行了一些讨论。在本文中，我将详细讨论`HttpServlet`。
与 Generic Servlet 不同，HTTP Servlet 不会覆盖 service（）方法。相反，它会覆盖 doGet（）方法或 doPost（）方法或两者。 doGet（）方法用于从服务器获取信息，而 doPost（）方法用于向服务器发送信息。
与`GenericServlet`不同，`HTTPServlet`不会覆盖`service()`方法。相反，它会覆盖`doGet()`方法或`doPost()`方法或两者。`doGet()`方法用于从服务器获取信息，而`doPost()`方法用于向服务器发送信息。
在 Http Servlet 中，不需要覆盖 service（）方法，因为此方法将 Http 请求分派给正确的方法处理程序，例如，如果它接收到 HTTP GET 请求，则会将请求分派给 doGet（）方法。
在`HttpServlet`中，不需要覆盖`service()`方法，因为此方法将 Http 请求分派给正确的方法处理程序，例如，如果它接收到 HTTP `GET`请求，则会将请求分派给`doGet()`方法。
## Http Servlet 如何工作？
## `HttpServlet 如何工作？
正如您在下图中看到的那样，客户端（用户的浏览器）发出请求。这些请求可以是任何类型，例如 - 获取请求，发布请求，头请求等。服务器将这些请求分派给 servlet 的 service（）方法，此方法将这些请求分派给正确的处理程序，例如，如果它接收到 Get 请求它将其分派给 doGet（）方法。
正如您在下图中看到的那样，客户端（用户的浏览器）发出请求。这些请求可以是任何类型，例如 - `GET`请求，`POST`请求，`HEAD`请求等。服务器将这些请求分派给 servlet 的`service()`方法，此方法将这些请求分派给正确的处理程序，例如，如果它接收到`Get`请求它将其分派给`doGet()`方法。
![Http Servlet](img/800e239048bf09e4171bc1a7b1b429a7.jpg)
## Http Servlet 的层次结构
## `HttpServlet`的层次结构
```java
java.lang.Object
......@@ -22,21 +22,21 @@ java.lang.Object
|_extended byjavax.servlet.http.HttpServlet
```
我已经在 [Generic Servlet 文章](https://beginnersbook.com/2014/04/genericservlet-class/)中讨论过你应该总是使用 HttpServlet 而不是 GenericServlet。 HttpServlet 更易于使用，并且具有比 GenericServlet 更多的方法。
我已经在[`GenericServlet`文章](https://beginnersbook.com/2014/04/genericservlet-class/)中讨论过你应该总是使用`HttpServlet`而不是`GenericServlet`。`HttpServlet`更易于使用，并且具有比`GenericServlet`更多的方法。
## Http Servlet 的例子
## `HttpServlet`的例子
我在这个例子中使用 Eclipse IDE。从 Eclipse 文件菜单中创建新的“Dynamic Web Project”。
我在这个例子中使用 Eclipse IDE。从 Eclipse 文件菜单中创建新的`Dynamic Web Project`。
> 我已经解释了在 Eclipse IDE 中创建 Servlet 的所有步骤，但是如果您不熟悉 Eclipse 并且没有在系统上安装它，请参考本指南：[如何安装 Eclipse，配置 tomcat 并运行 First Servlet 使用 Eclipse](https://beginnersbook.com/2017/07/how-to-create-and-run-servlet-in-eclipse-ide/) 的应用。
> 我已经解释了在 Eclipse IDE 中创建 Servlet 的所有步骤，但是如果您不熟悉 Eclipse 并且没有在系统上安装它，请参考本指南：[如何安装 Eclipse，配置 tomcat 并使用 Eclipse 运行第一个 Servlet 应用](https://beginnersbook.com/2017/07/how-to-create-and-run-servlet-in-eclipse-ide/)。
完成后，在 IDE 中创建以下所有文件后，项目结构（或层次结构）将如下所示。
![Http Servlet Project Structure](img/3a03fe804d0be295cd4786785347f611.jpg)
**index.html**
`index.html`
我们正在创建一个 html 文件，一旦我们点击网页上的链接就会调用 servlet。在 WebContent 文件夹中创建此文件。该文件的路径应如下所示：WebContent / index.html
我们正在创建一个 html 文件，一旦我们点击网页上的链接就会调用 servlet。在`WebContent`文件夹中创建此文件。该文件的路径应如下所示：`WebContent/index.html`
```java
index<!DOCTYPE html>
......@@ -52,9 +52,9 @@ index<!DOCTYPE html>
```
**ExampleHttpServlet.java**
`ExampleHttpServlet.java`
现在，我们通过扩展 HttpServlet 类来创建一个 Http Servlet。右键单击 src 文件夹并创建一个新的类文件，将该文件命名为 ExampleHttpServlet。文件路径应如下所示：Java Resources / src / default package / ExampleHttpServlet.java
现在，我们通过扩展`HttpServlet`类来创建一个`HttpServlet`。右键单击`src`文件夹并创建一个新的类文件，将该文件命名为`ExampleHttpServlet`。文件路径应如下所示：`Java Resources/src/default package/ExampleHttpServlet.java`
```java
import java.io.*;
......@@ -87,9 +87,9 @@ public class ExampleHttpServlet extends HttpServlet
}
```
**web.xml**
`web.xml`
此文件可在此路径 WebContent / WEB-INF / web.xml 中找到。在此文件中，我们将使用特定 URL 映射 Servlet。由于我们在单击 index.html 页面上的链接时调用欢迎页面，因此我们将欢迎页面映射到我们上面创建的 Servlet 类。
此文件可在此路径`WebContent/WEB-INF/web.xml`中找到。在此文件中，我们将使用特定 URL 映射 Servlet。由于我们在单击`index.html`页面上的链接时调用欢迎页面，因此我们将欢迎页面映射到我们上面创建的 Servlet 类。
```java
<web-app>
......@@ -119,7 +119,7 @@ public class ExampleHttpServlet extends HttpServlet
**运行项目：**
右键单击 index.html，在服务器上运行。
右键单击`index.html`，在服务器上运行。
**输出：**
......@@ -129,26 +129,26 @@ public class ExampleHttpServlet extends HttpServlet
![Http Servlet Output2](img/c4925a852361bccb9c63ade1cbfe89be.jpg)
## HttpServlet 类的方法
## `HttpServlet`类的方法
1. **protected void doGet（HttpServletRequest req，HttpServletResponse resp）**：这个方法由 servlet 服务方法调用，以处理来自客户端的 HTTP GET 请求。覆盖此方法时，请读取请求数据，编写响应头，获取响应的编写器或输出流对象，最后编写响应数据。
1. `protected void doGet(HttpServletRequest req, HttpServletResponse resp)`：这个方法由 servlet `service`方法调用，以处理来自客户端的 HTTP `GET`请求。覆盖此方法时，请读取请求数据，编写响应头，获取响应的编写器或输出流对象，最后编写响应数据。
2. **protected long getLastModified（HttpServletRequest req）**：返回一个长整数，指定上次修改 HttpServletRequest 对象的时间，格林威治标准时间 1970 年 1 月 1 日午夜（以秒为单位），如果时间不知道，则返回-1
2. `protected long getLastModified(HttpServletRequest req)`：返回一个长整数，指定上次修改`HttpServletRequest`对象的时间，格林威治标准时间 1970 年 1 月 1 日午夜（以秒为单位），如果时间不知道，则返回 -1
3. **protected void doHead（HttpServletRequest req，HttpServletResponse resp）**：这个方法由 servlet 服务方法调用，以处理来自客户端的 HTTP HEAD 请求。当客户端想要仅查看响应的标头（例如 Content-Type 或 Content-Length）时，它会发送 HEAD 请求
3. `protected void doHead(HttpServletRequest req, HttpServletResponse resp)`：这个方法由 servlet `service`方法调用，以处理来自客户端的 HTTP `HEAD`请求。当客户端想要仅查看响应的标头（例如`Content-Type`或`Content-Length`）时，它会发送`HEAD`请求
4. **protected void doPost（HttpServletRequest req，HttpServletResponse resp）**：servlet 服务方法调用此方法来处理来自客户端的 POST 请求。 HTTP POST 方法允许客户端一次性向 Web 服务器发送无限长度的数据，并且在向服务器发布信息时非常有用。与 doGet 不同，我们从服务器获取信息时，在从客户端向服务器传输信息时使用此方法。
4. `protected void doPost(HttpServletRequest req, HttpServletResponse resp)`：servlet `service`方法调用此方法来处理来自客户端的`POST`请求。 HTTP `POST`方法允许客户端一次性向 Web 服务器发送无限长度的数据，并且在向服务器发布信息时非常有用。与`doGet`不同，我们从服务器获取信息时，在从客户端向服务器传输信息时使用此方法。
5. **protected void doPut（HttpServletRequest req，HttpServletResponse resp）**：这个方法由 servlet 服务方法调用，以处理来自客户端的 PUT 请求。此方法类似于 doPost 方法，但与我们向服务器发送信息的 doPost 方法不同，此方法将文件发送到服务器，这类似于从客户端到服务器的 FTP 操作。
5. `protected void doPut(HttpServletRequest req, HttpServletResponse resp)`：这个方法由 servlet `service`方法调用，以处理来自客户端的`PUT`请求。此方法类似于`doPost`方法，但与我们向服务器发送信息的`doPost`方法不同，此方法将文件发送到服务器，这类似于从客户端到服务器的 FTP 操作。
6. **protected void doDelete（HttpServletRequest req，HttpServletResponse resp）**：由 servlet service（）方法调用，以处理来自客户端的 DELETE 请求，允许客户端从服务器删除文档，网页或信息。
6. `protected void doDelete(HttpServletRequest req, HttpServletResponse resp)`：由 servlet `service()`方法调用，以处理来自客户端的`DELETE`请求，允许客户端从服务器删除文档，网页或信息。
7. **protected void doOptions（HttpServletRequest req，HttpServletResponse resp）**：由服务方法调用，以允许 servlet 处理 OPTIONS 请求。 OPTIONS 请求确定服务器支持哪些 HTTP 方法并返回适当的标头。
7. `protected void doOptions(HttpServletRequest req, HttpServletResponse resp)`：由`service`方法调用，以允许 servlet 处理`OPTIONS`请求。`OPTIONS`请求确定服务器支持哪些 HTTP 方法并返回适当的标头。
8. **protected void doTrace（HttpServletRequest req，HttpServletResponse resp）**：此方法由 service（）方法调用，用于处理 TRACE 请求。用于调试目的。
8. `protected void doTrace(HttpServletRequest req, HttpServletResponse resp)`：此方法由`service()`方法调用，用于处理`TRACE`请求。用于调试目的。
9. **protected void service（HttpServletRequest req，HttpServletResponse resp）**：没有必要覆盖此方法，此方法从客户端接收 HTTP 请求并将它们转发到相应的 doXXX 方法，如 doGet（）， doPost（），doHEAD（）等
9. `protected void service(HttpServletRequest req, HttpServletResponse resp)`：没有必要覆盖此方法，此方法从客户端接收 HTTP 请求并将它们转发到相应的 doXXX 方法，如`doGet()`，`doPost()`，`doHEAD()`等
10. **public void service（ServletRequest req，ServletResponse res）**：将客户端请求转发给受保护的服务方法。也没有必要重写此方法。
10. `public void service(ServletRequest req, ServletResponse res)`：将客户端请求转发给受保护的`service`方法。也没有必要重写此方法。
**参考：** [Http Servlet 官方文档](https://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpServlet.html)
\ No newline at end of file
**参考**：[`HttpServlet`官方文档](https://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpServlet.html)
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或