超级会员免费看
Java Servlet 开发全解析
1. Servlet 概述
在互联网或企业内部网中，客户端访问是让众多用户轻松获取数据和资源的有效方式。这种访问基于客户端使用超文本标记语言（HTML）和超文本传输协议（HTTP）的万维网标准。Servlet API 为响应 HTTP 请求抽象出了一个通用的解决方案框架。
传统上，处理互联网客户端更新数据库等问题的方式是创建一个带有文本字段和“提交”按钮的 HTML 页面。用户在文本字段中输入信息并点击“提交”按钮，数据会与一个 URL 一起提交，该 URL 指定了服务器运行的通用网关接口（CGI）程序的位置，服务器会将数据提供给该程序。CGI 程序通常用 Perl、Python、C、C++ 等可以从标准输入读取数据并向标准输出写入数据的语言编写。Web 服务器所做的只是调用 CGI 程序，并使用标准流（或可选的环境变量作为输入）进行输入和输出，而 CGI 程序则负责其他所有事情。它首先检查数据格式是否正确，如果不正确，就生成 HTML 页面描述问题并返回给用户；如果数据正确，则以适当的方式处理数据，可能将其添加到数据库中，然后生成一个合适的 HTML 页面返回给用户。
理想情况下，我们希望使用完全基于 Java 的解决方案来解决这个问题，即在客户端使用小程序验证和发送数据，在服务器端使用 Servlet 接收和处理数据。然而，尽管小程序是一种成熟且有大量支持的技术，但在 Web 上使用它存在问题，因为我们不能依赖客户端的 Web 浏览器支持特定版本的 Java，甚至不能保证浏览器支持 Java。在企业内部网中，我们可以要求特定的支持，这会提供更多的灵活性，但在 Web 上，最安全的方法是在服务器端处理所有处理，并将纯 HTML 页面发送给客户端，这样就不会有客户端因为没有安装适当的软件而无法使用我们的网站。
Servlet 为服务器端编程提供了出色的支持，这也是转向 Java 的最常见原因之一。它不仅提供了一个替代 CGI 编程的框架，还消除了许多棘手的 CGI 问题，而且所有代码都具有 Java 的平台可移植性，并且可以访问所有 Java API（当然，除了像 Swing 这样生成图形用户界面的 API）。
2. 基本 Servlet
Servlet API 的架构是一个经典的服务提供者架构，有一个
service()
方法，所有客户端请求都会通过 Servlet 容器软件发送到该方法，还有生命周期方法
init()
和
destroy()
，这两个方法仅在 Servlet 加载和卸载时调用（这种情况很少发生）。
public interface Servlet {
public void init(ServletConfig config)
throws ServletException;
public ServletConfig getServletConfig();
public void service(ServletRequest req,
ServletResponse res)
throws ServletException, IOException;
public String getServletInfo();
public void destroy();
}
getServletConfig()
方法的唯一目的是返回一个
ServletConfig
对象，该对象包含此 Servlet 的初始化和启动参数。
getServletInfo()
方法返回一个包含 Servlet 信息的字符串，如作者、版本和版权信息。
GenericServlet
类是这个接口的一个简单实现，通常不使用。
HttpServlet
类是
GenericServlet
的扩展，专门用于处理 HTTP 协议，我们大多数时候会使用
HttpServlet
。
Servlet API 最方便的特性是与
HttpServlet
类一起提供的辅助对象。在
Servlet
接口的
service()
方法中，有两个参数：
ServletRequest
和
ServletResponse
。在
HttpServlet
类中，这两个对象被扩展为
HttpServletRequest
和
HttpServletResponse
。以下是一个简单的示例，展示了
HttpServletResponse
的使用：
//: c15:servlets:ServletsRule.java
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class ServletsRule extends HttpServlet {
int i = 0; // Servlet "persistence"
public void service(HttpServletRequest req,
HttpServletResponse res) throws IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
out.print("<HEAD><TITLE>");
out.print("A server-side strategy");
out.print("</TITLE></HEAD><BODY>");
out.print("<h1>Servlets Rule! " + i++);
out.print("</h1></BODY>");
out.close();
}
} ///:~
ServletsRule
是一个非常简单的 Servlet。在 Servlet 容器首次启动并加载 Servlet 时，会调用
init()
方法对其进行初始化，且仅初始化一次。当客户端请求一个代表 Servlet 的 URL 时，Servlet 容器会拦截该请求，设置好
HttpServletRequest
和
HttpServletResponse
对象后，调用
service()
方法。
service()
方法的主要职责是与客户端发送的 HTTP 请求进行交互，并根据请求中的属性构建 HTTP 响应。
ServletsRule
只操作响应对象，而不查看客户端发送的内容。在设置响应的内容类型（这必须在获取
Writer
或
OutputStream
之前完成）后，响应对象的
getWriter()
方法会生成一个
PrintWriter
对象，用于写入基于字符的响应数据（或者，
getOutputStream()
方法会生成一个
OutputStream
，用于二进制响应，这通常在更专业的解决方案中使用）。
运行这个程序时，我们会注意到变量
i
的值在对 Servlet 的多次请求之间会保留。这是 Servlet 的一个重要特性，因为一个特定类的 Servlet 只会在容器中加载一次，并且除非 Servlet 容器终止（通常只有在重启服务器计算机时才会发生），否则不会卸载，所以该 Servlet 类的任何字段实际上都变成了持久对象。这意味着我们可以轻松地在 Servlet 请求之间维护值，而在使用 CGI 时，我们必须将值写入磁盘才能保存它们，这需要很多额外的操作，并且不是跨平台的解决方案。
当然，有时 Web 服务器和 Servlet 容器需要进行维护或在停电时重启。为了避免丢失任何持久信息，在 Servlet 加载或卸载时，会自动调用
init()
和
destroy()
方法，这给了我们在关机时保存数据并在重启后恢复数据的机会。只要服务器机器配置合理，Servlet 容器在终止时会调用
destroy()
方法，我们就有机会保存有价值的数据。
使用
HttpServlet
时还有一个问题。该类提供了
doGet()
和
doPost()
方法，用于区分客户端的 CGI “GET” 和 “POST” 提交。GET 和 POST 只是在提交数据的细节上有所不同，作者个人倾向于忽略这些差异。然而，大多数已发布的信息似乎更倾向于创建单独的
doGet()
和
doPost()
方法，而不是使用一个通用的
service()
方法来处理这两种情况。这种偏好很常见，但作者从未看到过一个能让他相信这不仅仅是习惯于关注 GET 或 POST 的 CGI 程序员的惯性思维的解释。因此，本着“做最简单可行的事情”的精神，作者在这些示例中使用
service()
方法来处理 GET 和 POST 请求。不过，我们要记住，可能有一个很好的理由使用
doGet()
和
doPost()
方法。
当一个表单提交到 Servlet 时，
HttpServletRequest
对象会预先加载所有表单数据，这些数据以键值对的形式存储。如果我们知道字段的名称，可以直接使用
getParameter()
方法查找值。我们还可以获取一个
Enumeration
（迭代器的旧形式）来遍历字段名称，以下示例展示了这一点，同时也演示了如何使用一个 Servlet 生成包含表单的页面并响应该页面：
//: c15:servlets:EchoForm.java
// Dumps the name-value pairs of any HTML form
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
public class EchoForm extends HttpServlet {
public void service(HttpServletRequest req,
HttpServletResponse res) throws IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
Enumeration flds = req.getParameterNames();
if(!flds.hasMoreElements()) {
// No form submitted -- create one:
out.print("<html>");
out.print("<form method=\"POST\"" +
" action=\"EchoForm\">");
for(int i = 0; i < 10; i++)
out.print("<b>Field" + i + "</b> " +
"<input type=\"text\""+
" size=\"20\" name=\"Field" + i +
"\" value=\"Value" + i + "\"><br>");
out.print("<INPUT TYPE=submit name=submit"+
" Value=\"Submit\"></form></html>");
} else {
out.print("<h1>Your form contained:</h1>");
while(flds.hasMoreElements()) {
String field= (String)flds.nextElement();
String value= req.getParameter(field);
out.print(field + " = " + value+ "<br>");
}
}
out.close();
}
} ///:~
这里我们会注意到 Java 在字符串处理方面似乎设计得不太好，返回页面的格式化很麻烦，因为需要处理换行符、转义引号和连接字符串的 “+” 号。对于较大的 HTML 页面，直接在 Java 中编写代码是不合理的。一种解决方案是将页面保存为一个单独的文本文件，然后打开它并将其交给 Web 服务器。如果需要对页面内容进行任何替换，情况也不会好多少，因为 Java 在字符串处理方面表现不佳。在这些情况下，我们可能最好使用更合适的解决方案（作者推荐 Python，有一个嵌入 Java 的版本叫 JPython）来生成响应页面。
3. Servlet 与多线程
Servlet 容器有一个线程池，用于处理客户端请求。很有可能两个客户端同时到达，同时通过
service()
方法进行处理。因此，
service()
方法必须以线程安全的方式编写。任何对公共资源（文件、数据库）的访问都需要使用
synchronized
关键字进行保护。
以下是一个简单的示例，在线程的
sleep()
方法周围添加了一个同步块，这会阻塞所有其他线程，直到指定的时间（五秒）用完。测试时，我们应该启动多个浏览器实例，并尽快在每个实例中访问这个 Servlet，我们会看到每个实例都必须等待轮到自己：
//: c15:servlets:ThreadServlet.java
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class ThreadServlet extends HttpServlet {
int i;
public void service(HttpServletRequest req,
HttpServletResponse res) throws IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
synchronized(this) {
try {
Thread.currentThread().sleep(5000);
} catch(InterruptedException e) {
System.err.println("Interrupted");
}
}
out.print("<h1>Finished " + i++ + "</h1>");
out.close();
}
} ///:~
我们也可以在
service()
方法前面加上
synchronized
关键字来同步整个 Servlet。实际上，只有当关键部分位于可能不会执行的执行路径中时，才使用同步块。在这种情况下，我们可以使用同步块避免每次都进行同步的开销。否则，所有线程都必须等待，所以我们最好同步整个方法。
4. 使用 Servlet 处理会话
HTTP 是一种“无会话”协议，我们无法从一次服务器访问判断是否是同一个人多次查询我们的网站，还是完全不同的人。因此，Web 开发人员投入了大量精力来实现会话跟踪机制。例如，企业如果不跟踪客户及其购物车中的商品，就无法进行电子商务。
会话跟踪有几种方法，最常见的是使用持久的“cookie”，这是互联网标准的一部分。互联网工程任务组的 HTTP 工作组已将 cookie 写入了官方标准 RFC 2109 中。
cookie 只是 Web 服务器发送给浏览器的一小段信息。浏览器将 cookie 存储在本地磁盘上，每当再次访问与该 cookie 关联的 URL 时，cookie 会随请求一起悄悄发送，从而将所需信息返回给服务器（通常是让服务器知道是你在访问）。然而，客户端可以关闭浏览器接受 cookie 的功能。如果我们的网站必须跟踪关闭了 cookie 的客户端，就必须手动实现其他会话跟踪方法（URL 重写或隐藏表单字段），因为 Servlet API 内置的会话跟踪功能是围绕 cookie 设计的。
4.1 Cookie 类
Servlet API（2.0 及以上版本）提供了
Cookie
类，该类包含了所有 HTTP 头细节，并允许设置各种 cookie 属性。使用 cookie 只需将其添加到响应对象中。构造函数的第一个参数是 cookie 名称，第二个参数是值。在发送任何内容之前，我们需要将 cookie 添加到响应对象中：
Cookie oreo = new Cookie("TIJava", "2000");
res.addCookie(cookie);
通过调用
HttpServletRequest
对象的
getCookies()
方法可以恢复 cookie，该方法返回一个 cookie 对象数组：
Cookie[] cookies = req.getCookies();
然后，我们可以为每个 cookie 调用
getValue()
方法，以获取包含 cookie 内容的字符串。在上面的示例中，
getValue("TIJava")
将返回包含 “2000” 的字符串。
4.2 Session 类
会话是指客户端在一段定义的时间内对网站进行的一次或多次页面请求。例如，当我们在线购买杂货时，我们希望会话从第一次将商品添加到“我的购物车”到结账的这段时间内有效。每次向购物车添加商品都会导致一个新的 HTTP 连接，而该连接对之前的连接或购物车中的商品一无所知。为了弥补这种信息缺失，cookie 规范提供的机制允许我们的 Servlet 进行会话跟踪。
Servlet 的
Session
对象位于通信通道的服务器端，其目标是在客户端浏览和与我们的网站交互时，捕获有关该客户端的有用数据。这些数据可能与当前会话相关，如购物车中的商品，也可能是客户端首次访问网站时输入的认证信息，在特定的交易过程中不需要重新输入。
Servlet API 的
Session
类使用
Cookie
类来完成其工作。然而，
Session
对象只需要某种存储在客户端并传递给服务器的唯一标识符。网站也可以使用其他类型的会话跟踪方法，但这些机制实现起来更困难，因为它们没有封装在 Servlet API 中（也就是说，我们必须手动编写代码来处理客户端禁用 cookie 的情况）。
以下是一个使用 Servlet API 实现会话跟踪的示例：
//: c15:servlets:SessionPeek.java
// Using the HttpSession class.
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class SessionPeek extends HttpServlet {
public void service(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException {
// Retrieve Session Object before any
// output is sent to the client.
HttpSession session = req.getSession();
res.setContentType("text/html");
PrintWriter out = res.getWriter();
out.println("<HEAD><TITLE> SessionPeek ");
out.println(" </TITLE></HEAD><BODY>");
out.println("<h1> SessionPeek </h1>");
// A simple hit counter for this session.
Integer ival = (Integer)
session.getAttribute("sesspeek.cntr");
if(ival==null)
ival = new Integer(1);
else
ival = new Integer(ival.intValue() + 1);
session.setAttribute("sesspeek.cntr", ival);
out.println("You have hit this page <b>"
+ ival + "</b> times.<p>");
out.println("<h2>");
out.println("Saved Session Data </h2>");
// Loop through all data in the session:
Enumeration sesNames =
session.getAttributeNames();
while(sesNames.hasMoreElements()) {
String name =
sesNames.nextElement().toString();
Object value = session.getAttribute(name);
out.println(name + " = " + value + "<br>");
}
out.println("<h3> Session Statistics </h3>");
out.println("Session ID: "
+ session.getId() + "<br>");
out.println("New Session: " + session.isNew()
+ "<br>");
out.println("Creation Time: "
+ session.getCreationTime());
out.println("<I>(" +
new Date(session.getCreationTime())
+ ")</I><br>");
out.println("Last Accessed Time: " +
session.getLastAccessedTime());
out.println("<I>(" +
new Date(session.getLastAccessedTime())
+ ")</I><br>");
out.println("Session Inactive Interval: "
+ session.getMaxInactiveInterval());
out.println("Session ID in Request: "
+ req.getRequestedSessionId() + "<br>");
out.println("Is session id from Cookie: "
+ req.isRequestedSessionIdFromCookie()
+ "<br>");
out.println("Is session id from URL: "
+ req.isRequestedSessionIdFromURL()
+ "<br>");
out.println("Is session id valid: "
+ req.isRequestedSessionIdValid()
+ "<br>");
out.println("</BODY>");
out.close();
}
public String getServletInfo() {
return "A session tracking servlet";
}
} ///:~
在
service()
方法内部，我们调用请求对象的
getSession()
方法，该方法返回与该请求关联的
Session
对象。
Session
对象不会在网络上传输，而是存在于服务器上，并与客户端及其请求相关联。
getSession()
有两个版本：无参数版本（如这里使用的）和
getSession(boolean)
版本。
getSession(true)
等同于
getSession()
。布尔参数的作用是指定如果找不到会话对象，是否要创建它。最常用的调用是
getSession(true)
，也就是
getSession()
。
如果
Session
对象不是新的，它会提供客户端之前访问的详细信息。如果是新的，程序会开始收集客户端此次访问的活动信息。通过会话对象的
setAttribute()
和
getAttribute()
方法可以捕获客户端信息：
java.lang.Object getAttribute(java.lang.String)
void setAttribute(java.lang.String name,
java.lang.Object value)
Session
对象使用简单的名称 - 值对来加载信息，名称是一个字符串，值可以是任何从
java.lang.Object
派生的对象。
SessionPeek
通过一个名为
sesspeek.cntr
的
Integer
对象来跟踪客户端在本次会话中访问的次数。如果该名称不存在，则创建一个值为 1 的
Integer
对象；否则，创建一个值为之前
Integer
对象值加 1 的新对象，并将其放入
Session
对象中。如果在
setAttribute()
调用中使用相同的键，新对象会覆盖旧对象。递增的计数器用于显示客户端在本次会话中访问的次数。
getAttributeNames()
方法与
getAttribute()
和
setAttribute()
相关，它返回一个绑定到
Session
对象的对象名称的枚举。
SessionPeek
中的一个
while
循环展示了该方法的使用。
我们可能会想知道
Session
对象会存在多久。答案取决于我们使用的 Servlet 容器，它们通常默认设置为 30 分钟（1800 秒），这可以从
SessionPeek
调用
getMaxInactiveInterval()
方法中看到。不同的 Servlet 容器测试结果可能不同，有时
Session
对象可以存在一整晚，但作者从未见过
Session
对象在指定时间之前消失的情况。
以下是本文的一些关键信息总结表格：
| 主题 | 关键内容 |
|---|---|
| 传统 CGI 处理流程 | 用户输入信息 -> 提交数据与 URL -> 服务器调用 CGI 程序 -> CGI 程序处理数据并返回 HTML 页面 |
| Servlet 特性 | 平台可移植性、替代 CGI 编程、持久对象、线程安全 |
| 会话跟踪方法 | Cookie、URL 重写、隐藏表单字段 |
下面是一个简单的 mermaid 流程图，展示了 Servlet 的基本处理流程：
graph LR
A[客户端请求] --> B[Servlet 容器拦截]
B --> C[设置 HttpServletRequest 和 HttpServletResponse]
C --> D[调用 service() 方法]
D --> E{数据格式是否正确}
E -- 是 --> F[处理数据并返回 HTML 响应]
E -- 否 --> G[生成错误 HTML 页面返回]
通过以上内容，我们对 Servlet 的基本概念、使用方法、多线程处理和会话跟踪有了一个全面的了解。在实际开发中，我们可以根据具体需求选择合适的方法来实现服务器端编程。
Java Servlet 开发全解析
5. 处理表单数据
当表单提交到 Servlet 时，
HttpServletRequest
对象会包含所有表单数据。通过
getParameter()
方法可以方便地获取特定字段的值。下面详细介绍处理表单数据的流程：
1.
获取表单字段名称
：使用
getParameterNames()
方法返回一个
Enumeration
对象，用于遍历所有表单字段的名称。
2.
获取字段值
：对于每个字段名称，调用
getParameter()
方法获取其对应的值。
以下是一个示例代码，展示了如何处理表单数据：
//: c15:servlets:FormDataHandler.java
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
public class FormDataHandler extends HttpServlet {
public void service(HttpServletRequest req, HttpServletResponse res) throws IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
Enumeration<String> flds = req.getParameterNames();
out.print("<h1>Form Data:</h1>");
while (flds.hasMoreElements()) {
String field = flds.nextElement();
String value = req.getParameter(field);
out.print(field + " = " + value + "<br>");
}
out.close();
}
} ///:~
在这个示例中，Servlet 接收表单数据并将每个字段的名称和值显示在页面上。
6. 异常处理
在 Servlet 开发中，异常处理是非常重要的。
service()
方法通常会抛出
ServletException
和
IOException
，我们需要对这些异常进行适当的处理。以下是一个异常处理的示例：
//: c15:servlets:ExceptionHandlingServlet.java
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class ExceptionHandlingServlet extends HttpServlet {
public void service(HttpServletRequest req, HttpServletResponse res) {
try {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
// 模拟可能抛出异常的操作
int result = 1 / 0;
out.print("<h1>Success!</h1>");
out.close();
} catch (IOException e) {
e.printStackTrace();
try {
res.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "IO Error");
} catch (IOException ioException) {
ioException.printStackTrace();
}
} catch (ArithmeticException e) {
e.printStackTrace();
try {
res.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Arithmetic Error");
} catch (IOException ioException) {
ioException.printStackTrace();
}
}
}
} ///:~
在这个示例中，
service()
方法中模拟了一个可能抛出异常的操作。如果发生
IOException
或
ArithmeticException
，会将错误信息发送给客户端。
7. Servlet 配置
Servlet 需要在
web.xml
文件中进行配置，以便 Servlet 容器能够正确识别和调用。以下是一个简单的
web.xml
配置示例：
<servlet>
<servlet-name>MyServlet</servlet-name>
<servlet-class>com.example.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyServlet</servlet-name>
<url-pattern>/myServlet</url-pattern>
</servlet-mapping>
在这个配置中，
servlet-name
是 Servlet 的名称，
servlet-class
是 Servlet 类的全限定名，
url-pattern
是映射到该 Servlet 的 URL 模式。
8. 性能优化
为了提高 Servlet 的性能，我们可以采取以下措施：
1.
使用连接池
：对于数据库连接，使用连接池可以减少连接的创建和销毁开销。
2.
缓存数据
：对于一些频繁使用的数据，可以进行缓存，减少数据库查询次数。
3.
优化代码
：避免在
service()
方法中进行耗时的操作，如文件读写、网络请求等。
以下是一个使用连接池的示例：
//: c15:servlets:ConnectionPoolServlet.java
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSource;
public class ConnectionPoolServlet extends HttpServlet {
private static DataSource dataSource;
static {
BasicDataSource basicDataSource = new BasicDataSource();
basicDataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
basicDataSource.setUsername("root");
basicDataSource.setPassword("password");
basicDataSource.setInitialSize(5);
basicDataSource.setMaxTotal(10);
dataSource = basicDataSource;
}
public void service(HttpServletRequest req, HttpServletResponse res) throws IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
try (Connection conn = dataSource.getConnection();
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
while (rs.next()) {
out.print(rs.getString("username") + "<br>");
}
} catch (Exception e) {
e.printStackTrace();
}
out.close();
}
} ///:~
在这个示例中，使用了 Apache Commons DBCP2 连接池来管理数据库连接。
9. 总结
通过本文的介绍，我们全面了解了 Java Servlet 的开发。从基本概念到具体实现，包括 Servlet 的生命周期、多线程处理、会话跟踪、表单数据处理、异常处理、配置和性能优化等方面。以下是本文的关键要点总结：
-
基本概念
：Servlet 是服务器端的 Java 程序，用于处理客户端的 HTTP 请求。
-
生命周期
：包括
init()
、
service()
和
destroy()
方法。
-
多线程处理
：
service()
方法需要保证线程安全，对公共资源的访问要进行同步。
-
会话跟踪
：使用
Cookie
和
Session
类来实现会话跟踪。
-
表单数据处理
：通过
HttpServletRequest
对象获取表单数据。
-
异常处理
：对
ServletException
和
IOException
等异常进行适当处理。
-
配置
：在
web.xml
文件中配置 Servlet。
-
性能优化
：使用连接池、缓存数据和优化代码等方法提高性能。
以下是一个 mermaid 流程图，展示了 Servlet 开发的整体流程：
graph LR
A[客户端请求] --> B[Servlet 容器]
B --> C{Servlet 是否存在}
C -- 是 --> D[调用 init() 方法（首次加载）]
C -- 否 --> E[创建并加载 Servlet]
D --> F[调用 service() 方法]
E --> F
F --> G{数据处理}
G -- 成功 --> H[返回响应]
G -- 失败 --> I[处理异常并返回错误信息]
希望本文能够帮助你更好地掌握 Java Servlet 开发，在实际项目中能够灵活运用这些知识。
扫一扫
371
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
