JSP程序设计第二版：实战项目与综合技能提升

Tranyn.X

于 2024-08-30 15:29:29 发布

阅读量700

点赞数 26

本文链接：https://blog.csdn.net/weixin_32242475/article/details/141744928

版权

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

简介：耿祥义和张跃平编写的《JSP程序设计（第2版）上机实验与综合实训》旨在深化读者对JSP技术的理解并提高实际应用能力。书中详细涵盖了JSP从基础到高级的应用，包括十个章节的实验资料，如JSP基础、内置对象、表达式语言、动作标签、自定义标签库、JSP与Servlet的交互、转发与重定向、异常处理、数据库连接和高级应用等。通过系统学习，读者将掌握JSP开发的关键技能，为Web开发打下坚实基础。 jsp程序设计（第2版）上机实验与综合实训，耿祥义、张跃平

1. JSP基础介绍与实践

1.1 JSP技术概述

JavaServer Pages（JSP）是一种基于Java技术的服务器端技术，允许开发者将Java代码嵌入到HTML页面中，用于创建动态交互式的Web应用。JSP与Servlet技术紧密相关，可以看作是Servlet的一种简化，目的是为了使开发者能够更加轻松地编写静态HTML与动态内容混合的页面。

1.2 JSP的基本组成

JSP页面主要由以下三部分组成： - 静态HTML或XML：构成页面的主体。 - JSP脚本元素：包括声明、脚本片段和表达式。 - 声明：用于定义变量和方法。 - 脚本片段：包含有效的Java代码。 - 表达式：生成动态内容插入到HTML页面。 - JSP标准标签库（JSTL）或自定义标签。

1.3 JSP页面的基本结构和开发步骤

JSP页面的文件通常以 .jsp 为扩展名。一个标准的JSP页面结构如下：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>简单的JSP页面</title>
</head>
<body>
    <%
        // 这里可以包含Java代码
        String message = "Hello, JSP!";
    %>
    <p><%= message %></p> <!-- 表达式输出 -->
</body>
</html>

开发JSP页面的基本步骤包括： 1. 定义页面布局和所需功能。 2. 在JSP文件中嵌入Java代码。 3. 利用JSP标签和EL表达式简化代码。 4. 调试和测试页面以确保功能正确实现。

通过以上内容，读者可以对JSP有一个初步的了解，并为后续章节的深入学习打下基础。接下来将探索JSP内置对象的应用与管理，进一步加深对JSP的认识。

2. JSP内置对象的应用与管理

2.1 JSP内置对象概述

2.1.1 内置对象的定义和分类

在JSP（JavaServer Pages）技术中，内置对象是指在JSP页面中可以直接使用的对象，无需进行实例化或通过作用域对象获取。这些对象由容器自动创建，并在JSP页面的脚本元素中可以直接引用。内置对象的使用极大地简化了Java代码与HTML代码的混合编写，提高了开发效率。

JSP内置对象按照它们在Web应用中的作用域可以分为三类：

请求作用域对象：与一次请求相关的对象，如 request 对象。
会话作用域对象：与一次用户会话相关的对象，如 session 对象。
应用作用域对象：与整个Web应用相关的对象，如 application 对象。

2.1.2 内置对象的作用域和生命周期

JSP内置对象的生命周期与它们的作用域密切相关。作用域定义了对象的有效范围，生命周期则是对象存在的时间。

request 对象：当客户端发起请求时，容器创建一个 request 对象，用于封装请求信息，包括请求参数、请求头、请求URI等。该对象在一次请求处理完毕后即被销毁。
session 对象：在用户首次访问服务器时创建，维护用户的会话信息，直到用户长时间无活动或主动退出会话时销毁。
application 对象：代表整个Web应用的运行环境，从服务器启动到停止，只创建一次，所有用户共享。

理解内置对象的作用域和生命周期对于编写高效且可维护的JSP页面至关重要。

2.2 JSP内置对象的高级应用

2.2.1 request对象深入

request 对象作为请求作用域的核心对象，提供了丰富的API来获取客户端的请求信息。它不仅能够获取HTTP请求中的参数值，还能读取请求头、了解请求类型等。

// 伪代码示例：获取请求参数
String paramValue = request.getParameter("paramName");

在处理POST请求时， request.getParameter() 方法常被用来获取表单提交的数据。此外， request.getQueryString() 可以用来获取URL中查询字符串的内容，而 request.getMethod() 则可以获取当前请求的HTTP方法类型（如GET、POST等）。

2.2.2 session与application对象的协同工作

session 对象常用于跟踪用户的会话状态，而 application 对象则用于在应用程序范围内共享信息。在大型的Web应用中，合理地使用这两个对象可以极大地提高应用的性能和用户的体验。

session 对象通常与 application 对象结合，以共享跨会话的应用数据。例如，我们可以使用 application 对象来记录网站访问的统计信息，而每个用户的会话信息则存储在各自的 session 中。

// 伪代码示例：在session中存储用户信息，并在application中记录访问次数
session.setAttribute("user", userInfo);
Integer hitCount = (Integer) application.getAttribute("hitCount");
if(hitCount == null) {
    hitCount = 1;
} else {
    hitCount += 1;
}
application.setAttribute("hitCount", hitCount);

application 对象在Web应用的生命周期内只有一份实例，因此可以用来存储那些不需要为每个用户单独存储的数据。而 session 对象则维护了每个用户的状态，通常用于存储用户的登录信息、购物车等数据。通过 session 对象，我们可以在用户的多个请求之间共享数据，甚至可以在用户断开连接后还保留这些信息一段时间。

本章节通过对JSP内置对象的深入讨论，揭示了它们在Web开发中的核心作用。内置对象不仅简化了代码的编写，还为Web应用提供了强大的状态管理和数据共享能力。接下来的章节将探索JSP表达式语言（EL）和脚本元素的使用方法，进一步深入理解JSP技术的灵活性和表现力。

3. 表达式语言（EL）和脚本元素使用

表达式语言（Expression Language，简称EL）是JSP技术中用于简化JSP页面中的Java代码编写的一种语言，它提供了一种简洁的语法来访问Java对象的数据。同时，脚本元素允许开发者在JSP页面中使用Java代码，包括声明、表达式和脚本片段。本章将详细介绍EL和脚本元素的使用方法，以及它们在Web开发中的应用。

3.1 表达式语言（EL）的基本语法

3.1.1 EL表达式的构成和使用场景

EL表达式是一种用于访问数据的语言，它可以用来获取JavaBean组件的属性值、Map集合的值、List集合中的元素等。EL表达式的基本格式如下：

${expression}

其中， expression 是EL表达式的内容，可以是一个简单的变量，也可以是包含多个属性、方法调用和算术运算的复杂表达式。在使用EL表达式时，通常有以下几个场景：

在JSP页面中显示数据，例如 ${user.name} 可以显示名为user的JavaBean的name属性值。
在JSP页面中的标签属性中使用，例如 <a href="user.jsp?userId=${user.id}"> 。
用于条件判断和循环，如在 <c:if> 和 <c:forEach> 等自定义标签中。

3.1.2 EL中的运算符和函数

EL语言中提供了多种运算符，包括算术运算符、关系运算符和逻辑运算符，用于构建复杂的表达式。例如：

算术运算符： + , - , * , / , %
关系运算符： == , != , < , > , <= , >=
逻辑运算符： && , || , !

除了运算符，EL还提供了一系列预定义的函数，可以用于字符串处理、类型转换等。例如：

fn:length(str) ：返回字符串的长度。
fn:contains(str, substr) ：检查一个字符串是否包含另一个子字符串。
fn:replace(str, from, to) ：替换字符串中的某些字符。

3.1.3 使用示例

以下是一个简单的EL表达式使用示例：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>EL Expression Example</title>
</head>
<body>
    <h2>显示用户信息</h2>
    <p>Name: ${user.name}</p>
    <p>Age: ${user.age}</p>
    <h2>显示列表长度</h2>
    <p>Friends List Length: ${fn:length(friends)}</p>
    <h2>检查用户是否在线</h2>
    <p>Is user online: ${user.onlineStatus == 'true'}</p>
</body>
</html>

在这个例子中，EL表达式被用来显示用户的名字和年龄，计算朋友列表的长度，以及判断用户是否在线。

3.2 脚本元素的深入解析

3.2.1 脚本片段和表达式

脚本元素允许开发者在JSP页面中直接编写Java代码。这些元素包括声明（Declarations）、表达式（Expressions）和脚本片段（Scriptlets）。

声明：用于声明变量和方法。例如： <%! int i = 0; %>
表达式：用于输出表达式的结果。例如： <%= "Hello, World!" %>
脚本片段：包含多条Java语句。例如： jsp <% String message = "Hello"; out.println(message + ", World!"); %>

3.2.2 脚本元素在页面中的作用和局限

脚本元素可以执行复杂的逻辑和控制流程，能够处理大部分编程任务。但使用过多的脚本元素会导致JSP页面难以维护和理解。因此，最佳实践是尽可能地使用EL和JSTL来替代脚本元素，从而提高代码的可读性和可维护性。

3.2.3 使用示例

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Scriptlet Example</title>
</head>
<body>
    <%-- 声明变量 --%>
    <%! String message = "Hello from Scriptlet"; %>
    <%-- 使用表达式输出变量 --%>
    <p><%= message %></p>
    <%-- 脚本片段，执行一个循环 --%>
    <%
        for(int i = 0; i < 5; i++) {
            out.println("<p>Count is: " + i + "</p>");
        }
    %>
</body>
</html>

在上述例子中，脚本元素被用来声明一个字符串变量、使用表达式输出变量内容，并使用一个简单的循环来输出计数信息。然而，如果这个循环操作被用于处理更复杂的逻辑，建议将这部分逻辑转移到一个Java类中。

3.2.4 脚本元素与EL的交互

EL和脚本元素可以在同一个JSP页面中混合使用。通常，脚本元素用于处理业务逻辑和数据模型的创建，而EL则用于展示数据。

脚本元素可以创建变量并将其存储在不同的作用域中（page, request, session, application），这些变量随后可以在EL表达式中被访问。例如：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>EL and Scriptlet Interaction</title>
</head>
<body>
    <%-- 在request作用域中设置一个属性 --%>
    <% request.setAttribute("greeting", "Hello, World!"); %>
    <h2>通过EL显示消息</h2>
    <p>${greeting}</p>
</body>
</html>

在此示例中，使用脚本元素在request作用域中设置了 greeting 属性，然后在页面中使用EL表达式 "${greeting}" 来展示这个属性的值。

3.2.5 脚本元素的优化策略

为了提高代码的可维护性和可重用性，建议将逻辑和数据处理的代码迁移到Java类中，并在JSP页面中通过EL和自定义标签来调用这些逻辑。这样，JSP页面将更简洁，更加专注于表现层的实现。

通过上述章节的介绍，我们已经了解了EL的基本语法、脚本元素的使用方法，以及如何在JSP页面中结合使用这两者。在后续的章节中，我们将探索JSP中标准动作标签的使用，以及如何设计和实现自定义标签库。

4. 标准动作标签的使用方法

4.1 标准动作标签的分类和功能

4.1.1 jsp:useBean的使用技巧

在JSP页面中， jsp:useBean 是用于查找或实例化JavaBean组件的动作标签。通过这个标签可以轻松地在JSP页面中使用JavaBean，无需编写大量的代码。这个动作的出现极大地简化了JavaBean的使用流程，并让页面逻辑和Java代码的分离更加明显。

为了更有效地使用 jsp:useBean ，可以遵循一些最佳实践：

明确Bean的作用域 ：在使用 jsp:useBean 时，应该指定Bean的作用域。这个作用域可以是page、request、session或application。例如：

<jsp:useBean id="myBean" class="com.example.MyBean" scope="session" />

这段代码会创建一个Bean实例，其作用域是session。如果在同一个作用域内已经存在同名的Bean实例， jsp:useBean 将直接使用该实例。

异常处理 ：如果Bean实例化过程中发生异常，可以通过 <jsp:useBean> 的 onError 属性指定错误处理代码。

<jsp:useBean id="myBean" class="com.example.MyBean" scope="session" 
             onMiss="errorPage.jsp" onErr="errorPage.jsp" />

上面的示例中，如果创建Bean时发生错误，将会跳转到 errorPage.jsp 页面进行处理。

与Bean操作标签结合使用 ： jsp:useBean 通常与 jsp:setProperty 和 jsp:getProperty 一起使用，从而对Bean的属性进行设置和获取。

4.1.2 jsp:setProperty和jsp:getProperty详解

jsp:setProperty 和 jsp:getProperty 是操作JavaBean属性的两个动作标签。它们允许在JSP页面中直接对JavaBean的属性进行设置和获取。

jsp:setProperty

jsp:setProperty 通常在 jsp:useBean 标签中使用，用于在创建Bean实例或存在实例时，设置Bean的属性。它可以自动根据请求参数来设置属性值，或者直接指定属性值。

示例代码如下：

<jsp:useBean id="myBean" class="com.example.MyBean" scope="session" />
<jsp:setProperty name="myBean" property="*" />

这段代码告诉JSP容器，如果存在名为 myBean 的Bean实例，则根据请求参数自动设置其所有属性。如果不存在，则先创建一个实例，然后设置属性。

jsp:getProperty

jsp:getProperty 用于获取JavaBean的属性值，并将其输出到响应中。

示例代码如下：

<jsp:useBean id="myBean" class="com.example.MyBean" scope="session" />
<p>Current value of property: <jsp:getProperty name="myBean" property="propertyName" /></p>

这段代码将输出 myBean 对象的 propertyName 属性值到页面上。

注意事项

在使用 jsp:setProperty 和 jsp:getProperty 时，需要注意几个关键点：

属性类型匹配 ：JSP容器会尝试将请求参数的值转换为JavaBean属性的类型。如果类型不匹配，可能会抛出异常。因此，合理利用JavaBean属性的类型转换和格式化功能显得很重要。
部分设置与完全设置 ：使用 <jsp:setProperty> 时，除了可以使用 property="*" 自动匹配设置所有属性外，也可以明确指定需要设置的属性。例如：

<jsp:setProperty name="myBean" property="name,age" />

上面的例子只会设置 name 和 age 属性。

可选属性设置 ：为了使 <jsp:setProperty> 更具灵活性，可以使用 <jsp:param> 标签来指定属性值。例如：

<jsp:useBean id="myBean" class="com.example.MyBean" scope="session" />
<jsp:setProperty name="myBean">
    <jsp:param name="name" value="John Doe" />
    <jsp:param name="age" value="30" />
</jsp:setProperty>

通过这种结合使用，即使请求中没有包含相应的参数，也可以强制设置属性值。

jsp:setProperty 和 jsp:getProperty 动作标签极大地简化了在JSP页面上对JavaBean的操作，使Web开发更加便捷。但开发者仍需要确保属性类型匹配和异常处理得当，以保证应用的健壮性。

4.2 动作标签在实际项目中的应用案例

4.2.1 动态表单处理

在Web应用中，动态表单是常见的需求。开发者需要在页面上展示、提交和处理表单数据。利用JSP标准动作标签可以有效地处理动态表单。

以一个用户注册页面为例：

创建JavaBean ：首先，需要创建一个JavaBean，比如User，用来表示表单数据。

public class User {
    private String username;
    private String password;
    private String email;

    // Getters and setters for each field
    // ...
}

使用jsp:useBean和jsp:setProperty ：在JSP页面上，可以这样使用动作标签来处理表单数据：

<jsp:useBean id="user" class="com.example.User" scope="request" />
<form action="register.jsp" method="post">
    Username: <input type="text" name="username" />
    Password: <input type="password" name="password" />
    Email: <input type="text" name="email" />
    <input type="submit" value="Register" />
</form>

<jsp:setProperty name="user" property="*" />

通过这个简单的动作标签组合，当表单提交到 register.jsp 时，请求中的参数 username 、 password 和 email 会被自动赋值给user对象的相应属性。

使用jsp:getProperty ：提交表单后，可以用 jsp:getProperty 在页面上显示用户提交的数据。

User Information:
Username: <jsp:getProperty name="user" property="username" />
Password: <jsp:getProperty name="user" property="password" />
Email: <jsp:getProperty name="user" property="email" />

这样，用户在提交表单后可以看见自己输入的数据。

4.2.2 页面间数据传递和处理

在实际的项目中，页面间的数据传递也是频繁发生的操作。通过JSP动作标签，可以以更为高效和可维护的方式进行。

假设有一个用户信息展示页面，需要从另一个处理用户数据的页面传递数据过来：

使用jsp:useBean获取数据 ：在目标页面，可以使用 jsp:useBean 来获取从前一个页面传递过来的Bean实例。

<jsp:useBean id="user" class="com.example.User" scope="request" />

展示数据 ：之后，页面可以利用 jsp:getProperty 展示Bean中的数据。

<p>User Information:</p>
<p>Username: <jsp:getProperty name="user" property="username" /></p>
<p>Email: <jsp:getProperty name="user" property="email" /></p>

通过这种方式，页面可以展示传递过来的用户数据，无需通过请求参数的形式明文传递。

注意事项 ：需要注意的是，如果是跨页面数据传递，必须确保数据的作用域和传递方式相匹配。例如， request 作用域仅限于当前请求和响应链路，若需要跨多个请求传递数据，则应使用 session 或 application 作用域。

通过这些案例，可以清晰地看到JSP标准动作标签在实际开发中的强大功能和便利性。无论是动态表单处理还是页面间的数据传递和处理，使用标准动作标签都能够简化代码、提高开发效率，并使得页面结构更加清晰。

5. 自定义标签库的设计与实现

5.1 自定义标签库的原理和结构

5.1.1 标签库描述文件（TLD）解析

在JSP技术中，标签库（Tag Library）是一个强大的组件化开发工具，它允许开发者自定义一系列功能强大的标签，从而简化页面编写和维护工作。标签库描述文件（Tag Library Descriptor, TLD）是定义这些自定义标签属性和行为的XML文件。

核心元素解析

taglib ：根元素，用于声明文档类型和版本，也包含对标签库的命名空间声明。
tlib-version ：标签库的版本号。
short-name ：标签库的简称。
uri ：用于区分具有相同简名的标签库的唯一标识符。
tag ：定义单个标签的详细信息。
tag-class ：标签处理器类的全限定名。
body-content ：描述标签体的内容类型，可选值包括 empty 、 tagdependent 和 scriptfree 。
attribute ：定义标签所接受的属性。

TLD文件的编写需要遵循一定的规范，以确保标签库能够被容器正确识别和处理。一个典型的TLD文件内容如下：

<taglib xmlns="***"
    xmlns:xsi="***"
    xsi:schemaLocation="***
    ***"
    version="2.1">
    <tlib-version>1.0</tlib-version>
    <short-name>mytags</short-name>
    <uri>***</uri>
    <tag>
        <name>sayHello</name>
        <tag-class>com.mycompany.tags.SayHelloTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <name>to</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>
    <!-- Other tags -->
</taglib>

5.1.2 标签处理器类的设计要点

自定义标签处理器类是自定义标签库的"大脑"。它继承自 SimpleTagSupport 或其他相关类，并重写 doTag 方法来实现特定的逻辑。

类设计核心要点

继承关系 ：通常，自定义标签处理器会继承自 SimpleTagSupport 类，以便更简单地处理标签的逻辑。
生命周期方法 ： doTag 方法是标签处理器的主要入口点，在此方法中可以访问标签的属性、父标签、标签体以及页面上下文。
标签属性 ：必须提供 set 方法来接收TLD中定义的属性。
标签体处理 ：如果标签不是空标签，可以使用 JspFragment 来处理标签体的内容。

下面是一个简单的标签处理器类示例：

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class SayHelloTag extends SimpleTagSupport {
    private String to;

    public void setTo(String to) {
        this.to = to;
    }

    public void doTag() throws JspException, IOException {
        JspWriter out = getJspContext().getOut();
        out.println("Hello, " + to + "!");
    }
}

5.2 自定义标签库的开发流程

5.2.1 开发环境的搭建和配置

开发自定义标签库之前，需要确保已安装Java开发环境以及JSP兼容的Web容器，如Apache Tomcat。

开发步骤概览

创建项目结构 ：根据个人或团队的项目结构标准，建立相应的目录结构。
编写TLD文件 ：遵循TLD定义规范，创建TLD文件并存放在 WEB-INF 目录下的 tags 子目录中。
实现标签处理器 ：创建标签处理器类并实现具体逻辑。
编译和部署 ：将标签库的jar文件放入Web应用的 WEB-INF/lib 目录，配置 web.xml 确保标签库能够被正确加载。

5.2.2 标签库的实现和测试

实现细节

实现细节 ：在开发工具中编写并编译自定义标签处理器。
测试：使用JSP页面测试标签功能，确保标签按预期工作。
调试：如果测试发现问题，检查TLD文件、标签处理器逻辑，并调整测试环境。

下面是一个简单的测试页面示例：

<%@ taglib prefix="my" uri="***" %>
<html>
<head>
    <title>Test Custom Tag</title>
</head>
<body>
    <my:sayHello to="World" />
</body>
</html>

在JSP页面中通过 prefix 属性引用了TLD文件中定义的标签库，然后使用了 sayHello 标签，并传入 to 属性值 "World" 。

测试验证

测试时，Web容器应正确处理自定义标签，并在页面上显示 "Hello, World!" 。如果出现异常或不正确的输出，可能需要检查TLD文件的配置、标签处理器的实现和JSP页面引用的正确性。

以上内容构成了自定义标签库设计与实现的基础架构，从TLD文件解析到标签处理器的实现，再到开发流程的介绍，为JSP开发者提供了清晰的指导。通过实践操作，自定义标签库能够极大地提高Web应用开发的效率和可维护性。

6. JSP与Servlet的交互处理

JSP（JavaServer Pages）和Servlet都是Java EE（Java Platform, Enterprise Edition）规范中的一部分，它们在Web应用中扮演着至关重要的角色。JSP擅长于展示动态内容，而Servlet则擅长于处理逻辑。在现代Web应用开发中，了解如何使这两者相互协作是十分必要的。本章我们将深入探讨JSP与Servlet的交互机制和协作模式，并通过实际案例来加深理解。

6.1 JSP与Servlet交互机制

在Web应用中，JSP页面和Servlet经常需要进行数据交互和请求处理。了解它们之间的交互机制对于开发高效、可维护的Web应用至关重要。

6.1.1 请求和响应对象的传递

当一个JSP页面需要调用Servlet来处理某些逻辑时，可以通过 request 和 response 对象进行。这些对象由Web服务器创建，并在请求和响应过程中提供相应的接口。

. . . request对象传递

在JSP页面中，当需要将客户端的请求数据传递给Servlet时，可以通过以下方式：

<%
    // 假设有一个名为"doSomething"的Servlet
    RequestDispatcher dispatcher = request.getRequestDispatcher("/doSomething");
    dispatcher.forward(request, response);
%>

这段代码中， getRequestDispatcher 方法通过指定Servlet的路径来获取 RequestDispatcher 对象。然后，使用 forward 方法将请求转发到目标Servlet。这样， request 对象中的数据就可以在Servlet中使用了。

. . . response对象传递

通常情况下，Servlet处理完业务逻辑后，会将数据传递回JSP页面以展示给用户。这一过程可以通过设置响应内容实现：

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // 处理业务逻辑
    // ...

    // 将数据设置到request对象中，供JSP页面使用
    request.setAttribute("data", "处理结果");

    // 将请求转发到JSP页面
    RequestDispatcher dispatcher = request.getRequestDispatcher("result.jsp");
    dispatcher.forward(request, response);
}

在这个例子中，Servlet通过 setAttribute 方法将数据存放到 request 对象中，然后通过 forward 方法将控制权以及包含业务数据的 request 对象传递给JSP页面。

6.1.2 JSP页面中调用Servlet的几种方式

在JSP页面中调用Servlet可以有多种方式，主要包括直接URL调用、表单提交以及 <jsp:include> 动作。

. . . 直接URL调用

在JSP页面中，可以通过HTML的 <a> 标签直接指定Servlet的URL来调用：

<a href="MyServlet">访问Servlet</a>

. . . 表单提交

JSP页面中的表单提交也可以触发Servlet的执行：

<form action="MyServlet" method="post">
    <!-- 表单内容 -->
</form>

. . . `<jsp:include>` 动作

通过JSP的内置动作标签 <jsp:include> 可以在JSP页面中包含另一个资源的内容：

<jsp:include page="MyServlet" />

这种方式与转发不同，它实际上是在请求中包含了目标Servlet的输出，而不是转发整个请求。

6.2 JSP与Servlet的协作模式

在实际项目中，JSP和Servlet往往会遵循MVC（Model-View-Controller）设计模式进行协作。这种模式将应用分为三个核心组件，即数据模型、用户界面和控制逻辑，从而实现代码的分离和重用。

6.2.1 MVC设计模式在JSP和Servlet中的应用

MVC模式在JSP和Servlet中的应用，通常Servlet担任Controller的角色，处理业务逻辑并调用Model层的类来获取数据，然后将数据传递给JSP页面（View层）进行展示。

. . . Model层

Model层主要负责数据的存取和业务逻辑的处理。在Java Web应用中，通常由JavaBean或DAO（Data Access Object）类实现。

. . . View层

View层是用户界面，由JSP页面实现，负责展示数据。

. . . Controller层

Controller层由Servlet实现，它负责接收用户的请求，并根据请求调用Model层获取数据，然后选择适当的View层进行展示。

6.2.2 实际案例分析

考虑一个典型的Web应用，其处理用户请求并展示用户信息的流程：

用户通过浏览器访问一个URL，请求查看用户信息。
请求到达Servlet（Controller），该Servlet处理请求，并调用Model层的类获取用户信息。
Model层的类根据请求，从数据库或其他数据源中检索所需信息。
Servlet获取到数据后，将数据传递给JSP页面（View）。
JSP页面使用EL表达式和脚本元素将数据展示给用户。

为了更清晰地说明这一过程，让我们看一个简化的示例：

表格：MVC模式下的组件交互

| 组件 | 功能描述 | 示例 | | --- | --- | --- | | Servlet | 接收请求，调用Model获取数据，选择View展示数据 | UserServlet | | JavaBean | 存储用户信息 | User | | JSP | 展示用户信息 | userInfo.jsp |

通过上述分析和表格，我们可以看到MVC模式如何清晰地划分了各组件的职责，从而使得Web应用更容易维护和扩展。在实际开发中，遵循MVC模式能够使得应用的结构更加清晰，代码的重用性更高。

7. 请求转发与重定向的区别和使用

在Web开发中，请求的转发与重定向是常用的两种技术手段，它们在实现页面跳转和数据传递方面有着各自独特的特点和适用场景。理解这两种技术的区别和使用方法，对于提高Web应用的性能和用户体验至关重要。

7.1 请求转发与重定向的原理和特点

7.1.1 请求转发的概念和应用场景

请求转发（Forward）是服务器内部的一种操作，它允许一个Servlet或JSP页面将请求转发到另一个资源，如另一个Servlet、JSP页面或其他资源。请求转发发生在服务器内部，客户端并不知情。

原理：在请求转发过程中，客户端发送一个请求给服务器，服务器内部将请求转发给另一个资源继续处理。整个过程对客户端透明，就像只有一个请求一样。
应用场景 ：请求转发常用于Web应用中的页面导航，当需要从前一个页面跳转到另一个页面时，如果这两个页面需要共享请求范围（Request Scope）内的数据，就非常适合使用请求转发。

7.1.2 重定向的概念和应用场景

重定向（Redirect）是指客户端收到服务器的响应后，根据响应中的状态码和位置信息，向新的位置发送请求。重定向是客户端与服务器之间的交互过程，通常涉及两个请求。

原理：在重定向过程中，客户端接收到包含重定向URL的响应后，自动向新的URL发起请求。第一次请求和第二次请求都是客户端与服务器之间的独立交互。
应用场景 ：重定向通常用于需要用户看到新URL的场景，或者在需要跳转到另一个服务器上的资源时。例如，在用户登录成功后跳转到主页，或者在处理表单提交后跳转到感谢页面等。

7.2 请求转发与重定向的实践操作

7.2.1 实践中的选择和优化

在实际开发中，开发者需要根据应用场景选择适合的转发或重定向方式。性能优化也是需要考虑的因素。

选择：如果仅在同一个Web应用内的多个资源之间进行页面导航，且希望保持请求范围内的数据共享，请求转发更为合适。如果需要导航到不同应用或外部资源，并且需要用户看到新的URL，重定向是更好的选择。
优化：对于请求转发，由于请求在服务器内部进行，可以减少网络的往返次数和提高性能。对于重定向，应当尽量减少重定向的次数，并合理使用301和302状态码来指导客户端进行缓存，以避免不必要的网络延迟。

7.2.2 典型应用场景对比分析

下面通过一个简单的例子来分析请求转发与重定向的不同使用场景。

假设有一个用户注册流程，用户填写注册信息后点击提交，然后系统需要进行验证并显示注册成功或失败的页面。

请求转发 ：用户提交表单后，服务器端的Servlet接收请求，验证用户信息。如果验证通过，则转发请求到注册成功页面。此过程用户看到的URL不会改变，且可以共享同一个请求范围内的数据。
重定向 ：如果在验证后，需要用户跳转到另一个应用（例如支付应用）来完成支付过程，这时使用重定向比较合适。在验证通过后，服务器将响应一个302状态码，并提供支付应用的URL。用户浏览器收到后，会向支付应用发起新的请求。这种方式下，用户可以看到URL的改变，并且原始请求范围内的数据不会被共享。

sequenceDiagram
    participant 用户
    participant Web应用
    participant 支付应用

    用户->>Web应用: 提交注册表单
    Web应用->>Web应用: 验证用户信息
    alt 验证通过
        Web应用-->>用户: 请求转发到成功页面
        用户->>Web应用: 查看成功页面
    else 验证失败
        Web应用-->>用户: 显示错误信息
    end
    alt 需要支付
        Web应用-->>用户: 重定向到支付应用
        用户->>支付应用: 查看支付页面
    end

通过上述分析，我们可以看出，在Web应用开发中，请求转发与重定向各有千秋。正确地选择和应用这两种技术，有助于提升应用的整体性能和用户体验。

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

Tranyn.X

关注

26
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
JSP程序设计第二版：实战项目与综合技能提升

本文还有配套的精品资源，点击获取简介：耿祥义和张跃平编写的《JSP程序设计（第2版）上机实验与综合实训》旨在深化读者对JSP技术的理解并提高实际应用能力。书中详细涵盖了JSP从基础到高级的应用，包括十个章节的实验资料，如JSP基础、内置对象、表达式语言、动作标签、自定义标签库、JSP与Servlet的交互、转发与重定向、异常处理、数据库连接和高级应用等。通过系统学习，读者...
复制链接

扫一扫