使用 WebSphere Studio Enterprise Developer V5 的 EGL 和 Struts: 第 1 部分：生成 Java

文档选项 未显示需要 JavaScript 的文档选项 样例代码

级别： 初级

Reginaldo W. Barosa (rbarosa@us.ibm.com), IT 认证专家, IBM 波士顿

2003 年 7 月 01 日

本教程描述了 WebSphere Studio Enterprise Developer V5 用来部署用 WebSphere Application Server V5 的企业生成语言（Enterprise Generation Language，EGL）编写的应用程序的体系结构。

© Copyright International Business Machines Corporation 2003. All rights reserved.

引言

本教程描述了 WebSphere Studio Enterprise Developer V5 用来部署用 WebSphere Application Server V5 的企业生成语言（Enterprise Generation Language，EGL）编写的应用程序的体系结构。它将详细描述编码、测试、生成并部署一个三层应用程序的过程，该应用程序由 Web 接口、WebSphere Application Server V5 和执行 DB2® 查询来访问数据库的服务器程序组成。

本教程分为两部分。第 1 部分将讲述用 WebSphere Studio Enterprise Developer 来生成 Java™ 服务器程序的过程。而第 2 部分将讲述如何生成能在 z/OS 中运行的 COBOL/CICS 服务器程序，并还将描述如何为 z/OS 的执行配置必要的 Java 连接器。

我们将用标准 WebSphere 模型（servlet => JSPs => Java bean => server）来实现这个样本程序。WebSphere Studio EnterpriseDeveloper（以下简称 Enterprise Developer）用 Struts 框架来实现上述模型。此外，我们还将用 EGL 来实现这个模型，这意味着您可以不需要具备 Java 技能，因为 Enterprise Developer 会为您生成所有的 Java 代码和 JSP 代码。

本教程的重点不在于讨论对该程序进行编码的实际过程。相反，它将描述使用 Enterprise Developer 向 WebSphere Application Server 5.0（以下简称 Application Server）进行部署的编码和测试的生产过程。

如果您愿意，可以把教程所包含的样本程序加载到 Enterprise Developer 中，而不必自己从头开始。请参阅 下载部分以获取更多详细信息。

回页首

EGL 是什么？

企业生成语言（EGL）是一种开发技术，它是由 VisualAge® Generator 中使用的过程化语言发展而来的，它使您能够迅速地编写功能齐全的程序。最初发布的 EGL 允许您用简单的过程化语言来创建以下几种类型的程序：

• 能作为被调用程序在 CICS for MVS 上运行的 COBOL 程序。
• 能在 z/OS UNIX® System Services、Windows® 2000、Windows NT 或 Windows XP 以及 iSeries 上运行的 Java 程序。您可以在任何 J2EE 容器的上下文中部署该 Java 程序：
  • J2EE 应用程序客户机
  • J2EE Web 应用程序
  • EJB 容器；在这种情况下，您还可以生成一个 EJB 会话 bean。

用 EGL 进行编码有以下几点好处：

• 您可以通过使用过程化脚本语言和特定于语言的调试器来迅速地实现业务逻辑，这样可以提高您的生产力。
• 即使您不具备 Java 或 COBOL 技能，也能生成 Java 和 COBOL 代码。
• 您可以集中精力考虑代码所要解决的业务问题上，而不必疲于应付 CICS、MQSeries 和 SQL 之类复杂的技术问题；例如，您可以用相似的 I/O 语句来访问不同类型的外部数据存储。
• 您可以用相同的源来创建一个应用程序系统的多个部分。例如，当您开发好一个 EGL 程序后，可以生成一个 Java 包装程序、一个 EJB 会话 bean 和一个后端程序。假设您要开发软件来让用户访问 servlet，该 servlet 随后将数据发往一个生成的 Java 包装程序，然后让该包装程序访问 CICS 上生成的程序或者 EJB Server，在这种情况下，就能够提高效率了。
• 您可以根据当前平台的需求来编写代码而不必担心今后的迁移。
• 您不必学习面向对象编程就能创建 Java 应用程序和 servlet。
• 您可以不必为了能在 Web 应用程序服务器和在 CICS for MVS 上运行的生成的程序间进行通信而去编写一个 Java 连接器。一个生成的 Java 包装程序将对要在两者间传送的数据进行编组。
• 您可以用 EGL 生成 Java 和 COBOL，而且无需另外专门的编码就能够让它作为一个 Web 服务被使用。
• 最大的好处：您不必担心所生成代码的级别。例如，EJB 代码将根据最新支持的 EJB 级别生成，因此，您可以不必关心 EJB 规范的级别（比如 1.1、2.0 等等）。

回页首

Struts 是什么？

Struts 是 Java 类和 JSP 标记库的一个集合，它为开发 Web 应用程序提供了一个框架。Struts 技术是开放源代码的，并且是作为 Apache 软件基金会（Apache Software Foundation）的 Jakarta 项目的一部分来开发的。

Struts 可用来帮助您开发分为三个功能层的应用程序：

• 模型
  即业务逻辑，（在许多情况下）包括对数据存储（比如关系数据库）的访问。处理模型的开发小组可以是开发 DB2 COBOL 程序、EJB 实体 bean 或适用于存储和操纵企业数据的其他技术的专家。
• 视图
  负责表示层的代码。它由 JSP 和用来存储供 JSP 使用的数据的 Java bean 组成。
• 控制器
  用来决定事件全部流程的代码。

这种模型-视图-控制器划分（有时称为模型 2）拥有许多与生俱来的好处，并常常被认为是开发 Web 应用程序的最佳实践。要了解有关 Struts 的更多信息，请参阅 Apache Jakarta 项目 Web 站点。

Enterprise Developer 提供的 Struts 应用程序开发工具使您可以轻松地构建并管理基于 Struts 的 Web 应用程序。Enterprise Developer 具有下列功能：

• 允许您建立一个 Struts 项目，这样就能帮您准确地定位标记库和其他 Struts 相关的资源；因此，当您在开发应用程序时就可以顺利地引用那些资源。
• 提供了创建各种表单 bean 和操作类的向导，使您在开发特定于您应用程序的逻辑时能够领先一步。
• 包含一个用来创建和修改 Struts 配置文件的专用编辑器。
• 提供用于验证和编辑的 Struts 支持；例如，它可以帮助您使用 Struts 标记库。
• 提供了一个可视化装配工具，它有以下一些好处：
  • 帮助架构师设计基于 Struts 的 Web 应用程序的流程
  • 将 Struts 代码嵌入多个组件
  • 提供对适用于不同资源的的编辑器和向导的快速访问
  • 把小组的责任分开以求更大的生产力和更强的专业性。

回页首

使用 Struts 和 Enterprise Developer 的解决方案体系结构

Enterprise Developer 使用的 Struts 体系结构如图 1 所示。在运行时，Application Server 包含了模型 2 Web 应用程序的视图和控制器两个组件，而模型组件则包含在第三层（通常在 Application Server 之外）中。

回页首

Struts 数据流：组件详细内容

Struts 对 视图的作用：

• Struts 提供了 Java 类 org.apache.struts.action.ActionForm ，Java 开发人员将其子类化以创建表单 bean。在运行时，这个 bean 的使用方法有两种：
  • 当 JSP 在准备显示相关 HTML 表单时，JSP 会访问拥有要在表单中显示的值的 bean。这些值是由业务逻辑或先前的用户输入所提供的。
  • 当 Web 浏览器返回用户输入时，这个 bean 会验证并保存用户输入以供业务逻辑使用，或者（如果验证失败）就用于随后的重新显示。
• Struts 提供了许多定制 JSP 标记，它们使用简单然而 － 从它们隐藏了复杂性这个意义上讲 － 却功能强大。例如，页面设计人员不需要清楚地了解表单 bean，而只需要知道 bean 的名称和已知 bean 中每个字段的名称。

Struts 对 控制器的作用：

• Struts 控制器 servlet 依照部署时所提供的一组规则来处理运行时事件。那些规则被包含在 Struts 配置文件中并指定 servlet 如何响应从业务逻辑处接收到的每个传出。如果要改变控制流，只需要修改配置文件。控制器 servlet 是 org.apache.struts.action.ActionServlet （以下简称 ActionServlet）类的实例化。
• Struts 还提供了 Java 类 org.apache.struts.action.Action ，Java 开发人员将其子类化以创建操作类。在运行时，ActionServlet 会执行操作，这意味着 servlet 会调用每个实例化的操作类的执行方法。执行方法返回的对象会指导 ActionServlet 接着访问哪个操作或 JSP。从操作类调用业务逻辑比将业务逻辑包含在操作类中更有利于促进重用。

Struts 不直接作用于 模型开发，但 Struts 配置文件提供了一种简洁的方式来控制模型组件被调用的情况，但在这里，Enterprise Developer 对模型（开发）有了很大的帮助，因为它生成了必需的代码。

您也许会注意到 Struts 模型和 VisualAge Generator 所用的模型非常相似。因为这两个模型的实现非常相似（比如 Gateway Servlet 对应于 ActionServlet 等等），这使得您将来在 VisualAge Generator 和 Enterprise Developer 间进行迁移会变得更容易。请参阅 相关信息了解更多详细信息。

回页首

使用 EGL 实现一个简单的应用程序

为了更好地理解 Enterprise Developer 及其模型，我们将使用 Web 接口来实现一个简单的应用程序。在这个应用程序中：

• 用户键入一个 ID 并按下按钮来调用服务器程序。
• 服务器程序将读取 DB2 数据库中的数据来检查该 ID。
• 如果找到 ID，服务器程序就返回它的名称。如果没有找到，则将返回一条消息。

需要用到的数据库是 SAMPLE 数据库，而所要用到的表是 STAFF 表。其流程如图 2 所示。

后面的几步将指导您逐步创建、测试并部署上图所示的应用程序。要完成这个应用程序，您将需要：

• IBM WebSphere Studio Enterprise Developer V5
• IBM DB2 UDB V7（虽然早期版本同样适用），还有它创建的数据库 SAMPLE。

本文所示的示例所用的是 DB2 V 7.2。在将 DB2 JAR 文件添加入您的环境之前，请确保您所用的是正确的 JDBC（JDBC2）。一种简单的检查方法是转到 C:\SQLLIB\java12 目录并检查 inuse 文件是否存在。如果不存在，您将需要执行 usejdbc2.bat 命令（请参考适当的 DB2 文档获取帮助）。

如果您愿意，只要遵循 下载部分的说明，您就可以导入完整的解决方案而不必亲自动手。

回页首

构建一个 EGL 服务器程序

从后端开始编写程序是个好办法，首先要定义数据库布局和字段。然后，首先要做的就是定义变量和记录布局，然后是程序逻辑。

接着，EGL 服务器程序将对 STAFF 表（SAMPLE 数据库的一部分）进行简单地查询，如果找到用户标识，服务器程序将获取它的姓名；如果没有找到，则服务器程序将给出一条表明无效用户标识的消息。如果在连接数据库时发生错误，则将在另一个 Web 页面上显示一条消息。

您可以将 Enterprise Developer 下的 EGL 源代码存储在多个位置，但出于本教程的目的，我们将在 EGLWeb/Java Source 文件夹下创建所有 EGL 组件。

要实现这个示例，您需要执行下列任务：

1. 设置 Enterprise Edition EGL 首选项以启用 DB2 访问
2. 创建 EGL 组件
3. 以解释方式调试 EGL 程序
4. 生成 EGL Java 代码

1. 设置 Enterprise Edition EGL 首选项以启用 DB2 访问

使用 Enterprise Developer，对 DB2 进行适当设置以准备好工作区。这个活动通常是一次完成的，并且这是必需的，因为它提供了所需的缺省值。

1.1 设置 EGL Interpretive Debugger 首选项

Enterprise Developer 允许您用 EGL Java 调试器或 EGL Interpretive Debugger 调试 EGL 程序。要使用 EGL Java 调试器，您必须首先生成所有您要包括在调试会话中的 EGL 程序。而当您在使用 EGL Interpretive Debugger 时，不需要首先生成您的 EGL 程序。您可以简单地编写您的程序并启动调试。

要设置 EGL Interpretive Debugger 首选项，请选择 Windows => Preferences => EGL => Interpretive Debugger。我们的示例将在 Windows 下运行，并且我们将以 db2admin 身份登录，它也是我们的 SQL 用户标识。结果如图 3 所示，我们指定了下列值：

• EZESYS： WIN （其他可选项有： ISERIESJ 、 MVSCICS 或 USS ）
• EZExxx 特定词： db2admin
• Class Path Order：指出所需的 DB2 类（ db2java.zip ）的位置。

1.2 设置缺省数据库连接

要设置缺省数据库连接，请选择 SQL Database Connections并检查如图 4 所示的选择。请确保在 Class location 字段中指定了正确的 DB2 JAR 文件。

2. 创建 EGL 组件

EGL 定义可以按下面三种文件类型之一进行存储：

• 程序文件：
  • 扩展名： .eglpgm
  • 包含一个程序部件。程序文件的名称必须和程序部件的名称相匹配。在我们的示例中，程序将被命名为 TE01A 。
  • 可导入任意数量的定义文件。
  • 用 EGL 源格式编写。
  • 您要测试或生成的文件。
• 定义文件：
  • 扩展名： .egldef
  • 可包含任意数量的函数和数据部份。
  • 可由程序文件或其他定义文件导入。
  • 用 EGL 源格式编写。
• 构建文件：
  • 扩展名： .eglbld
  • 可包含任意数量的构建部件，并由它们来决定如何生成并准备一个程序。
  • 可导入其他构建文件。

您将创建一个名为 SAMPLE 的 EGL 定义文件，它将包含：

• 一个在访问 staff 表时要用的 DB2 记录定义（STAFF）
• 一个在与 EGL 服务器程序进行通信时要用的记录定义（TE01W01）。

通过将这些记录保存在一个独立于程序的文件中，您可以轻松地维护一个定义，并使它仍可以为多个程序所共享。同样，通过将 SAMPLE 数据库的所有记录定义存储在一个单独的文件中，就可以由数据库管理员来负责创建并维护这个文件以供开发人员使用。

Enterprise Developer 项目中哪些地方可以存储 EGL 源呢？您必须定义存储 EGL 文件的地方。在一个 Web 应用程序中，您可以将 EGL 源文件夹放在以下三个位置：

• Java 源之下
• Web 内容之下
• 直接在任何项目之下。

上述每一个位置都有其各自的优点和缺点。为了能更容易地导入和导出我们的代码，我们将把 EGL 文件存储在 Java 源之下。采用这种方式，如果我们要导出源的 WAR 或 EAR 文件，EGL 源也会包含其中。它还有一个优点：EGL 文件会被复制到 Web Content\WEB-INF\classes 目录下。这会创建在选择用来生成 Java 或 COBOL 代码的构建描述符时要用到的副本。开发人员也可能无意地改变 WEB-INF 中复制的版本。您可以在每一个项目构建中重新创建那些副本。

请参考 IBM 红皮书 Legacy Modernization with WebSphere Studio Enterprise Developer的第 8 章以获取更多信息。

2.1 创建 Web 项目

Web 项目是存放各种资源的容器，例如，这些资源可以是与部署 Web 页面或 Web 应用程序所必需的文件的层次结构相对应的源文件和元数据。要创建 Web 项目：

1. 启动 Enterprise Edition。
2. 打开 EGL Perspective。
3. 在 Navigator 视图中，选择 Ctrl+N => Web => Web Project来创建 Web 项目。
4. 在“Define the Web Project”对话框中，输入下列值：
   • Web 项目的名称： EGLWeb
   • Web 项目特性：选择 Add Struts support
   • 选择 Next。
5. 在“J2EE Settings”对话框中，将 New project name 的值设置为： EGLEAR 。选择 Finish。

该向导将创建一个包含预先准备好的适当的内容文件夹结构的空项目容器。这个文件夹将包含一些文件，它们是 Struts 框架的组成部分，如图 5 中的红框所示。您现在可以开始创建内容。

2.2 创建 SQL 记录

这一步，您将执行下列任务：

1. 使用 Navigator 视图中的 EGL Perspective，选择 EGLWeb/Java Source，然后按下 Ctrl+N。
2. 使用向导，从左边的列表中选择 EGL，然后双击右边列表中的 EGL Definitions File。
3. 选择 EGLWeb/Java Source文件夹。将 File name 的值设置为： SAMPLE 。选择 Next。
4. 在“Add Import Statements”对话框中，选择 Next。
5. 在“Select Type of Part to Add”对话框中，选择 Record，然后选择 Next。
6. 在“Enter Record Name...”对话框中，将 Name 的值设置为： STAFF 。选择 Next。
7. 在“Select Record Organization”对话框中，选择 SQL Record，然后选择 Next。
8. 在“Enter SQL Properties”对话框中，选择 Add。将 Name 的值设置为： db2admin.staff 。保持 Label 的值为 T1 。选择 Finish。（如果在创建 STAFF 表时所用的限定符不是 db2admin ，您必须更改它，否则向导将无法找到 STAFF 表。）
9. 编辑器随 SAMPLE.egldef 一起打开。用鼠标右键单击编辑器区域，从上下文菜单中选择 Retrieve SQL。该操作的结果如图 6 所示。
   图 6. EGL 记录定义
   
   
10. 用 Ctrl+S保存您所作的改变，但不要关闭编辑器。

2.3 创建工作区域（工作存储）

TE01W01 是我们的工作存储记录，它是一个为程序定义的临时数据区域。在晚些时候，您将把 TE01W01 声明为我们服务器程序中的参数数据区域。当要调用服务器程序的客户机在传递用户标识时就会用到它。在返回信息时，服务器程序会传递 TE01W01 中的名称或消息（如果用户标识无效）。

您可以使用 EGL Source Editor 来定义 TE01W01 记录：

1. 要添加一条记录定义，将光标移到编辑器的最后一行代码上。按下 Ctrl+Space，然后双击 Record。
2. 为 TE01W01 记录创建 ID 和 NAME 数据项。您可以从 STAFF 记录中复制 ID 和 NAME 的定义。
3. 关闭该文件。结果如图 7 所示。

2.4 创建 EGL 程序文件

通过上述首先定义的数据区域，代码辅助就会在将数据引用插入程序逻辑或函数逻辑时帮助您。这一般比手动完成插入更快更准确。在任何对数据区域的引用生效前都必须在程序或函数中定义并声明它。

由于 STAFF 和 TE01W01 记录被定义在另一个名为 SAMPLE.egldef 的文件中， IMPORT 语句将把那些定义链接到我们的程序中。您可以将这些记录声明为参数或变量。参数是由外部源传入程序或函数的，而变量则是程序或函数内部的数据区域。在我们的 EGL 服务器程序中，我们将把 TE01W01 记录声明为参数，而将把 STAFF 记录声明为变量：

1. 使用 Navigator 视图中的 EGL Perspective，选择 EGLWeb，然后按下 Ctrl+N。
2. 使用向导，从左边的列表中选择 EGL，然后双击右边列表中的 EGL Program File。
3. 选择 EGLWeb/Java Source文件夹。将 File name 的值设置为： TE01A 。选择 Next。
4. 在“Create EGL Program File - Add Import Statements”对话框中，选择 Add...。
5. 在“Add Import”对话框中，展开 EGLWeb并选择 SAMPLE.egldef。
6. 选择 Next两次。
7. 在“Add a Program Part - Enter Program Parameters...”对话框中，选择 Add...。
8. 在“Add Parameter”对话框中，将 Parameter name 的值设置为： TE01W01 ，然后选择 Next。
9. 在“Add a Program Part - Enter Program Variables...”对话框中，选择 Add...。
10. 在“Add Variable”对话框中，将 Variable name 的值设置为： STAFF 。
11. 选择 Finish。
12. 添加如图 8 所示的代码。
    图 8. EGL TE01A 程序
    
    
13. 保存并关闭编辑器。

2.5 编辑 SQL 缺省选择条件

SQL 缺省选择条件被存储在 SQL 记录的声明中。这些条件会根据缺省 SQL 语句中被选中的那些行来定义部分标准。要编辑 SQL 缺省选择条件：

1. 用鼠标右键单击 SAMPLE.egldef并选择 Open With => EGL Part Editor，这样就能用 EGL 部件编辑器打开记录定义文件。编辑器显示了 SQL 结构。
2. 选择 EGL 部件编辑器工具条上的 Show SQL Default Select Conditions（ ）。
3. 通过输入不带“WHERE”关键字的选择条件来设置 Default select conditions 字段，例如： ID = :ID 。请参阅图 9。
4. 在 Default select conditions 字段中，用鼠标右键单击并选择 Check SQL Statement来执行对您的 SQL 语句的语法检查。如果检测到错误，就会显示 SQL Errors 视图，由它来显示关于错误的信息。
   图 9. 在 TE01A 程序中使用的 SQL 语句
   
   
   如果您使用的是 DB2 V7 或更高版本，Check SQL Statement 功能可能无法正确工作。比如说即使 SQL 语句中有错，您也可能收到表示全部正确的消息，发生这种情况是有可能的。导致这种情况发生的是 db2cli.ini 文件（位于 SQLIB 文件夹中）中的一个参数的参数，您必须为“每个”正在使用 DB2 的工作站更新一次该文件。要避免产生这个问题，您可以选择 Start => Programs => IBM DB2 => Command Window 来启动 DB2 命令窗口，并执行以下命令：
   db2 update cli cfg for section COMMON using DEFERREDPREPARE 0
   该命令将在 db2cli.ini 文件中额外添加一行，强制语法检查正确工作。
5. 保存并关闭编辑器。

2.6 创建 EGL 程序的构建描述符

EGL 将生成诸如 Java 或 COBOL 的代码，但用户仍需要提供一些信息，比如要生成的 java 包的名称、目标操作系统、数据库名称等等。这些规范被存储在构建描述符部件控制中。这些部件包含以下几类信息：

• 构建描述符选项
  指定如何生成并准备 EGL 输出。构建描述符选项的子集可以在生成过程中包含其他构建部件。
• 用户定义的替代参数
  允许您建立限定符以在具体的目录名称中使用。
• Java 运行时属性
  为一些具体的“eze”术语（比如 ezedtelc、ezedaylc 和 ezeconct）赋值。当您要生成 COBOL 时，Java 运行时属性不起作用。

2.6.1 创建用于调试的构建描述符

在生成用于生产的代码之前，调试 EGL 代码是个不错的主意。为此您必须创建一个构建描述符；我们将把它命名为 intdebug 。要创建该描述符：

1. 选择 EGLWeb项目，然后按下 Ctrl+N。
2. 在“New - Select”对话框中，从左边的列表中选择 EGL，然后双击右边列表中的 EGL Build File。
3. 在“Create EGL Build File - Select Container”对话框中：
   • 选择 EGLWeb/Java Source文件夹。
   • 将 File name 的值设置为： TE01ABuild 。
4. 选择 Next两次。
5. 使用“Add EGL Build Part - Select Type...”向导，选择 Build Descriptor，然后选择 Next。
6. 在“Add a Build Descriptor Part - Enter Build Descriptor Name...”对话框中，将 Name 的值设置为： intdebug ，并选择 Finish。 TE01ABuild.eglbld 文件已被打开并使它可供编辑。
7. intdebug 被添加到 Outline 视图中，并且该部件已被打开并准备被编辑。在编辑器中，从 Build option filter 下拉菜单中选择 Java Debugging (Basic)。构建选项的表格会发生相应变化，也就是只显示和调试相关的选项。为规范使用下表：
   
   

   选项	值
   debug	yes
   J2EE	no
   package name	EGL
   sqIDB	jdbc:db2:SAMPLE
   sqlJDBCDriverClass	COM.ibm.db2.jdbc.app.DB2Driver
   system	WIN

8. 用 Ctrl+S来保存您所作的改变。
9. 选择 Show only specified options并将结果和图 10 进行比较：
   图 10. 用来调试的 EGL 构建描述符
   
   
10. 保存并关闭编辑器。

3. 以解释方式调试 EGL 程序

前面已经提过，在使用 EGL Interpretive Debugger 时您不必首先生成您的 EGL 程序。您可以简单地编写您的程序并开始调试。该调试器和 EGL 部件编辑器(或源编辑器）的结合允许您执行下列任务：

• 您可以在想要使调试器停下的代码处设置和除去断点。
• 您可以逐句调试 EGL 代码。您可以跳入被调用函数或程序进行逐句调试，或仅仅将整个调用作为一个当前语句来运行。
• 您可以从当前语句开始运行直至到达一个断点（或程序尾部）。
• 检查当调试器停止时在当前 EGL 程序和已调用的函数中定义的变量的值。
• 当调试器停止时改变变量值。有时您可以通过将不正确的值改为将由正确代码产生的值以临时地调整代码问题。这样您就可以继续调试会话，从而避免在每遇到一个错误或断点时都不得不重新生成并重新启动调试会话。
• 显示程序和函数的当前调用栈。您可以选择调用栈中的条目，这样可以显示变量被调用时的值。

3.1. 在 account.eglpgm 中设置断点

在我们的示例中，让我们设置一个简单的断点来检查并修改变量内容：

1. 在 Navigator 视图中，双击 TE01A.eglpgm。
2. 在编辑器中，双击 staff.ID = TE01W01.ID行的左页边距。这样就会出现一个蓝色圆点，它表示已为该行设置了断点。请参阅图 11。
   图 11. EGL 程序 TE01A 中的断点
   
   
3. 关闭 TE01A.eglpgm

3.2 创建 account.eglpgm 的解释方式的调试启动定义

1. 打开 Debug Perspective。从菜单条中选择 Run => Debug...
2. 当打开“Launch Configurations”窗口时，用鼠标右键单击 Debug an EGL Program Interpretively，然后选择 New。
3. 将 Name 的值设置为： TE01A 。
4. 用 Browse按钮，将 Project 的值设置为： EGLWeb。
5. 用 Browse按钮，将 EGL Program name 的值设置为： Java Source/TE01A.eglpgm。
6. 选择 Debug。
7. 当显示“Select a Build Descriptor”窗口时，选择已经定义好的 intdebug构建描述符，然后选择 OK。
8. 由于 TE01A 需要一个参数，故将显示一个警告。选择 Yes继续。

3.3 调试 EGL 程序

1. 调试器在 TE01A.eglpgm 的第一行代码处停止。在 Variables 视图（右上角）中，展开 STAFF => TE01W01 => ID结构。
2. 在 TE01W01 下，设置 ID=30（您只需要双击）。
3. 逐步调试该程序，观察帐户变量的改变（从菜单条中选择 Run => Step Over，或选择工具条中的 Step Over，也可以按 F6）。
4. 检查程序是否正在访问该表并从中检索姓名。待程序终止后，关闭 Debug Perspective。图 11 展示了程序正常运行时变量的内容：
   图 11. 调试过程中的变量
   
   
5. 关闭 TE01A.eglpgm 编辑器。

4. 生成 EGL Java 代码

如果解释调试的测试结果正确，那就可以生成 Java 代码供以后使用。现在，您将创建两个构建描述符，而它们将被用于生成 Java Server 组件：

• win-java
  这个构建描述符将定义如何创建一个 Java 类文件的集合来执行 EGL 逻辑。
• wrapper
这个构建描述符将定义如何创建一个 Java 包装程序文件，该文件将提供一个连接我们的 EGL 服务器程序的连接器。

4.1. 创建用于 Java 代码生成的构建描述符

1. 在 Navigator 视图中，双击 TE01ABuild.eglbld。
2. 在 Outline 视图中，用鼠标右键单击 TE01ABuild，然后选择 Add part。
3. 这样就会出现“Add EGL Build Part”向导。选择 Build Descriptor，并单击 Next。
4. 在“Add EGL Build Part - Enter Build Descriptor Name”对话框中，将 Name 的值设置为： win-java ，然后选择 Finish。
5. 这样 win-java 部件就被添加到 Outline 视图中，并被打开以供编辑。从 Build option filter 下拉菜单中选择 Java Target System (All)。构建选项的表格就会发生相应变化，也就是只显示那些与生成 Java 代码相关的选项。
6. 输入下列值：
   • debug 下拉菜单：选择 YES
   • genProject：选择 EGLWeb
   • genProperties： Yes
   • J2EE：选择 YES
   • packageName： eglweb.java
   • sqlDB： jdbc/SAMPLE
   • system：选择 WIN
7. 用 Ctrl+S保存您所作的改变。
8. 选中 Show only specified options以将选项列表中的选项减少到只有刚才输入的那些选项。请和图 13 中的列表进行比较。

4.2. 创建用于 Java 包装程序生成的构建描述符

EGL 生成的 Java 包装程序是一个类的集合，作为 servlet（或 Java 程序）和 EGL 生成的程序间的一个接口来工作。通过提供用于调用服务器的方法，以及用于获取和设置参数值的方法，java 包装程序使得 Java 程序员可以快速且轻松地调用我们的 EGL 服务器。Java 包装程序将对 Java 对象和记录结构（针对生成的 COBOL 程序）间的参数数据进行编组，对 ASCII 和 EBCDIC 数据进行相互转换，并处理所有的通信。

当您请求将程序部件生成为 Java 包装程序，EGL 会为下列内容产生一个包装程序类：

• 生成的程序
• 在该程序中声明为参数的每个记录或结构。

您将要设置 Java 包装程序构建描述符的下列选项：

• linkage ：表示一组描述如何调用 EGL 服务器程序的选项。
• nextBuildDescriptor ：将选项设置从另一个构建描述符添加到这个构建描述符所定义的选项中，比如 genProject 、 genProperties 和 packageName 。
• system=JAVAWRAPPER ：用于生成 Java 包装程序类。

要创建 Java 包装程序构建描述符：

1. 在 Outline 视图中，用鼠标右键单击 TE01ABuild，然后选择 Add part。
2. 这样就会出现“Add EGL Build Part”向导。选择 Build Descriptor，然后选择 Next。
3. 在“Add EGL Build Part - Enter Build Descriptor Name”对话框中，将 Name 的值设置为： wrapper ，然后选择 Finish。
4. 这样就能将 wrapper 部件添加到 Outline 视图中，且该部件已打开并使它可供编辑。在 Build option filter 下拉菜单中选择 Java Wrapper (All)。构建选项的表格就会发生相应变化，也就是只显示那些与生成 Java 代码相关的选项。
5. 输入下列值：
   • linkage： linkageTE01A
   • nextBuildDescriptor：选择 win-java
   • system： JAVAWRAPPER
6. 用 Ctrl+S保存您所作的改变。
7. 选中 Show only specified options以将选项列表中的选项减少到只有刚才输入的那些选项。请和 图 14 中的列表进行比较。

4.3. 创建 linkage 部件

linkage 部件定义了生成的 Java 包装程序应该如何调用一个被调用 EGL 程序。

1. 在 Outline 视图中，用鼠标右键单击 TE01ABuild，然后选择 Add part。
2. 这样就会出现“Add EGL Build Part”向导。选择 Linkage Options，然后选择 Next。
3. 在“Add EGL Build Part - Enter Build Descriptor Name”对话框中，将 Name 的值设置为： linkageTE01A ，然后选择 Finish。
4. 这样就能将 linkageTE01A 部件添加到 Outline 视图中，且该部件已打开并使它可供编辑。在编辑器中，在 callLink elements 表的下面选择 Add...。
5. 输入下列值：
   • Program Name： TE01A
   • Type：选择 remoteCall
6. 用 Ctrl+S保存您所作的改变。
7. 在“Properties of selected callLink elements”框中，输入下列值：
   • location： localhost
   • package： eglweb.java
   • remoteBind：选择 GENERATION
   • remotePgmType：选择 EGL
8. 用 Ctrl+S保存您所作的改变。您的 linkage 应该如图 15 所示。
   图 15. TE01A 程序的 Linkage 选项
   
   
9. 关闭 TE01ABuild.eglbld 文件。

您指定选项的概要描述：

4.4. 设置 EGL 缺省构建描述符

当您在项目、文件夹或单独的 EGL 程序的属性中设置了缺省构建描述符，就不需要为每个生成请求指定一个构建描述符。要设置缺省构建描述符（图 16）：

1. 在 Navigator 视图中，用鼠标右键单击 EGLWeb，然后从上下文菜单中选择 Properties。
2. 在“Properties”对话框中，从左边的列表中选择 EGL Default Build Descriptors。
3. 输入下列值：
   • Target system build descriptor： win-java (EGLWeb/Java Source/TE01ABuild.eglbld)
   • Java debugging build descriptor： intdebug (EGLWeb/Java Source/TE01ABuild.eglbld)
   • Java wrapper build descriptor： wrapper (EGLWeb/Java Source/TE01ABuild.eglbld)
4. 选择 OK。

4.5. 生成 Java EGL 服务器程序

要调用生成向导，在 Navigator 视图中用鼠标右键单击一个资源名称并选择 Generate EGL...。这将生成嵌套在该资源内所有文件中的顶层的所有程序部件。该向导会把所有顶层 EGL 程序显示给您，由您来选择哪些是您想要生成的。例如，如果您选择了一个项目资源，它会显示存储在项目中的 .eglbld 文件的顶层的每个程序部件以供您选择。由于我们已在前面指定了缺省构建描述符，故使得生成变得更容易了。

要生成 Java EGL 服务器程序：

1. 切换到 EGL 透视图。
2. 在 Navigator 视图中，用鼠标右键单击 EGLWeb 项目的 TE01A.eglpgm。然后从上下文菜单中选择 Generate EGL with => Target System and Java Wrapper Build Descriptors。
3. 这样就会出现 Generate 向导。确保在要生成部件的列表中选择了 TE01A。由于已经设置了 EGL Default Build Descriptors项目属性，就不再需要做什么了。选择 Finish。
4. EGL 生成现在就将开始。当它完成后，在 Generation Results 视图中检查有关 TE01A(wrapper ) 和 TE01A(win-java) 的消息，它们表示生成过程完成且没有出现错误。

注意多个文件（比如 TE01A.java 和 Te01aWrapper.java ）已经被生成到 EGLWeb/Java Source/eglweb/java 文件夹之下，如图 17 所示。

由于服务器程序是用 Java 编写的，您还要注意将一些环境变量添加到针对生成的 EGL Java 程序的部署描述符（ web.xml ）中。这些变量反映了您在 win-java 部署描述符中指定的那些变量。图 18 展示了用部署描述符编辑器编辑的 web.xml 文件。

到此为止，您已经准备好了所有供应用程序的客户机端使用的 Java 服务器代码和 Java 包装程序。

回页首

构建应用程序的客户机端

我们将使用 Struts 框架来对这个示例进行编码。WebSphere Studio Enterprise Developer 的 Struts 工具提供了下列向导：

现在可以使用这些向导来完成后面一系列的任务。为了帮助您，Enterprise Developer 提供了一个新的名为 Cheat Sheets 的超级向导（可看作上述所有向导的一个总的向导）来指导用户遍历整个开发过程，并为用户提供了一系列步骤来构建一个基于 Struts 的 Web 项目。

回页首

使用 Struts EGL Cheat Sheet

Cheat Sheet 是一个程序，它可以帮助您完成涉及一系列不同子任务的复杂任务。Struts EGL Cheat Sheet 可以创建使用 EGL 的基于 Struts 的 Web 应用程序。对于新手或任何喜欢这种附加指导的人来说，它能够提供很大的帮助。

要启动 Cheat Sheet，从菜单条单击 Help => Cheat Sheets。打开的级联菜单中列出了五种最常用的 Cheat Sheet。您也可以选择 Other...来打开一个对话框以选择其他 Cheat Sheet。Cheat Sheet 是以视图方式打开的。任何时候都只能打开并激活一个 Cheat Sheet，因此在打开一个新的 Cheat Sheet 之前将关闭任何已打开的 Cheat Sheet。被关闭的 cheat sheet 的完成状态将被保存。

一般来说，要使用 Cheat Sheet 来创建基于 Struts 的 Web 项目：

• 选择 Help => Cheat Sheets => Other... => Web Application With EGL CheatSheet。
• 这样就能打开“Cheat Sheet”对话框，然后您可以遵循下列步骤。
• 当您选择了 Click to perform 按钮（ ），它会运行一个工具（可以是一个向导），然后您就将使用那个工具。当您用完之后，下一步就会被自动突出显示并变为当前步骤。
• 如果当前步骤是一个人工任务，就将需要您来执行它并选择 Click to complete 按钮（ ）以转入下一步。
• 每个已完成的步骤的左页边距上都会有一个钩标记（ ）。

我们将要执行的一系列步骤（由 Cheat Sheet 指导）如下所示，在图 19 中所示的 Cheat Sheet 中也有。

1. 创建一个 Web 项目
2. Create a Web diagram
3. 创建 JSP（Web 页面）和 bean
4. 创建 Struts 操作
5. 实现业务逻辑组件
6. 生成并编译 EGL 组件
7. 运行 Web 应用程序。

1. 创建一个 Web 项目

我们已经在前面创建了 Web 项目，因此您可以通过单击 Cheat Sheet 的 图标绕过这一步。

2. 创建一个 Web 图表

Web 图表是一个文件，它可以帮助您显现基于 Struts 的 Web 应用程序的流程结构。下面的表格按照对话框的顺序显示需要您输入值的字段：

Web 图表编辑器将会被打开。Web 图表的一个很有用的特性是底层资源的任何改变都会实时地在图中显现出来。在我们的示例中，您将可以在编辑器的自由格式表面（FFS）中为名为 index.jsp 、 result.jsp 和 error.jsp 的 Web 页面创建节点，而这些页面现在并不存在。我们将出现在 FFS 上还没有实现的节点称作未实现（节点）。当您在图表编辑器以外创建了该 JSP，在图表编辑器得知该 JSP 已被创建后，就会在其图中作出实时的改变。

同样，如果删除图中已实现部件的底层资源，在图表编辑器得知该删除（操作）后也将在图中作出相应的改变。您可以使用图表编辑器来展示全部（或部分）Struts 应用程序。您还可以直接与图中的部件进行交互。例如，您可以直接从图表编辑器中调用 JSP 编辑器。

使用图表编辑器：

1. 按照下表从 中拖放并命名各图标：
   

   组件	连接到…／从…连接	转发名称	作用域
   index.jsp （Web 页面节点）	inquiry		request
   result.jsp （Web 页面节点）	inquiry	valid
   error.jsp （Web 页面节点）	inquiry	invalid
   Inquiry （操作映射节点）	全部
   InquiryForm （表单 bean 节点）	inquiry

   
   
2. 现在，按下图所示拖放并连接各图标：
   图 20. 流程图
   
   
3. 用 Ctrl+S保存该图。
4. 通过选择位于工作台左端的 图标，返回“Cheat Sheet”对话框。

3. 创建 JSP（Web 页面）和 bean

这一步，您将定义并实现 JSP、操作查询以及与您的 Web 图表相关联的 bean。您可以选择 perform 按钮（ ），这将会显示所要创建元素的列表，如图 21 所示。然后您可以双击每个元素来创建它。然而，如果您首先创建了表单 bean，那么向导就会根据您在那个表单 bean 中所指定的内容来创建 JSP 模型。创建表单 bean（ InquiryForm ）的步骤如下所示。

3.1 创建 InquiryForm

表单 bean（一种类型的 Java bean）是 ActionForm 类子类的实例，它既可以从提交的客户机请求中存储 HTML 或 JSP 表单数据，也可以存储来自用户选择的链接的输入数据。HTML 或 JSP 表单是由用于供用户输入信息的字段组成。

当浏览器提交 HTML 表单时，Struts ActionServlet 会进行如下操作：

• 查看 HTML 表单中各字段的名称。
• 将它们与表单 bean 中的属性名称进行匹配。
• 自动调用这些变量的 setter 方法以输入从 HTML 表单中检索而得的值。

此外，如果您实现了一个验证方法并在 Struts 配置文件中相应的操作映射条目上设置了验证标志，ActionServlet 将会调用那个验证方法。

我们可以在创建完 JSP 之后再创建表单 bean，但先创建表单 bean 会在生成 JSP 模型时对我们有所帮助。要创建表单 bean：

1. 双击 InquiryForm 。
2. 在“NewActionForm Class”对话框中，全部采用缺省值，然后选择 Next。
   图 22. 创建表单 bean
   
   
3. 在向导的“Choose new accessors”对话框中，选择 Next。
4. 在“New ActionForm class - Create new accessors...”对话框中，选择 Add...。
5. 输入 ID 和 name 的值，如图 23 所示。（按 Tab 离开 Type 栏以确保输入的值被接受。）现在，我们可以通过定义字段来利用 Struts 工具特性之一以创建这个 JSP，且所创建的 JSP 会用缺省布局来显示这些字段。
   图 23. 创建 ActionForm - accessors，改变类型
   
   
6. 选择 Finish生成 InquiryForm 。
7. 这样就创建了 InquiryForm Java 类并打开了编辑器。看一下生成的代码，您会看到其中已经创建了 ID 的 getter 和 setter 方法（ getID 和 setID ）、name 的 getter 和 setter 方法（ getName 和 setName ）以及一个 validate 方法。您可以用这个 validate 方法来验证您表单中的字段。
8. 关闭编辑器。

请注意：

• struts-config.xml 已被更新
• 该类被命名为 InquiryForm
• Struts 的表单 bean 被命名为 inquiryForm （其中 i 是小写的；小心，这可能造成混乱）。

生成的 xml 如下所示：

3.2 创建 error.jsp

要创建 error.jsp ：

1. 双击 error.jsp。
2. 全部采用缺省值，然后选择 Finish。
3. 使用编辑器和 Design 视图，输入错误消息： Error! Could be problems with Data Base connection. Check WebSphere Console.
4. 保存数据。结果如图 24 所示。

3.3 创建 index.jsp.

要创建 index.jsp ：

1. 双击 index.jsp。
2. 使用“New JSP File”向导，全部采用缺省值。
3. 选择 Next（五次）直至“Form Field Selection”对话框出现。
4. 在“Form Field Selection”对话框中，选择下列值（如图 25 所示），然后选择 Finish。
   • Form bean entry：选择 inquiryForm
   • 字段：ID
   
   图 25. 创建 index.jsp
   
   
5. Enterprise Developer 会自动创建带有 Struts 标记库引用以及被选中的 ID 字段的 index.jsp 。这样就会打开 JSP 并使它可供编辑。请注意生成的 JSP 中包含了选中的 ID 字段，如图 26 所示。
   图 26. 生成的 Index.jsp
   
   
6. 如图 27 所示改变文本。
   图 27. 修改后的 Index.jsp
   
   
7. 用 Ctrl+S保存您所作的改变并关闭编辑器。

3.4 创建 result.jsp

要创建 result.jsp ：

1. 双击 result.jsp。
2. 全部采用缺省值，然后选择 Finish。
3. Enterprise Developer 会自动创建带有 Struts 标记库引用的 result.jsp 。这样就可以打开该 JSP 并使它可供编辑，同时显示“Place result.jsp's content here”行。按照下列步骤替换该行。
4. 将该行的属性改为 Heading 2。
5. 按下 Enter在表单内获取新的一行。
6. 选择 Ctrl+T插入一张表。
7. 在“Insert Table”对话框中，选择 OK。
8. 这样就会显示一张 2x2 的表。将光标放在该表的第一行第一个单元格中，然后输入 USERID 。
9. 将光标放在第一行第二个单元格中（右上）。从菜单条中选择 JSP => Insert Custom...。
10. 在“Insert Custom Tag”对话框中，在文档中的 Tag 库中选择 /WEB-INF/struts-bean.tld。
11. 对于 Custom 标记，选择 write，然后选择 Insert。不要关闭这个窗口，因为您还会用到它。现在只是暂时离开这个窗口。
12. 在第二行第一个单元格中输入 NAME 。
13. 移到第二行第二个单元格。
14. 在“Insert Custom Tag”对话框中，在文档中的 Tag 库中选择 /WEB-INF/struts-bean.tld。
15. 对于 Custom 标记，选择 write，然后选择 Insert。
16. 选择 Close。
17. 从菜单条中选择 JSP =>Show Visual Custom Tags。这将取消对 Show Visual Custom Tags的选中，从而导致出现一个 bean:write 标记的按钮。
18. 将光标放在这张表的下面，按下 Enter，然后键入 Click here to return to the Index Page.
19. 选择您刚才输入的文本（突出显示整行），用鼠标右键单击，然后选择 Insert Link...
20. 在“Insert Link”对话框中，输入下列值：
    • Type： File
    • URL： index.jsp
    选择 OK。结果如图 28 所示。
    图 28. 完成后的 Result JSP
    
    
21. 选择编辑器底部的 Source标签。
22. 改变 struts 标记，如下所示：
    
    <bean:write name=" inquiryForm" property=" ID" />
    <bean:write name=" inquiryForm" property=" name" />尽管 Java 类的名称是 InquiryForm ，但请小心表单 bean 的名称却是 inquiryForm （首字母小写）。这两者很容易被搞混。编码改变的结果如图 29 所示。
    图 29. Result JSP 的源代码
    
    
23. 用 Ctrl+S保存您所作的改变。
24. 检查 Tasks 视图。应该没有 result.jsp 的错误。请解决那些仍然存在的错误（如果有）。请注意您还没有定义 /inquiry ，因此 Tasks 视图中会有一个警告。我们将在下一步中解决这个问题。
25. 关闭 result.jsp 编辑器。

至此，您已经创建了您将要用到的三个 JSP。请注意现在 EGLflow.gph 中这些 JSP 节点已经变为彩色的了，这表示它们已经被实现。如果“Select Web Pages”窗口仍然开着，请关闭它。

4. 创建 Struts 操作

Struts 操作是 Action 类子类的实例，用来实现一部分 Web 应用程序并返回一个转发。操作映射是一个配置文件条目，它将操作名称和操作、表单 bean 及本地转发关联在一起。

这一步您将定义并实现与 Web 图表相关联的 Action inquiry。您将在操作映射向导中调用 EGL 业务逻辑。使用 Cheat Sheet：

1. 选择 perform 图标（ ）。
2. 在 Select Action 对话框中，双击 on inquiry(Unrealized)。
3. 这样就会出现“New Action Mapping”向导。输入下列值，如图 30 所示：
   • Form Bean Name：选择 inquiryForm
   • Model：选择 EGL Struts Action
   选择 Next。
   图 30. 创建新的操作映射
   
   
4. 在“New Action Mapping - Create a EGL Struts Action”对话框中，选择 EGL Wrapper（如图 31 所示），然后选择 Next。
   图 31. 使用 EGL 创建新的操作映射
   
   
5. 在“New Action Mapping - Define data mappings”对话框中，输入或修改下列值：
   • 因为我们的 JSP 表单中只有一个输入字段，所以在 Input Mappings 中：
     • 使用 Add (form bean)按钮，输入 (short)iD
     • 使用 Remove按钮，除去 name 。
   • 使用 Add (reuse form bean)按钮，在 Output Mappings 中：
     • 输入 (short)id
     • 输入 (String)name
   由于这是在“Add a form bean mapping”弹出窗口中执行的，您可以在 Input 和 Output 中只选择 ID，选择 Add，然后为 name执行同样操作，然后选择 Done。结果如图 32 所示。
   图 32. 创建新的操作映射，定义数据映射
   
   
6. 选择 Finish。

请注意这样就创建了一个名为 InquiryAction.java 的类并且打开了编辑器。如果您愿意，您可以花一些时间去理解所生成的 Java 代码。转到 perform 方法，它是负责调用由 EGL 代码生成的 Java 类并把参数传给它们的方法。如果您想遵循执行逻辑，这也许是设置断点的一个好地方。您还会注意到 ID 字段通过工作存储（使用 Te01w01 生成的 Java bean）被发往生成的 EGL Java Wrapper（ Te01aWrapper ）。请参阅图 33 中的 perform 方法。

4.1 检查 Struts 转发

Struts 转发是由一个操作返回的对象，它有两个字段：一个名称和一个路径（通常是 JSP 的 URL）。其中路径是指将请求发往（或转发到）何处。转发可以是局部的（附属于一个具体的操作），也可以是全局的（对任何操作都可用）。

请确保在 InquiryAction 类的 perform 方法中正确地定义了转发。如果服务器程序中没有错误，那么转发就是 有效的；如果有错误，那它就是 无效的。

您将需要把无效转发的那一行移至正确的位置，如图 34 所示。

保存并关闭编辑器。至此 Struts 框架准备就绪。根据 Cheat Sheet 上的步骤，下一步将是实现业务逻辑组件（EGL）。

5. 实现业务逻辑组件

在这个步骤中，您将创建 EGL 程序来实现业务逻辑。因为我们发现在创建服务器程序时使字段定义能被重用更加容易，所以我们已经在 前面的步骤中完成了这个任务。然而，我们也可以选择在此处使用 EGL 向导来创建 EGL 源代码。

选择绕过按钮（ ）。

6. 生成并编译 EGL 组件

这一步，我们使用向导来生成 EGL 程序。由于我们已经生成了用 Java 代码写的 EGL 程序，也就是说这是另一个我们可以通过选择绕过按钮（ ）来绕过的步骤。

7. 运行 Web 应用程序

要运行应用程序：

1. 选择应用程序将运行哪个 WebSphere Application Server。单击 perform 图标（ ）来启动向导。
2. 设置下列值：
   • 文件夹：选择前面创建的 EGLWeb。
   • 应用程序服务器： WebSphere version 5.0 。您也可以使用已经定义的 WebSphere Application Server。
3. 这个代码是已发布的，并且 WebSphere Application Server 也启动了。当控制台显示了
   WSVR0001I: Server server1 open for e-business 消息，浏览器就会打开，并显示如图 35 所示的屏幕。
   图 35. 第一个 Web 屏幕
   
   
4. 为 Userid 输入值 30 ，然后选择 Submit。
5. 您的 WebSphere 控制台应该会列出一个错误（请参阅所有的红色消息），并应该显示 error.jsp ，如图 36 所示。
   图 36. 使用 error.jsp 的错误消息
   
   
6. WebSphere 控制台上的消息显示：
   VGJ0700E An error occurred during database connection: jdbc/SAMPLE.
   VGJ0005I The error occurred in TE01A.

出什么问题了？

生成的 EGL Java 代码使用 WebSphere 数据源来访问数据库。当我们在为 EGL 定义构建描述符时，我们指定了 jdbc/SAMPLE ，并且必须为 WebSphere 定义该 JNDI 名称。请注意很多与数据库相关的错误也可能是由 WebSphere 安全性问题（或糟糕的配置）所引起的。

尽管出现上述错误，但实际上 Struts 操作仍能正常工作，因为在这种情况下应用程序会返回一个无效的转发并正确地显示 error.jsp 页面。

7.1 定义 WebSphere 测试环境的数据源

根据 Sun JDBC 2.0 Standard Extension 规范中的定义，数据源允许您管理数据库的一个连接池。使用连接池能带给您下列好处：

• 它能提高性能。创建连接是非常消耗资源的；数据源会在自身被实例化后立即创建连接。
• 它能简化资源分配。这样就可以只在数据源中分配资源，而不是在代码中的任意地方。
• 相比较 JDBC 1.0 而言，它能简化连接调用。

数据源工作流程如下：

1. 当 servlet（或其他客户机）想要使用一个连接时，它会根据名称从 JNDI 服务器上查找一个数据源。
2. 然后，该数据源将一个连接返回给客户端。
3. 如果数据源没有多余的连接，它会向数据库管理器请求更多的连接（只要它没有超出最大连接数）。
4. 当客户端使用完连接之后，它就会关闭该连接。
5. 数据源随后将这个连接返回至可用池。

要定义数据源：

1. 在 Server Perspective 中，如果服务器在运行就停止它。
2. 在 Server Configuration 视图中，展开 Server Configurations文件夹，然后双击 WebSphere v5.0 Test Environment。
3. 选择编辑器底部的 Data Source标签。
4. 在“Data sources”对话框中，选择 Default DB2 JDBC provider。
5. 在“Data source defined”表中，选择 Add...旁的 JDBC provider list。
6. 在“Create a Data Source - Select the type...”对话框中，将数据源类型的值设置为： Version 5.0，然后选择 Next。
7. 在“Modify Data Source - Edit the settings...”对话框中，输入下列值：
   • Name： sample
   • JNDI 名称： jdbc/SAMPLE
   选择 Next。
8. 在“Create a Data Source - Edit the resource properties...”对话框中，输入下列值：
   • Name（在 Resource Properties 表中），选择 databaseName
   • Value： SAMPLE
   选择 Finish。您所作的改变应如图 37 所示。

要再次运行应用程序，只要选择 EGLWeb/Web Content => index.jsp => Run on Server。在 Userid 中输入 30 ，然后选择 Submit。如果一切正常，您应该会看见如图 38 所示的内容。

如果您输入了一个数据库中不存在的用户标识（比如 31 ），您就应该看到如图 39 所示的内容。

该程序可以被自然地扩展为显示适当的错误消息，我们在下一步将解释它。

7.2 扩展应用程序：使用应用程序资源属性文件

Struts 应用程序可以有选择地使用一个属性文件以保存文本。它允许您不必改变任何 Java 或 JSP 代码就能将改变应用到错误消息、按钮、标题、链接或其他任何文本字段上。它还可以使您轻松地将消息翻译为其他语言。向导会创建 ApplicationResources.properties 属性文件（如果您需要，可以在“Struts Settings”对话框中改变名称和包）。缺省情况下，向导会将文件放在指定的 Java 源包中，即放在 WEB-INF/classes 子目录中。

1. 编辑并改变 EGLWeb/JavaSource/eglweb/resources/ApplicationResources.properties 文件，如图 40 所示。

1. 改变 JSP 文件中的硬编码文本并用 <bean:message key=--/> Strut 标记来替换它们，并包含每一条具体的消息。您可以通过使用源或执行 JSP => Insert Custom?=> /Web-INF/struts-bean.tld => message =>Insert一系列步骤来实现它。在完成这些改变后， EGLWeb/Web Content/index.jsp 、 error.jsp 和 result.jsp 文件如下面三幅图所示。
   图 41. 带 bean 的 index.jsp：消息标记
   
   
   图 42. 带 bean 的 error.jsp：消息标记
   
   
   图 43. 带 bean 的 result.jsp：消息标记
   
   
2. 再次执行测试。结果将是相同的。假设您想要将应用程序翻译为巴西葡萄牙语，现在的好处是您只需改变 EGLWeb/Java Source/eglweb/resources/ApplicationResources.properties 文件就可以了。改变的结果如图 44 和 45 所示。
   图 44. 翻译为巴西葡萄牙语
   
   
   图 45. 翻译示例
   
   

回页首

结束语

祝贺您！您没有编写一行 Java 代码，就实现了一个使用 servlet、JSP 和 Java 的简单应用程序，它的服务器端是