JSP - 快速指南

---

JSP - 概述

什么是 JavaServer Pages？

JavaServer Pages (JSP) 是一种用于开发支持动态内容的网页的技术。这有助于开发人员通过使用特殊的 JSP 标记在 HTML 页面中插入 java 代码，其中大多数标记以 <% 开头并以 %> 结尾。

JavaServer Pages 组件是一种 Java servlet，旨在履行 Java Web 应用程序用户界面的角色。Web 开发人员将 JSP 编写为文本文件，其中组合了 HTML 或 XHTML 代码、XML 元素以及嵌入式 JSP 操作和命令。

使用 JSP，您可以通过网页表单收集用户的输入，显示来自数据库或其他源的记录，并动态创建网页。

JSP 标签可用于多种目的，例如从数据库检索信息或注册用户首选项、访问 JavaBeans 组件、在页面之间传递控制以及在请求、页面等之间共享信息。

为什么使用 JSP？

JavaServer Pages 通常与使用通用网关接口 (CGI)实现的程序具有相同的用途。但与 CGI 相比，JSP 具有几个优点。

• 性能显着提高，因为 JSP 允许在 HTML 页面本身中嵌入动态元素，而不是使用单独的 CGI 文件。

• JSP 总是在被服务器处理之前进行编译，这与 CGI/Perl 不同，CGI/Perl 需要服务器在每次请求页面时加载解释器和目标脚本。

• JavaServer Pages 构建在 Java Servlet API 之上，因此与 Servlet 一样，JSP 也可以访问所有强大的企业 Java API，包括JDBC、JNDI、EJB、JAXP等。

• JSP 页面可以与处理业务逻辑的 servlet 结合使用，该模型由 Java servlet 模板引擎支持。

最后，JSP 是 Java EE 的一个组成部分，Java EE 是企业级应用程序的完整平台。这意味着 JSP 可以在最简单的应用程序到最复杂和要求最高的应用程序中发挥作用。

JSP的优点

下表列出了使用 JSP 相对于其他技术的其他优点 -

与 Active Server Pages (ASP) 对比

JSP 的优点是双重的。首先，动态部分是用Java编写的，而不是Visual Basic或其他MS特定语言，因此它更强大且更易于使用。其次，它可以移植到其他操作系统和非 Microsoft Web 服务器。

与纯 Servlet 对比

编写（和修改！）常规 HTML 比使用大量 println 语句生成 HTML 更方便。

与服务器端包含 (SSI) 的比较

SSI 实际上只是用于简单的包含，而不是用于使用表单数据、建立数据库连接等的“真实”程序。

与 JavaScript

JavaScript 可以在客户端动态生成 HTML，但很难与 Web 服务器交互来执行数据库访问和图像处理等复杂任务。

与静态 HTML

当然，常规 HTML 不能包含动态信息。

下一步是什么？

我将逐步指导您设置环境以开始使用 JSP。我假设您对 Java 编程有很好的实践经验，可以继续学习 JSP。

如果您不了解 Java 编程语言，那么我们建议您通过我们的Java 教程来了解 Java 编程。

JSP - 环境设置

开发环境是您开发 JSP 程序、测试它们并最终运行它们的地方。

本教程将指导您设置 JSP 开发环境，其中涉及以下步骤 -

设置Java开发工具包

此步骤涉及下载 Java 软件开发工具包 (SDK) 的实现并适当设置 PATH 环境变量。

您可以从 Oracle 的 Java 站点 - Java SE 下载下载 SDK 。

下载 Java 实现后，请按照给定的说明进行安装和配置设置。最后设置PATH 和 JAVA_HOME环境变量以引用包含java和javac的目录，通常分别为java_install_dir/bin和java_install_dir。

如果您运行的是 Windows 并将 SDK 安装在C:\jdk1.5.0_20中，则需要在C:\autoexec.bat文件中添加以下行。

set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20

或者，在Windows NT/2000/XP上，您也可以右键单击“我的电脑”，选择“属性”，然后选择“高级”，最后选择“环境变量”。然后，您将更新 PATH 值并按“确定”按钮。

在 Unix（Solaris、Linux 等）上，如果 SDK 安装在/usr/local/jdk1.5.0_20并且您使用 C shell，则将以下内容放入.cshrc文件中。

setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.5.0_20

或者，如果您使用Borland JBuilder、Eclipse、IntelliJ IDEA或Sun ONE Studio等集成开发环境 (IDE)，请编译并运行一个简单的程序以确认 IDE 知道您安装 Java 的位置。

设置 Web 服务器：Tomcat

市场上有许多支持 JavaServer Pages 和 Servlet 开发的 Web 服务器。一些 Web 服务器可以免费下载，Tomcat 就是其中之一。

Apache Tomcat 是 JavaServer Pages 和 Servlet 技术的开源软件实现，可以充当测试 JSP 和 Servlet 的独立服务器，并且可以与 Apache Web Server 集成。以下是在您的计算机上设置 Tomcat 的步骤 -

• 从https://tomcat.apache.org/下载最新版本的 Tomcat 。

• 下载安装后，将二进制发行版解压到一个方便的位置。例如，在Windows 上的 C:\apache-tomcat-5.5.29 中，或在 Linux/Unix 上的/usr/local/apache-tomcat-5.5.29 中，并创建指向这些位置的CATALINA_HOME环境变量。

Tomcat 可以通过在 Windows 机器上执行以下命令来启动 -

%CATALINA_HOME%\bin\startup.bat
 
or
 
C:\apache-tomcat-5.5.29\bin\startup.bat

Tomcat 可以通过在 Unix（Solaris、Linux 等）机器上执行以下命令来启动 -

$CATALINA_HOME/bin/startup.sh
 
or
 
/usr/local/apache-tomcat-5.5.29/bin/startup.sh

成功启动后，可以通过访问http://localhost:8080/ 来使用 Tomcat 附带的默认 Web 应用程序。

执行后，您将收到以下输出 -

有关配置和运行 Tomcat 的更多信息可以在此处包含的文档以及 Tomcat 网站上找到 - https://tomcat.apache.org/。

可以通过在 Windows 计算机上执行以下命令来停止 Tomcat -

%CATALINA_HOME%\bin\shutdown
or

C:\apache-tomcat-5.5.29\bin\shutdown

可以通过在 Unix（Solaris、Linux 等）机器上执行以下命令来停止 Tomcat -

$CATALINA_HOME/bin/shutdown.sh

or

/usr/local/apache-tomcat-5.5.29/bin/shutdown.sh

设置 CLASSPATH

由于 servlet 不是 Java Platform, Standard Edition 的一部分，因此您必须向编译器标识 servlet 类。

如果您运行的是 Windows，则需要将以下行放入C:\autoexec.bat文件中。

set CATALINA = C:\apache-tomcat-5.5.29
set CLASSPATH = %CATALINA%\common\lib\jsp-api.jar;%CLASSPATH%

或者，在Windows NT/2000/XP上，您也可以右键单击“我的电脑”，选择“属性”，然后选择“高级”，然后选择“环境变量”。然后，您将更新 CLASSPATH 值并按“确定”按钮。

在 Unix（Solaris、Linux 等）上，如果您使用 C shell，则应将以下几行放入.cshrc文件中。

setenv CATALINA = /usr/local/apache-tomcat-5.5.29
setenv CLASSPATH $CATALINA/common/lib/jsp-api.jar:$CLASSPATH

注意- 假设您的开发目录是C:\JSPDev (Windows)或/usr/JSPDev (Unix)，那么您还需要在 CLASSPATH 中添加这些目录。

JSP-架构

Web服务器需要JSP引擎，即处理JSP页面的容器。JSP容器负责拦截JSP页面的请求。本教程利用Apache内置的JSP容器来支持JSP页面开发。

JSP 容器与Web 服务器一起提供JSP 所需的运行时环境和其他服务。它知道如何理解 JSP 中的特殊元素。

下图显示了 JSP 容器和 JSP 文件在 Web 应用程序中的位置。

JSP处理

以下步骤解释了 Web 服务器如何使用 JSP 创建网页 -

• 与普通页面一样，您的浏览器会向 Web 服务器发送 HTTP 请求。

• Web 服务器识别出该 HTTP 请求是针对 JSP 页面的，并将其转发到 JSP 引擎。这是通过使用以.jsp而不是.html结尾的 URL 或 JSP 页面来完成的。

• JSP 引擎从磁盘加载 JSP 页面并将其转换为 servlet 内容。这种转换非常简单，其中所有模板文本都转换为 println( ) 语句，所有 JSP 元素都转换为 Java 代码。这段代码实现了页面相应的动态Behave。

• JSP 引擎将 Servlet 编译为可执行类，并将原始请求转发给 Servlet 引擎。

• Web 服务器的一部分（称为 servlet 引擎）加载 Servlet 类并执行它。在执行期间，Servlet 会生成 HTML 格式的输出。Servlet 引擎在 HTTP 响应中进一步将输出传递到 Web 服务器。

• Web 服务器将 HTTP 响应以静态 HTML 内容转发到您的浏览器。

• 最后，Web 浏览器处理 HTTP 响应中动态生成的 HTML 页面，就像处理静态页面一样。

所有上述步骤都可以在下图中看到 -

通常，JSP 引擎会检查 JSP 文件的 servlet 是否已存在以及 JSP 上的修改日期是否早于 servlet。如果 JSP 比其生成的 servlet 旧，则 JSP 容器假定 JSP 没有更改，并且生成的 servlet 仍然与 JSP 的内容匹配。这使得该过程比其他脚本语言（例如 PHP）更高效，因此速度更快。

因此，在某种程度上，JSP 页面实际上只是编写 servlet 的另一种方法，而无需成为 Java 编程高手。除了转换阶段之外，JSP 页面的处理方式与常规 servlet 完全相同。

JSP-生命周期

在本章中，我们将讨论 JSP 的生命周期。理解 JSP 底层功能的关键是理解它们遵循的简单生命周期。

JSP 生命周期定义为从创建到销毁的过程。这类似于 servlet 生命周期，但需要一个额外的步骤将 JSP 编译为 servlet。

JSP 遵循的路径

以下是 JSP 遵循的路径 -

• 汇编
• 初始化
• 执行
• 清理

JSP 生命周期的四个主要阶段与 Servlet 生命周期非常相似。下面描述了四个阶段 -

JSP编译

当浏览器请求 JSP 时，JSP 引擎首先检查是否需要编译该页面。如果页面从未被编译过，或者 JSP 自上次编译以来已被修改，则 JSP 引擎将编译该页面。

编译过程涉及三个步骤 -

• 解析 JSP。
• 将 JSP 转变为 servlet。
• 编译 servlet。

JSP初始化

当容器加载 JSP 时，它会在服务任何请求之前调用jspInit()方法。如果您需要执行 JSP 特定的初始化，请重写jspInit()方法 -

public void jspInit(){
   // Initialization code...
}

通常，初始化仅执行一次，并且与 servlet init 方法一样，您通常会在 jspInit 方法中初始化数据库连接、打开文件并创建查找表。

JSP执行

JSP 生命周期的此阶段代表与请求的所有交互，直到 JSP 被销毁。

每当浏览器请求 JSP 并且页面已加载并初始化时，JSP 引擎就会调用JSP 中的_jspService()方法。

_jspService() 方法采用HttpServletRequest和HttpServletResponse作为其参数，如下所示 -

void _jspService(HttpServletRequest request, HttpServletResponse response) {
   // Service handling code...
}

JSP 的 _jspService() 方法是根据请求调用的。它负责生成该请求的响应，并且该方法还负责生成对所有七个 HTTP 方法（即GET、POST、DELETE等）的响应。

JSP 清理

JSP 生命周期的销毁阶段表示 JSP 不再被容器使用。

jspDestroy ()方法在 JSP 中相当于 Servlet 的 destroy 方法。当您需要执行任何清理（例如释放数据库连接或关闭打开的文件）时，重写 jspDestroy。

jspDestroy() 方法具有以下形式 -

public void jspDestroy() {
   // Your cleanup code goes here.
}

JSP - 语法

在本章中，我们将讨论 JSP 中的语法。我们将了解 JSP 开发中涉及的简单语法（即元素）的基本使用。

JSP 的要素

JSP 的元素描述如下 -

小脚本

scriptlet 可以包含任意数量的 JAVA 语言语句、变量或方法声明或在页面脚本语言中有效的表达式。

以下是 Scriptlet 的语法 -

<% code fragment %>

您可以编写与上述语法等效的 XML，如下所示 -

<jsp:scriptlet>
   code fragment
</jsp:scriptlet>

您编写的任何文本、HTML 标记或 JSP 元素都必须位于 scriptlet 之外。以下是 JSP 的第一个简单示例 -

<html>
   <head><title>Hello World</title></head>
   
   <body>
      Hello World!<br/>
      <%
         out.println("Your IP address is " + request.getRemoteAddr());
      %>
   </body>
</html>

注意- 假设 Apache Tomcat 安装在 C:\apache-tomcat-7.0.2 中，并且您的环境是按照环境设置教程设置的。

让我们将上面的代码保留在JSP文件hello.jsp中，并将该文件放在C:\apache-tomcat7.0.2\webapps\ROOT目录中。使用 URL http://localhost:8080/hello.jsp浏览相同的内容。上面的代码将生成以下结果 -

JSP 声明

声明声明一个或多个变量或方法，您可以稍后在 JSP 文件中的 Java 代码中使用这些变量或方法。在 JSP 文件中使用变量或方法之前必须声明它。

以下是 JSP 声明的语法 -

<%! declaration; [ declaration; ]+ ... %>

您可以编写与上述语法等效的 XML，如下所示 -

<jsp:declaration>
   code fragment
</jsp:declaration>

以下是 JSP 声明的示例 -

<%! int i = 0; %> 
<%! int a, b, c; %> 
<%! Circle a = new Circle(2.0); %> 

JSP表达式

JSP 表达式元素包含一个脚本语言表达式，该表达式将被计算、转换为字符串并插入到 JSP 文件中该表达式出现的位置。

由于表达式的值会转换为字符串，因此您可以在 JSP 文件中的一行文本中使用表达式，无论它是否用 HTML 标记。

表达式元素可以包含根据 Java 语言规范有效的任何表达式，但不能使用分号来结束表达式。

以下是 JSP 表达式的语法 -

<%= expression %>

您可以编写与上述语法等效的 XML，如下所示 -

<jsp:expression>
   expression
</jsp:expression>

以下示例显示了 JSP 表达式 -

<html> 
   <head><title>A Comment Test</title></head> 
   
   <body>
      <p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>
   </body> 
</html> 

上面的代码将生成以下结果 -

Today's date: 11-Sep-2010 21:24:25

JSP 评论

JSP 注释标记 JSP 容器应忽略的文本或语句。当您想要隐藏或“注释掉”JSP 页面的一部分时，JSP 注释非常有用。

以下是 JSP 注释的语法 -

<%-- This is JSP comment --%>

以下示例显示了 JSP 注释 -

<html> 
   <head><title>A Comment Test</title></head> 
   
   <body> 
      <h2>A Test of Comments</h2> 
      <%-- This comment will not be visible in the page source --%> 
   </body> 
</html> 

上面的代码将生成以下结果 -

A Test of Comments
  

您可以在各种情况下使用少量特殊结构来插入本来会被特殊处理的注释或字符。这是一个总结 -

JSP 指令

JSP 指令影响 servlet 类的整体结构。它通常具有以下形式 -

<%@ directive attribute="value" %>

指令标签分为三种类型 -

我们将在单独的章节JSP - 指令中解释 JSP 指令

JSP 操作

JSP 操作使用XML 语法中的构造来控制 servlet 引擎的Behave。您可以动态插入文件、重用 JavaBeans 组件、将用户转发到另一个页面或为 Java 插件生成 HTML。

Action 元素只有一种语法，因为它符合 XML 标准 -

<jsp:action_name attribute="value" />

动作元素基本上是预定义的函数。下表列出了可用的 JSP 操作 -

我们将在单独的章节中解释 JSP 操作JSP - 操作

JSP 隐式对象

JSP 支持九个自动定义的变量，也称为隐式对象。这些变量是 -

我们将在单独的一章“JSP - 隐式对象”中解释 JSP 隐式对象。

控制流语句

您可以在 JSP 编程中使用 Java 的所有 API 和构建块，包括决策语句、循环等。

决策声明

if ...else块开始时与普通 Scriptlet 类似，但 Scriptlet 在每一行处关闭，并在 Scriptlet 标记之间包含 HTML 文本。

<%! int day = 3; %> 
<html> 
   <head><title>IF...ELSE Example</title></head> 
   
   <body>
      <% if (day == 1 || day == 7) { %>
         <p> Today is weekend</p>
      <% } else { %>
         <p> Today is not weekend</p>
      <% } %>
   </body> 
</html> 

上面的代码将生成以下结果 -

Today is not weekend

现在看看下面的switch...case块，它使用out.println()和 Scriptletas 内部编写得有点不同-

<%! int day = 3; %> 
<html> 
   <head><title>SWITCH...CASE Example</title></head> 
   
   <body>
      <% 
         switch(day) {
            case 0:
               out.println("It\'s Sunday.");
               break;
            case 1:
               out.println("It\'s Monday.");
               break;
            case 2:
               out.println("It\'s Tuesday.");
               break;
            case 3:
               out.println("It\'s Wednesday.");
               break;
            case 4:
               out.println("It\'s Thursday.");
               break;
            case 5:
               out.println("It\'s Friday.");
               break;
            default:
               out.println("It's Saturday.");
         }
      %>
   </body> 
</html> 

上面的代码将生成以下结果 -

It's Wednesday.

循环语句

您还可以在 JSP 编程中使用 Java 中三种基本类型的循环块：for、while 和 do…while块。

让我们看一下下面的for循环示例 -

<%! int fontSize; %> 
<html> 
   <head><title>FOR LOOP Example</title></head> 
   
   <body>
      <%for ( fontSize = 1; fontSize <= 3; fontSize++){ %>
         <font color = "green" size = "<%= fontSize %>">
            JSP Tutorial
      </font><br />
      <%}%>
   </body> 
</html> 

上面的代码将生成以下结果 -

   JSP Tutorial




   JSP Tutorial




   JSP Tutorial

上面的例子可以使用while循环编写如下 -

<%! int fontSize; %> 
<html> 
   <head><title>WHILE LOOP Example</title></head> 
   
   <body>
      <%while ( fontSize <= 3){ %>
         <font color = "green" size = "<%= fontSize %>">
            JSP Tutorial
         </font><br />
         <%fontSize++;%>
      <%}%>
   </body> 
</html> 

上面的代码将生成以下结果 -

   JSP Tutorial



   JSP Tutorial



   JSP Tutorial

JSP 操作符

JSP 支持Java 支持的所有逻辑和算术运算符。下表列出了所有优先级最高的运算符出现在表的顶部，优先级最低的运算符出现在底部。

在表达式中，将首先计算优先级较高的运算符。

JSP 文字

JSP 表达式语言定义了以下文字 -

• 布尔值- true 和 false

• 整数- 如 Java 中所示

• 浮点- 如 Java 中

• 字符串- 带单引号和双引号；" 转义为 \"，' 转义为 \'，\ 转义为 \\。

• 空- 空

JSP - 指令

在本章中，我们将讨论 JSP 中的指令。这些指令向容器提供方向和指令，告诉它如何处理 JSP 处理的某些方面。

JSP 指令影响 servlet 类的整体结构。它通常具有以下形式 -

<%@ directive attribute = "value" %>

指令可以具有许多属性，您可以将它们列为键值对并用逗号分隔。

@ 符号和指令名称之间以及最后一个属性和结束的 %> 之间的空格是可选的。

指令标签分为三种类型 -

JSP - 页面指令

page指令用于向容器提供指令。这些指令与当前 JSP 页面有关。您可以在 JSP 页面中的任何位置编写页面指令。按照惯例，页面指令在 JSP 页面的顶部进行编码。

以下是页面指令的基本语法 -

<%@ page attribute = "value" %>

您可以编写与上述语法等效的 XML，如下所示 -

<jsp:directive.page attribute = "value" />

属性

下表列出了与页面指令相关的属性 -

在页面指令中查看与所有上述属性相关的更多详细信息。

包含指令

include指令用于在翻译阶段包含文件。该指令告诉容器在转换阶段将其他外部文件的内容与当前 JSP 合并。您可以在 JSP 页面中的任何位置编写包含指令。

该指令的一般使用形式如下 -

<%@ include file = "relative url" >

include 指令中的文件名实际上是一个相对 URL。如果您只指定一个没有关联路径的文件名，JSP 编译器会假定该文件与您的 JSP 位于同一目录中。

您可以编写与上述语法等效的 XML，如下所示 -

<jsp:directive.include file = "relative url" />

有关包含指令的更多详细信息，请检查包含指令。

taglib 指令

JavaServer Pages API 允许您定义类似于 HTML 或 XML 标签的自定义 JSP 标签，而标签库是一组实现自定义Behave的用户定义标签。

taglib指令声明您的 JSP 页面使用一组自定义标记，标识库的位置，并提供用于识别 JSP 页面中的自定义标记的方法。

taglib 指令遵循下面给出的语法 -

<%@ taglib uri="uri" prefix = "prefixOfTag" >

这里，uri属性值解析为容器理解的位置，并且prefix属性通知容器哪些标记位是自定义操作。

您可以编写与上述语法等效的 XML，如下所示 -

<jsp:directive.taglib uri = "uri" prefix = "prefixOfTag" />

有关 taglib 指令的更多详细信息，请查看Taglib 指令。

JSP - 操作

在本章中，我们将讨论 JSP 中的操作。这些操作使用 XML 语法中的构造来控制 servlet 引擎的Behave。您可以动态插入文件、重用 JavaBeans 组件、将用户转发到另一个页面或为 Java 插件生成 HTML。

Action 元素只有一种语法，因为它符合 XML 标准 -

<jsp:action_name attribute = "value" />

动作元素基本上是预定义的函数。下表列出了可用的 JSP 操作 -

通用属性

有两个属性是所有 Action 元素共有的：id属性和scope属性。

ID属性

id 属性唯一标识 Action 元素，并允许在 JSP 页面内引用该操作。如果 Action 创建对象的实例，则可以使用 id 值通过隐式对象 PageContext 来引用它。

范围属性

该属性标识 Action 元素的生命周期。id 属性和scope 属性直接相关，因为scope 属性决定了与id 关联的对象的生命周期。scope 属性有四个可能的值：(a) page、(b)request、(c)session和(d) application。

<jsp:include> 操作

此操作允许您将文件插入正在生成的页面中。语法如下 -

<jsp:include page = "relative URL" flush = "true" />

与include指令在 JSP 页面转换为 servlet 时插入文件不同，此操​​作在请求页面时插入文件。

下表列出了与包含操作相关的属性 -

例子

让我们定义以下两个文件(a)date.jsp和(b) main.jsp如下 -

以下是date.jsp文件的内容-

<p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>

以下是main.jsp文件的内容-

<html>
   <head>
      <title>The include Action Example</title>
   </head>
   
   <body>
      <center>
         <h2>The include action Example</h2>
         <jsp:include page = "date.jsp" flush = "true" />
      </center>
   </body>
</html>

现在让我们将所有这些文件保留在根目录中并尝试访问main.jsp。您将收到以下输出 -

The include action Example
   Today's date: 12-Sep-2010 14:54:22

<jsp:useBean> 操作

useBean操作非常通用。它首先使用 id 和scope 变量搜索现有对象。如果未找到对象，它将尝试创建指定的对象。

加载 bean 最简单的方法如下 -

<jsp:useBean id = "name" class = "package.class" />

加载 bean 类后，您可以使用jsp:setProperty和jsp:getProperty操作来修改和检索 bean 属性。

下表列出了与 useBean 操作相关的属性 -

现在让我们讨论jsp:setProperty和jsp:getProperty操作，然后再给出与这些操作相关的有效示例。

<jsp:setProperty> 操作

setProperty操作设置 Bean 的属性。在此操作之前必须先定义 Bean。使用 setProperty 操作有两种基本方法 -

您可以在jsp:useBean 元素之后但在jsp:useBean元素之外使用 jsp:setProperty，如下所示 -

<jsp:useBean id = "myName" ... />
...
<jsp:setProperty name = "myName" property = "someProperty" .../>

在这种情况下，无论是实例化新 bean 还是找到现有 bean，都会执行jsp:setProperty 。

jsp:setProperty 可以出现的第二个上下文是jsp:useBean元素的主体内部，如下所示 -

<jsp:useBean id = "myName" ... >
   ...
   <jsp:setProperty name = "myName" property = "someProperty" .../>
</jsp:useBean>

此处，仅当实例化新对象时才执行 jsp:setProperty，而不是在找到现有对象时执行。

下表列出了与setProperty操作相关的属性-

<jsp:getProperty> 操作

getProperty操作用于检索给定属性的值并将其转换为字符串，最后将其插入到输出中。

getProperty 操作只有两个属性，这两个属性都是必需的。getProperty 操作的语法如下 -

<jsp:useBean id = "myName" ... />
...
<jsp:getProperty name = "myName" property = "someProperty" .../>

下表列出了与getProperty操作关联的必需属性-

例子

让我们定义一个将在我们的示例中进一步使用的测试 bean -

/* File: TestBean.java */
package action;
 
public class TestBean {
   private String message = "No message specified";
 
   public String getMessage() {
      return(message);
   }
   public void setMessage(String message) {
      this.message = message;
   }
}

将上述代码编译到生成的TestBean.class文件，并确保将 TestBean.class 复制到C:\apache-tomcat-7.0.2\webapps\WEB-INF\classes\action文件夹中，并且CLASSPATH变量也应该是设置到这个文件夹 -

现在在main.jsp文件中使用以下代码。这会加载 bean 并设置/获取一个简单的字符串参数 -

<html>
   
   <head>
      <title>Using JavaBeans in JSP</title>
   </head>
   
   <body>
      <center>
         <h2>Using JavaBeans in JSP</h2>
         <jsp:useBean id = "test" class = "action.TestBean" />
         <jsp:setProperty name = "test"  property = "message" 
            value = "Hello JSP..." />
            
         <p>Got message....</p>
         <jsp:getProperty name = "test" property = "message" />
      </center>
   </body>
</html>

现在让我们尝试访问main.jsp，它将显示以下结果 -

Using JavaBeans in JSP
Got message....
Hello JSP...

<jsp:forward> 操作

转发操作终止当前页面的操作，并将请求转发到另一个资源，例如静态页面、另一个 JSP 页面或 Java Servlet 。

以下是前向操作的语法-

<jsp:forward page = "Relative URL" />

下表列出了与转发操作相关的必需属性 -

例子

让我们重用以下两个文件(a) date.jsp和(b) main.jsp，如下所示 -

以下是date.jsp文件的内容-

<p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>

以下是main.jsp文件的内容-

<html>
   <head>
      <title>The include Action Example</title>
   </head>
   
   <body>
      <center>
         <h2>The include action Example</h2>
         <jsp:forward page = "date.jsp" />
      </center>
   </body>
</html>

现在让我们将所有这些文件保留在根目录中并尝试访问main.jsp。这将显示如下结果。

这里它丢弃了主页中的内容，仅显示转发页面中的内容。

   Today's date: 12-Sep-2010 14:54:22

<jsp:plugin> 操作

插件操作用于将 Java 组件插入到 JSP 页面中。它确定浏览器的类型并根据需要插入<object>或<embed>标记。

如果所需的插件不存在，则会下载该插件，然后执行 Java 组件。Java 组件可以是Applet 或JavaBean。

插件操作有几个与用于格式化 Java 组件的常见 HTML 标记相对应的属性。<param>元素还可用于向 Applet 或 Bean 发送参数。

以下是使用插件操作的典型语法 -

<jsp:plugin type = "applet" codebase = "dirname" code = "MyApplet.class"
   width = "60" height = "80">
   <jsp:param name = "fontcolor" value = "red" />
   <jsp:param name = "background" value = "black" />
 
   <jsp:fallback>
      Unable to initialize Java Plugin
   </jsp:fallback>
 
</jsp:plugin>

如果您有兴趣，可以使用一些小程序尝试此操作。新元素<fallback>元素可用于指定在组件失败时发送给用户的错误字符串。

The <jsp:element> Action
The <jsp:attribute> Action
The <jsp:body> Action

< jsp:element>、<jsp:attribute>和<jsp:body>操作用于动态定义 XML 元素。动态这个词很重要，因为它意味着 XML 元素可以在请求时生成，而不是在编译时静态生成。

以下是动态定义 XML 元素的简单示例 -

<%@page language = "java" contentType = "text/html"%>
<html xmlns = "http://www.w3c.org/1999/xhtml"
   xmlns:jsp = "http://java.sun.com/JSP/Page">
   
   <head><title>Generate XML Element</title></head>
   
   <body>
      <jsp:element name = "xmlElement">
         <jsp:attribute name = "xmlElementAttr">
            Value for the attribute
         </jsp:attribute>
         
         <jsp:body>
            Body for XML element
         </jsp:body>
      
      </jsp:element>
   </body>
</html>

这将在运行时生成以下 HTML 代码 -

<html xmlns = "http://www.w3c.org/1999/xhtml" xmlns:jsp = "http://java.sun.com/JSP/Page">
   <head><title>Generate XML Element</title></head>
   
   <body>
      <xmlElement xmlElementAttr = "Value for the attribute">
         Body for XML element
      </xmlElement>
   </body>
</html>

<jsp:text> 操作

<jsp:text>操作可用于在 JSP 页面和文档中写入模板文本。以下是此操作的简单语法 -

<jsp:text>Template data</jsp:text>

模板主体不能包含其他元素；它只能包含文本和 EL 表达式（注 - EL 表达式将在后续章节中解释）。请注意，在 XML 文件中，您不能使用${whatever > 0}等表达式，因为大于号是非法的。相反，请使用gt形式，例如${whatever gt 0}或替代方法是将值嵌入到CDATA部分中。

<jsp:text><![CDATA[<br>]]></jsp:text>

如果您需要包含DOCTYPE声明（例如XHTML ），则还必须使用<jsp:text>元素，如下所示 -

<jsp:text><![CDATA[<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
   "DTD/xhtml1-strict.dtd">]]></jsp:text>

   <head><title>jsp:text action</title></head>
   
   <body>
      <books><book><jsp:text>  
         Welcome to JSP Programming
      </jsp:text></book></books>
   </body>
</html>

尝试使用和不使用<jsp:text>操作的上述示例。

JSP - 隐式对象

在本章中，我们将讨论 JSP 中的隐式对象。这些对象是JSP容器在每个页面中提供给开发人员的Java对象，开发人员可以直接调用它们，而无需显式声明。JSP 隐式对象也称为预定义变量。

下表列出了 JSP 支持的九个隐式对象 -

请求对象

request 对象是javax.servlet.http.HttpServletRequest对象的实例。每次客户端请求页面时，JSP 引擎都会创建一个新对象来表示该请求。

request 对象提供了获取 HTTP 标头信息的方法，包括表单数据、cookie、HTTP 方法等。

我们可以在后续章节中介绍与请求对象相关的完整方法集 - JSP - 客户端请求。

响应对象

响应对象是javax.servlet.http.HttpServletResponse对象的实例。正如服务器创建请求对象一样，它也创建一个对象来表示对客户端的响应。

响应对象还定义了处理创建新 HTTP 标头的接口。通过这个对象，JSP 程序员可以添加新的 cookie 或日期戳、HTTP 状态代码等。

我们将在后续章节中介绍与响应对象相关的完整方法集 - JSP - 服务器响应。

输出对象

out 隐式对象是javax.servlet.jsp.JspWriter对象的实例，用于发送响应中的内容。

根据页面是否缓冲，初始 JspWriter 对象的实例化方式有所不同。使用page 指令的buffered = 'false'属性可以轻松关闭缓冲。

JspWriter 对象包含与java.io.PrintWriter类大部分相同的方法。然而，JspWriter 有一些额外的方法旨在处理缓冲。与 PrintWriter 对象不同，JspWriter 抛出IOExceptions。

下表列出了我们将用来编写boolean char、int、double、object、String等的重要方法。

会话对象

会话对象是javax.servlet.http.HttpSession的实例，其Behave与会话对象在 Java Servlet 下的Behave完全相同。

会话对象用于跟踪客户端请求之间的客户端会话。我们将在后续章节中介绍会话对象的完整用法 - JSP - 会话跟踪。

应用对象

应用程序对象是生成的 Servlet 的ServletContext对象的直接包装器，实际上是javax.servlet.ServletContext对象的实例。

该对象是 JSP 页面整个生命周期的表示。该对象在 JSP 页面初始化时创建，并在通过jspDestroy()方法删除 JSP 页面时删除。

通过向应用程序添加属性，您可以确保组成 Web 应用程序的所有 JSP 文件都可以访问它。

我们将在JSP - Hits Counter章节中检查应用程序对象的使用。

配置对象

config 对象是javax.servlet.ServletConfig的实例，并且是ServletConfig对象的直接包装器