JSP基础界面开发实战教程

原创于 2025-07-27 12:11:50 发布 · 699 阅读

CC 4.0 BY-SA版权

简介：JavaServer Pages（JSP）是创建动态网页的技术，它将HTML与Java代码结合。本项目“简单的JSP界面”展示了如何利用JSP构建基础用户界面并实现数据库交互。项目涵盖JSP文件结构、数据库操作（通过JDBC）和用户控件使用。通过分析项目的代码实现，初学者能够掌握JSP的基本概念和动态网页的生成过程。

1. JSP基础知识介绍

简介

JavaServer Pages（JSP）是一种用于开发动态Web内容的开源技术。它允开发者将Java代码嵌入到HTML页面中，以便生成动态内容。自1999年发布以来，JSP一直是开发基于Java的Web应用程序的重要工具之一。

JSP的历史和作用

JSP技术是与Servlet技术一起推出的，它解决了直接使用Java代码编写HTML的繁琐问题，提高了开发效率。JSP页面在服务器端被转换成Servlet，然后由Java虚拟机（JVM）执行，生成最终的HTML响应发送给客户端。这一过程保证了内容的动态性和应用程序的可移植性。

JSP文件结构和基本语法

一个基本的JSP文件由HTML内容和嵌入的Java代码组成。JSP的基本语法包括JSP指令、脚本元素、表达式和声明。指令用于设置与整个JSP页面相关的属性，如错误页面和缓冲区大小。脚本元素允许开发者编写可执行的Java代码，而表达式和声明则用于输出表达式的结果和定义方法或变量。

JSP的发展至今已有多个版本，每个版本都对原有的功能进行了扩展和优化，以适应不断变化的Web开发需求。理解JSP的基础知识，为进一步学习JSP高级应用打下了坚实的基础。

2. JSP页面与HTML的结合方式

2.1 页面布局设计

JSP页面的布局设计是构建动态网页的基础。理解如何将JSP与HTML结合，可以让我们设计出既美观又功能强大的Web应用界面。

2.1.1 使用JSP包含指令与HTML整合

JSP提供了一种包含指令功能，可以将HTML代码嵌入到JSP页面中，从而使页面布局和设计更加灵活和模块化。

<!-- 假设我们有一个头部header.jsp -->
<%@ include file="header.jsp" %>

使用 <%@ include %> 指令可以将其他JSP文件、HTML文件或其他文本文件的内容包含进来。这种方法特别适用于将常用的页面元素（如头部、尾部、导航栏等）分离出来，以便在不同的页面中重复使用。这种方式不仅有助于维护，还可以提高页面加载速度。

2.1.2 利用JSP标签库增强HTML功能

JSP标签库提供了一组扩展标签，可以更方便地处理动态内容，并且可以减少Java代码的使用，让HTML页面看起来更加清晰。

<c:forEach var="item" items="${list}">
    <tr>
        <td>${item.name}</td>
        <td>${item.price}</td>
    </tr>
</c:forEach>

在这个例子中， <c:forEach> 标签用于遍历一个列表并显示每个项目的名称和价格。这种标签库的使用，使得JSP页面可以专注于展现逻辑，而将业务逻辑的处理交给后端Java代码。

2.2 JSP与CSS、JavaScript的融合

JSP和CSS、JavaScript的结合是前端开发人员必须掌握的技能。掌握它们的融合方式，对于创建响应式和交互式的Web页面至关重要。

2.2.1 在JSP页面中嵌入CSS和JavaScript

在JSP中嵌入CSS和JavaScript可以通过多种方式完成，最常见的是使用 <link> 和 <script> 标签。

<head>
    <link rel="stylesheet" type="text/css" href="style.css">
    <script type="text/javascript" src="script.js"></script>
</head>

上述代码演示了如何在JSP页面的 <head> 部分引入外部CSS文件和JavaScript文件。通常建议将CSS和JavaScript代码分别放在单独的文件中，这样做不仅有助于保持页面的清晰，还可以利用浏览器缓存来加速页面加载。

2.2.2 实现动态内容与静态样式的分离

为了提高页面加载速度和维护性，将动态内容和静态样式分离是一个好的实践。

graph LR
A[JSP页面] -->|包含| B[HTML标签]
B -->|引用| C[CSS样式表]
B -->|引用| D[JavaScript文件]
C -.-> E[样式定义]
D -.-> F[行为控制]

如上图所示，通过JSP页面引用HTML标签，再通过HTML标签引用CSS样式表和JavaScript文件，我们实现了静态样式与动态内容的分离。这样的设计不仅使得网页的视觉效果和交互行为更容易被修改和扩展，也提高了Web应用的整体性能。

在下一章节中，我们将深入探讨JSP的核心脚本元素，以及它们在页面中的具体应用。这将为我们的Web开发之旅带来更深刻的理解和技术提升。

3. 脚本元素、表达式和声明的使用

3.1 脚本元素的应用

3.1.1 Java代码块的插入与作用域

在JSP页面中，可以通过特定的脚本元素插入Java代码，以实现更复杂的逻辑处理。JSP提供了三种脚本元素：声明、脚本片段和表达式。Java代码块通常是作为脚本片段插入的，使用 <% 和 %> 包围。例如：

<%!
// 声明类级别的变量和方法
private String globalVar = "Hello World";
public void printVar() {
    out.println(globalVar);
}
%>

在上面的代码片段中，我们声明了一个类级别的变量 globalVar 和一个方法 printVar ，它们的作用域是整个JSP页面。这种声明通常用于定义那些需要在多个脚本片段或者表达式中使用的变量或方法。

<%
// 脚本片段，用于处理请求时的逻辑
String message = request.getParameter("message");
if(message != null) {
    out.println("Received message: " + message);
}
%>

在上面的脚本片段中，我们处理了用户通过表单提交的消息。这里的代码只能在当前JSP页面内访问，它的作用域仅限于脚本片段内部。

脚本片段虽然提供了灵活性，但应谨慎使用，因为过多的Java代码会导致JSP页面难以维护。通常推荐尽可能使用JSP标准标签库（JSTL）或表达式语言（EL）来替代直接编写Java代码。

3.1.2 脚本片段的执行时机

脚本片段在JSP页面被请求时执行。具体来说，JSP容器在处理JSP页面请求时，会将所有的脚本片段进行翻译和执行。这就意味着脚本中的逻辑是在服务器端执行的，输出的结果通常发送给客户端。

执行时机示例：

<%
// 检查用户是否已登录
if(session.getAttribute("user") == null) {
    response.sendRedirect("login.jsp");
}
%>

在这段脚本片段中，我们检查用户是否已经登录。如果用户未登录，页面会重定向到登录页面。这里需要注意的是，这种检查通常在页面处理逻辑的开始阶段执行，以确保只有登录的用户能够访问页面的其他部分。

3.2 表达式和声明的区别与用途

3.2.1 理解表达式与声明的语法和功能

表达式和声明在JSP中用于不同的目的。表达式用于输出数据到响应中，它的结果总是字符串。表达式使用 <%= expression %> 来定义。例如：

<%= "Current date and time: " + new java.util.Date() %>

在上面的例子中，表达式输出了当前的日期和时间。这里，表达式中的内容被计算并转换成字符串后输出到客户端。

声明用于在JSP页面中声明变量或方法，它们不会直接输出任何内容到响应中，但可以在脚本片段或表达式中被使用。例如：

<%! String constant = "A constant value"; %>
<%
    // 在这里可以使用constant变量
%>

在这个例子中，我们声明了一个常量 constant ，该常量可以在整个JSP页面中使用，但它本身不会被直接输出到响应中。

3.2.2 在JSP页面中合理运用表达式和声明

在实际开发中，合理运用表达式和声明非常重要，因为这直接影响到代码的可读性和可维护性。一般建议，只有那些需要在多个地方使用的变量或方法才应该声明，而临时需要输出到客户端的数据则应该使用表达式来处理。

例如，如果我们在页面中多次需要格式化日期，可以声明一个方法来处理：

<%! 
    private String formatDateTime(Date date) {
        // 使用SimpleDateFormat来格式化日期
    }
%>

然后在需要输出格式化日期的地方，使用表达式调用该方法：

<%= formatDateTime(new java.util.Date()) %>

通过这种方式，可以保持JSP页面的简洁，同时也使得业务逻辑和表示逻辑分离，提高代码的可维护性。

4. JDBC数据库连接操作

4.1 JDBC基础概念与连接步骤

4.1.1 掌握JDBC驱动的加载与连接数据库的流程

Java数据库连接（Java Database Connectivity，简称JDBC）是一个Java API，能够执行SQL语句。它提供了独立于特定数据库管理系统（DBMS）的统一方法来查询和更新数据库中的数据。为了使用JDBC，首先需要了解如何加载JDBC驱动，这是与数据库进行通信的第一步。

加载JDBC驱动通常有如下几种方式：
1. 静态加载驱动：

Class.forName("com.mysql.cj.jdbc.Driver");

这段代码会尝试加载MySQL JDBC驱动类，并将其实例注册到JDBC驱动管理器中。

动态加载驱动：

DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());

这种方式直接创建了一个驱动实例并注册。

在实际开发中，推荐使用静态加载方式，因为它能确保在创建 DriverManager 之前加载驱动类，避免了重复加载驱动的问题。

加载了驱动之后，接下来是建立数据库连接。通常会使用 DriverManager.getConnection() 方法来建立连接，需要提供数据库的URL，登录用户名和密码。

4.1.2 理解JDBC连接对象、语句对象和结果集对象

连接对象（Connection） ：它是JDBC架构中的关键对象，用于和特定数据库进行连接。通过调用 DriverManager.getConnection() 返回一个Connection对象。
语句对象（Statement） ：用于发送SQL语句到数据库，执行SQL查询，并返回结果。可以通过Connection对象的 createStatement() 方法创建一个Statement实例。
结果集对象（ResultSet） ：它代表了SQL查询语句执行后返回的数据集，是结果集对象的集合，用于遍历查询结果。

代码示例：

Connection con = DriverManager.getConnection(url, user, password);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM table_name");

4.2 高效的数据库连接管理

4.2.1 使用数据库连接池提升性能

数据库连接池是一种用于管理数据库连接的技术，它可以显著减少建立和释放数据库连接所需的时间。连接池是一种创建一定数量连接并将其保持为打开状态的容器，当应用程序需要连接数据库时，可以从池中获得一个连接，而不是创建一个新的连接。

使用连接池的原因包括减少资源消耗、提高系统响应速度和提升资源利用率。

代码示例：

DataSource dataSource = new ComboPooledDataSource();
Connection connection = dataSource.getConnection();
try {
    // Do work with the connection
} finally {
    connection.close();
}

在实际应用中，会用到连接池的配置参数，如最小连接数、最大连接数、连接的最大存活时间等，来确保连接池的高效运行。

4.2.2 异常处理与数据库资源的正确释放

处理JDBC编程中的异常是确保资源正确释放的关键。JDBC定义了SQLException类来处理可能发生的各种数据库错误。正确地捕获和处理这些异常不仅可以帮助我们调试程序，还能确保在出现异常时释放数据库资源。

代码示例：

Connection connection = null;
try {
    connection = dataSource.getConnection();
    // 使用connection进行数据库操作...
} catch (SQLException e) {
    // 处理异常...
} finally {
    if (connection != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            // 处理关闭连接时的异常...
        }
    }
}

在JDBC中，通常会有两个资源需要释放：Connection和ResultSet。ResultSet的关闭应在Connection之前完成，因为关闭Connection也会自动关闭当前打开的ResultSet。

将上述代码逻辑结合到一个表格中，可帮助理解JDBC连接对象、语句对象和结果集对象的生命周期：

对象	描述	创建方式	使用注意	关闭时机
Connection	数据库连接	DriverManager.getConnection()	避免频繁创建和销毁	应用结束或异常处理后
Statement	执行SQL语句	Connection.createStatement()	防止SQL注入风险	SQL执行完后
ResultSet	SQL查询结果集	Statement.executeQuery()	逐条读取数据	数据读取完后

表格中的每一行都是对JDBC对象生命周期的一个简短总结，用以指导开发者正确管理JDBC资源。

在接下来的章节中，我们会探讨JSP数据库操作实践（查询、更新等），深入分析SQL查询语句的使用，以及如何在JSP中展示查询结果，进一步提升我们的数据库操作技能。

5. JSP数据库操作实践（查询、更新等）

数据库操作是JSP应用中的重要环节，它允许动态地与数据存储进行交互，执行查询、更新等操作。本章节将深入探讨如何在JSP中实现高效且安全的数据库操作实践。

5.1 数据查询操作的实现

5.1.1 掌握SQL查询语句的使用

在进行数据库操作之前，首先需要掌握SQL（Structured Query Language）查询语句的基本使用。SQL是用于访问和处理数据库的标准编程语言。以下是一些基本的SQL查询语句：

SELECT 语句用于从数据库中选择数据。
WHERE 子句用于过滤记录。
JOIN 用于结合两个或多个表中的行。
ORDER BY 用于对结果集进行排序。
LIMIT 限制结果集的行数。

-- 示例查询语句：从用户表中选择所有记录并按年龄排序
SELECT * FROM users ORDER BY age;

在JSP页面中，通常会将SQL查询语句嵌入Java代码片段中，例如使用 PreparedStatement 来避免SQL注入攻击并提高性能。

5.1.2 在JSP中展示查询结果

一旦执行了SQL查询，获取结果并在JSP页面中展示是一个直接的过程。首先，需要通过数据库连接执行查询，并将结果集传递到JSP页面。然后，可以使用JSP内置对象如 request 、 response 、 out 来控制展示逻辑。

<%@ page import="java.sql.*" %>
<%
    Connection conn = null;
    PreparedStatement pstmt = null;
    ResultSet rs = null;
    try {
        Class.forName("com.mysql.jdbc.Driver");
        conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/yourdb", "username", "password");
        String sql = "SELECT * FROM users";
        pstmt = conn.prepareStatement(sql);
        rs = pstmt.executeQuery();
%>
<html>
<head>
    <title>User List</title>
</head>
<body>
    <table border="1">
        <tr>
            <th>ID</th>
            <th>Name</th>
            <th>Age</th>
        </tr>
        <% 
            while (rs.next()) {
                out.println("<tr>");
                out.println("<td>" + rs.getInt("id") + "</td>");
                out.println("<td>" + rs.getString("name") + "</td>");
                out.println("<td>" + rs.getInt("age") + "</td>");
                out.println("</tr>");
            }
        %>
    </table>
</body>
</html>
<%
    if (rs != null) try { rs.close(); } catch (SQLException ignore) {}
    if (pstmt != null) try { pstmt.close(); } catch (SQLException ignore) {}
    if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
%>

展示查询结果需要结合HTML和JSP标签，如上述代码示例中使用 <table> 标签展示用户列表。

5.2 数据更新与事务管理

5.2.1 实现数据的插入、更新和删除操作

数据的插入、更新和删除操作在JSP中是通过执行SQL的 INSERT 、 UPDATE 和 DELETE 语句来实现的。它们通常在JSP页面中的Java代码块中执行，并与数据库交互。

<%@ page import="java.sql.*" %>
<%
    Connection conn = null;
    PreparedStatement pstmt = null;
    try {
        Class.forName("com.mysql.jdbc.Driver");
        conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/yourdb", "username", "password");
        // 插入操作示例
        String insertSQL = "INSERT INTO users (name, age) VALUES (?, ?)";
        pstmt = conn.prepareStatement(insertSQL);
        pstmt.setString(1, "John Doe");
        pstmt.setInt(2, 30);
        pstmt.executeUpdate();
        // 更新操作示例
        String updateSQL = "UPDATE users SET age = ? WHERE id = ?";
        pstmt = conn.prepareStatement(updateSQL);
        pstmt.setInt(1, 31);
        pstmt.setInt(2, 1);
        pstmt.executeUpdate();
        // 删除操作示例
        String deleteSQL = "DELETE FROM users WHERE id = ?";
        pstmt = conn.prepareStatement(deleteSQL);
        pstmt.setInt(1, 1);
        pstmt.executeUpdate();
    } catch (Exception e) {
        // 处理异常
    } finally {
        if (pstmt != null) try { pstmt.close(); } catch (SQLException ignore) {}
        if (conn != null) try { conn.close(); } catch (SQLException ignore) {}
    }
%>

在执行更新操作时，确保数据库连接正确，并且在发生错误时能够进行适当异常处理。

5.2.2 理解事务的概念及在JSP中的应用

事务是一组数据库操作，它们作为一个单独的工作单元执行。事务确保了数据的完整性和一致性，即使在出现错误的情况下也能保证数据不会被部分更新。

在JSP中，可以通过设置连接的自动提交属性来管理事务：

conn.setAutoCommit(false); // 关闭自动提交

try {
    // 执行一组操作...
    conn.commit(); // 手动提交事务
} catch (Exception e) {
    conn.rollback(); // 发生错误时回滚事务
    e.printStackTrace();
}

或者，可以使用更高级的事务管理机制，如数据库连接池中提供的事务功能。

通过在JSP页面中合理使用事务，可以有效避免数据更新过程中出现的数据不一致问题，确保数据完整性。

至此，本章节已经详细介绍了在JSP中进行数据库查询操作和数据更新操作的实践，包括了SQL语句的使用、查询结果的展示、事务管理以及错误处理。通过这些内容的学习，开发者可以在JSP应用中更加安全和高效地处理数据库操作。

6. JSP内置对象使用（out等）

JSP内置对象是预定义在JSP页面中可以直接使用的对象。它们为开发者提供了与HTTP请求、响应、会话、应用环境等进行交互的能力，而无需显式创建。这些内置对象包括request, response, session, application, out, config, pageContext, page以及exception。这些对象极大地简化了Web应用的开发。

6.1 JSP内置对象概述

6.1.1 探索JSP内置对象的种类和特点

JSP内置对象覆盖了Web开发的各个方面。每个对象都有其特定的用途和生命周期：

request ：客户端的请求信息。
response ：服务器对客户端的响应。
session ：用户的会话信息，用于跟踪单个用户的活动。
application ：整个Web应用的信息，它是所有用户的共享数据。
out ：输出流，用于在JSP页面向客户端发送数据。
config ：表示servlet配置信息，如初始化参数。
pageContext ：提供了对JSP页面所有对象及命名空间的访问。
page ：代表JSP页面的实例自身，但在实际使用中较少。
exception ：仅在错误页面中使用，用于处理异常信息。

了解这些内置对象的使用场景和生命周期，对开发者来说至关重要。它们极大地简化了对HTTP请求/响应处理的编码工作，减少了重复代码的编写。

6.1.2 利用内置对象简化开发

在JSP页面中，开发者通常不需要显式地创建这些内置对象的实例。例如，下面是一个简单的JSP页面，使用内置对象out输出一段文本到客户端：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Out Object Example</title>
</head>
<body>
    <%-- 输出到客户端 --%>
    <% out.println("<h1>Welcome to JSP!</h1>"); %>
</body>
</html>

在这个例子中，我们不需要创建out对象，可以直接使用它。内置对象使得开发者可以更加专注于业务逻辑的实现，而不需要花费太多精力处理底层的细节问题。

6.2 实际案例分析

6.2.1 使用request对象处理客户端请求

request对象包含了客户端发送的请求信息，如参数、HTTP头部信息等。通过这个对象，我们可以读取表单数据、处理GET和POST请求。

下面的代码示例演示了如何使用request对象读取客户端传递的参数：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Request Object Example</title>
</head>
<body>
    <%-- 获取客户端传递的参数 --%>
    <%
        String name = request.getParameter("name");
        String email = request.getParameter("email");
    %>
    <h2>User Information:</h2>
    <p>Name: <%= name %></p>
    <p>Email: <%= email %></p>
</body>
</html>

在这个示例中，我们通过 getParameter() 方法读取了名为 name 和 email 的参数，并将其输出到HTML页面上。request对象的使用使得获取这些参数变得直接和简单。

6.2.2 使用session对象进行会话跟踪

session对象提供了一种方式，使得开发者可以在多个页面请求之间存储用户的信息。这对于跟踪用户的登录状态、购物车信息等场景非常有用。

下面的代码展示了如何使用session对象存储和检索用户信息：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Session Object Example</title>
</head>
<body>
    <%-- 存储用户信息到session对象 --%>
    <%
        session.setAttribute("username", "admin");
        String username = (String) session.getAttribute("username");
    %>
    <h2>User Information:</h2>
    <p>Welcome, <%= username %>!</p>
</body>
</html>

在这个示例中，我们使用 setAttribute() 方法将用户名存储到session对象中，并通过 getAttribute() 方法检索并显示它。session对象用于维持用户状态，是Web开发中不可或缺的组件。

通过本章的介绍，我们可以看到JSP内置对象为Web应用开发提供了极大的便利。它们使得处理HTTP请求和响应、跟踪用户会话以及在页面间共享数据变得更加简单和高效。在实际开发中，合理利用这些内置对象可以显著提高开发效率和应用性能。

7. 表单控件在JSP中的应用与HTTP请求处理

在Web应用开发中，表单是与用户交互的重要组成部分，而JSP作为Java EE中的重要组件，经常与HTML表单结合，用于收集用户输入的数据。此外，JSP页面通常与Servlet交互，以便处理来自用户的HTTP请求。本章将探讨如何在JSP中使用表单控件进行数据交互以及与Servlet的交互细节。

7.1 表单控件与数据交互

7.1.1 设计表单并收集用户输入数据

表单的创建首先需要了解HTML中的 <form> 标签，它是用来创建用户输入界面的基本元素。通过设置 action 属性，可以指定提交表单数据时所要访问的URL，而 method 属性则定义了数据提交的方式，通常为GET或POST。

以下是一个简单的HTML表单设计示例：

<form action="processForm.jsp" method="post">
    <label for="name">姓名：</label>
    <input type="text" id="name" name="name" required>
    <br>
    <label for="email">邮箱：</label>
    <input type="email" id="email" name="email" required>
    <br>
    <input type="submit" value="提交">
</form>

在上述表单中，我们创建了两个文本输入字段，分别用于用户输入姓名和邮箱，以及一个提交按钮。

7.1.2 使用JSP处理表单提交的数据

在用户点击提交按钮后，表单数据会通过HTTP POST请求发送到服务器。在JSP页面中，可以通过 request.getParameter() 方法获取这些数据。下面是一个处理上述表单数据的JSP代码示例：

<%@ page import="java.io.*" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>数据处理</title>
</head>
<body>
<%
    String name = request.getParameter("name");
    String email = request.getParameter("email");
    if (name != null && email != null) {
        out.println("用户提交的信息如下：<br>");
        out.println("姓名：" + name + "<br>");
        out.println("邮箱：" + email + "<br>");
    } else {
        out.println("请填写所有字段并重新提交表单。");
    }
%>
</body>
</html>

在这段代码中，我们通过 request.getParameter("name") 和 request.getParameter("email") 获取了用户输入的姓名和邮箱信息，并进行了简单的验证和输出。

7.2 Servlet与JSP页面的交互

7.2.1 分析Servlet作为控制器的角色

在MVC设计模式中，Servlet常常扮演控制器的角色，它负责接收请求，处理业务逻辑，并选择合适的视图进行响应。JSP页面通常作为视图层，用于展示处理后的数据。

7.2.2 实现JSP与Servlet之间的数据传递

数据通常是在Servlet处理完业务逻辑后，通过请求对象（request）传递给JSP页面的。Servlet可以使用 request.setAttribute() 方法将数据添加到请求中，然后将控制权转发给JSP页面。

以下是一个Servlet处理请求并传递数据给JSP的示例代码：

// Servlet代码片段
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    String name = request.getParameter("name");
    String email = request.getParameter("email");
    // 假设已经进行了数据验证
    request.setAttribute("name", name);
    request.setAttribute("email", email);
    // 将请求转发到JSP页面
    RequestDispatcher dispatcher = request.getRequestDispatcher("result.jsp");
    dispatcher.forward(request, response);
}

在JSP页面 result.jsp 中，我们可以使用如下代码来访问由Servlet设置的属性值：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>表单提交结果</title>
</head>
<body>
<%
    String name = (String) request.getAttribute("name");
    String email = (String) request.getAttribute("email");
%>
<p>姓名: <%= name %></p>
<p>邮箱: <%= email %></p>
</body>
</html>

这样，用户提交的数据就被从Servlet处理后传递到了JSP页面，并展示了出来。

通过上述示例，我们了解了表单在JSP页面的设计与数据交互方式，以及Servlet与JSP之间的数据传递机制。这不仅使得Web应用的功能得以扩展，也为用户提供了更为丰富的交互体验。

本文还有配套的精品资源，点击获取