5. 附录

本文介绍了《Java 5 持久化实践》一文中所用工具的安装及基本使用方法。以下信息截至 2007 年 5 月。这些内容很快就会过时。届时，建议读者遵循类似但并非完全相同的操作步骤。本指南中的安装操作是在 Windows XP Professional 系统上进行的。

5.1. Java

我们将使用 Sun 公司提供的最新版 Java [http://www.sun.com]。可通过以下网址 [http://java.sun.com/javase/downloads/index.jsp] 进行下载：

运行下载文件中的JDK安装程序。默认情况下，Java将安装在[C:\Program Files\Java]目录下：

5.2. Eclipse

5.2.1. 基本安装

Eclipse 是一款集成开发环境（IDE），其官方网站地址为 [http://www.eclipse.org/]，可从 [http://www.eclipse.org/downloads/] 下载。下面，我们将下载 Eclipse 3.2.2：

下载 ZIP 文件后，将其解压到硬盘上的某个文件夹中：

我们将上述图中所示的 Eclipse 安装文件夹 [C:\devjava\eclipse 3.2.2\eclipse] 简称为 <eclipse>。[eclipse.exe] 是可执行文件，而 [eclipse.ini] 是其配置文件。让我们来看看它们的内容：

-vmargs
-Xms40m
-Xmx256m

在启动 Eclipse 时，请按以下方式使用这些参数：

eclipse.exe -vmargs -Xms40m -Xmx256m

这通过创建一个使用相同参数启动 Eclipse 的快捷方式，实现了与使用 .ini 文件相同的效果。下面我们来解释这些参数：

1. -vmargs：表示后续参数是针对将运行 Eclipse 的 Java 虚拟机（JVM）设置的。Eclipse 是一个 Java 应用程序。
2. -Xms40m：？
3. -Xmx256m：设置分配给运行 Eclipse 的 Java 虚拟机 (JVM) 的内存大小（单位为 MB）。如这里所示，默认大小为 256 MB。如果系统允许，建议设置为 512 MB。

这些参数将传递给运行 Eclipse 的 JVM。JVM 由 [java.exe] 或 [javaw.exe] 文件代表。该文件位于何处？实际上，它可以通过多种方式定位：

• 操作系统 PATH 环境变量中
• 位于 <JAVA_HOME>/jre/bin 文件夹中，其中 JAVA_HOME 是定义 JDK 根目录的系统变量。
• 作为参数传递给 Eclipse 的位置，格式为 -vm <路径>\javaw.exe

最后一种方案更为可取，因为前两种方案容易受到后续应用程序安装的影响，这些安装可能会更改操作系统 PATH 或 JAVA_HOME 变量。

因此，我们创建以下快捷方式：

目标	<eclipse>\eclipse.exe" -vm "C:\Program Files\Java\jre1.6.0_01\bin\javaw.exe" -vmargs -Xms40m -Xmx512m
启动方式	Eclipse 安装文件夹 <eclipse>

完成上述操作后，使用此快捷方式启动 Eclipse。此时将弹出一个对话框：

[工作区] 即工作区。我们接受提供的默认值。默认情况下，Eclipse 项目将创建在此对话框中指定的 <工作区> 文件夹内。有一种方法可以覆盖此行为。这正是我们将系统地进行的操作。因此，在此对话框中给出的响应并不重要。

完成此步骤后，将显示 Eclipse 开发环境：

我们按照上述建议关闭 [欢迎] 视图：

在创建 Java 项目之前，我们将配置 Eclipse 以指定用于编译 Java 项目的 JDK。为此，我们选择 [窗口 / 首选项 / Java / 已安装的 JRE] 选项：

通常，用于启动 Eclipse 本身的 JRE（Java 运行时环境）应出现在 JRE 列表中。这通常是列表中唯一的条目。您可以通过 [添加] 按钮添加 JRE。随后必须指定该 JRE 的根目录。 点击 [搜索] 按钮将启动对磁盘上 JRE 的搜索。这是跟踪已安装 JRE 的好方法，以免在升级到新版本时忘记卸载旧版本。上图中，被选中的 JRE 就是将用于编译和运行 Java 项目的那个。这是在第 5.1 节中安装的，也是用于启动 Eclipse 的那个。双击它可打开其属性：

现在，让我们创建一个 Java 项目 [文件 / 新建 / 项目]：

选择 [Java 项目]，然后 [下一步] ->

在 [2] 中，我们指定一个空文件夹作为 Java 项目的安装位置。在 [1] 中，我们为项目命名。项目名称不必与文件夹名称一致，尽管上例可能暗示了这一点。完成上述操作后，我们点击 [下一步] 按钮进入创建向导的下一页：

在上图中，我们在项目内创建了一个专用文件夹，用于存放源文件（.java）：

• 在[1]中，我们可以看到[src]文件夹，该文件夹将存放.java源文件
• 在 [2] 中，我们可以看到 [bin] 文件夹，编译后的 .class 文件将存储在此处

点击 [完成] 即可完成向导。现在我们已经拥有了一个 Java 项目骨架：

右键单击 [test1] 项目以创建一个 Java 类：

1. 在 [1] 中，选择将创建该类的文件夹。默认情况下，Eclipse 会建议使用当前项目文件夹。
2. 在 [2] 中，指定类将被放置的包
3. 在 [3] 中，输入类名
4. 在 [4] 中，我们指定应生成静态方法 [main]

点击 [完成] 确认向导。随后，项目中将生成一个类：

Eclipse 已生成该类的骨架。可通过双击上方的 [Test1.java] 进行访问：

我们将上述代码修改如下：

运行 [Test1.java] 程序：[右键单击 Test1.java -> 运行作为 -> Java 应用程序]

执行结果显示在 [控制台] 窗口中：

[控制台]窗口默认应已显示。如果未显示，您可以通过[窗口/显示视图/控制台]将其显示出来：

5.2.2. 选择编译器

Eclipse 允许您生成与 Java 1.4、Java 1.5 和 Java 1.6 兼容的代码。默认情况下，它配置为生成与 Java 1.4 兼容的代码。JPA API 要求使用 Java 1.5 代码。我们可以通过 [窗口 / 首选项 / Java / 编译器] 更改生成的代码类型：

• 在 [1] 中：选择 [Java / 编译器] 选项
• 在 [2] 中：选择 Java 5.0 兼容性

5.2.3. 安装 Callisto s

上述安装的基础版本允许您构建 Java 控制台应用程序，但不支持 Web 或 Swing 类型的 Java 应用程序；否则，您必须自行完成所有操作。我们将安装各种插件：

请按以下步骤操作 [帮助/软件更新/查找并安装]：

• 在 [2] 中，指定要安装新插件

• 在 [3] 中，指定要搜索插件的站点
• 在 [4] 中，勾选所需的插件

• 在 [5] 中，Eclipse 提示您所选的插件依赖于其他尚未选中的插件
• 在 [6] 中，使用 [选择必需项] 按钮自动选择缺失的插件
• 在 [7] 中，接受这些不同插件的许可条款

• 在 [8] 中，您将看到即将安装的所有插件列表
• 在 [9] 中，开始下载这些插件
• 在 [10] 中，下载完成后，请在不验证签名的情况下安装所有插件

• 在[11]中，安装插件后，请重启Eclipse
• 在[12]中，若前往[文件/新建/项目]，你会发现现在可以创建Web应用程序了，而最初这是无法做到的。

5.2.4. 安装 [ TestNG] 插件

TestNG（Test Next Generation）是一款单元测试工具，其概念与 JUnit 相似。不过，它提供了一些改进功能，因此在此我们更倾向于使用它而非 JUnit。操作步骤与之前相同：[帮助/软件更新/查找并安装]：

• 在 [2] 中，我们指定要安装新插件

• 在[3a]中，[TestNG]的下载站点未被列出。我们通过[3b]将其添加
• 在 [4b] 中：该插件的网站是 [http://beust.com/eclipse]。在 [4a] 中，输入任意内容。

• 在 [5a] 中，已选择 [TestNG] 插件进行更新。在 [5b] 中，我们开始更新。
• 在 [6] 中，已成功连接到插件网站。页面显示了该网站上所有可用的插件。此处仅有一个插件，我们选中它后继续进行下一步。

• 在[7]中，接受插件的许可条款
• 在[8]中，我们会看到即将安装的所有插件列表——本例中仅有一个。我们开始下载。随后，后续步骤与上述Callisto插件的安装流程相同。

Eclipse 重启后，我们可以验证新插件是否已安装，例如通过查看可用视图 [窗口 / 显示视图 / 其他]：

如上所示，现在出现了一个之前不存在的 [TestNG] 视图。

5.2.5. 安装 [ Hibernate Tools] 插件

Hibernate 是一个 JPA 提供商，而 Eclipse 的 [Hibernate Tools] 插件对于构建 JPA 应用程序非常有用。截至 2007 年 5 月，只有其最新版本（3.2.0beta9）支持 Hibernate/JPA，且无法通过上述方法获取。目前仅提供旧版本。因此，我们将采取不同的安装方式。

该插件可在 Hibernate Tools 网站上获取：http://tools.hibernate.org/。

• 在 [1] 中，选择 Hibernate Tools 的最新版本
• 在 [2] 中，下载它

• 在 [3] 中，使用解压工具将下载的 ZIP 文件解压到 <eclipse> 文件夹中（最好先关闭 Eclipse）
• 在 [4] 中，确认操作过程中部分文件将被覆盖

重新启动 Eclipse：

• 在 [1] 中：打开一个视图
• 在 [2] 中：现在有一个 [Hibernate Console] 视图

我们不再继续使用 [Hibernate Tools] 插件（在 [2] 中点击“取消”）。其使用方法已在教程示例中进行说明。

有时 Eclipse 无法检测到新插件。您可以使用 -clean 选项强制其重新扫描所有插件。因此，Eclipse 快捷方式的可执行文件将修改如下：

"<eclipse>\eclipse.exe" -clean -vm "C:\Program Files\Java\jre1.6.0_01\bin\javaw.exe" -vmargs -Xms40m -Xmx512m

一旦 Eclipse 检测到新插件，请删除上方的 -clean 选项。

5.2.6. 安装 [ SQL Explorer] 插件

接下来我们将安装一个插件，它能让我们直接在 Eclipse 中浏览数据库的内容。Eclipse 可用的插件可在网站 [http://eclipse-plugins.2y.net/eclipse/plugins.jsp] 上找到：

• 在 [1]：Eclipse 插件网站
• 在 [2]：选择 [数据库] 类别
• [3]：在 [数据库] 类别中，选择按评分排序的视图（鉴于投票人数较少，该排序结果可能不太可靠）
• 在 [4] 中：QuantumDB 排名第一
• 在 [5]：我们选择 SQLExplorer，虽然它版本较旧、排名较低（第 3 名），但依然非常出色。我们前往该插件的网站 [plugin-homepage]

• 在 [6] 和 [7] 中：下载该插件。

• 在 [8] 中：将插件的 zip 文件解压到 Eclipse 文件夹中。

为验证安装是否成功，请重启 Eclipse，可选地使用 -clean 选项：

• 在 [1] 中：打开一个新的视图
• 在 [2] 中：我们可以看到 [SQL Explorer] 视图已可用。我们稍后会再回到这一点。

5.3. Tomcat 5.5 Servlet 容器

5.3.1. 安装

要运行 Servlet，我们需要一个 Servlet 容器。这里介绍其中之一——Tomcat 5.5，可从 http://tomcat.apache.org/ 下载。我们将概述其安装步骤（2007 年 5 月版）。如果系统中已安装了 Tomcat 的旧版本，最好先将其卸载。

要下载该产品，请点击上方的 [Tomcat 5.x] 链接：

您可以下载适用于 Windows 平台的 .exe 文件。下载完成后，双击该文件启动 Tomcat 安装程序：

接受许可条款 ->

点击 [下一步] ->

接受建议的安装文件夹，或使用 [浏览] 进行更改 ->

设置 Tomcat 服务器管理员的登录名和密码。此处我们使用 [admin / admin] ->

Tomcat 5.x 需要 JRE 1.5。通常它会自动检测到您机器上已安装的 JRE。上图中指定的路径是第 5.1 节中下载的 JRE 1.6 的路径。如果未找到 JRE，请使用 [1] 按钮指定其根目录。完成上述操作后，点击 [安装] 按钮安装 Tomcat 5.x ->

点击 [完成] 按钮即可完成安装。Windows 任务栏右侧会出现一个图标，表示 Tomcat 已安装：

右键单击此图标可访问“启动”和“停止”服务器命令：

现在，我们使用 [停止服务] 选项来停止 Web 服务器：

请注意图标状态的变化。该图标可从任务栏中移除：

Tomcat 已安装在用户选择的文件夹中，我们将其称为 <tomcat>。下载的 Tomcat 5.5.23 版本的目录结构如下：

Tomcat 安装程序已在 [开始] 菜单中添加了多个快捷方式。我们使用下方的 [监视] 链接来启动 Tomcat 停止/启动工具：

随后，我们将看到之前展示的图标：

双击此图标即可启动 Tomcat 监控程序：

通过 [启动 - 停止 - 暂停] - 重启 按钮，我们可以启动、停止和重启服务器。点击 [启动] 即可启动服务器，随后使用浏览器输入 URL http://localhost:8080。此时应会看到类似以下内容的页面：

您可以点击以下链接，验证 Tomcat 是否已正确安装：

[http://localhost:8080] 页面上的所有链接都值得探索，我们鼓励读者亲自尝试。我们稍后将有机会重新回顾那些用于管理服务器上部署的 Web 应用程序的链接：

5.3.2. 在 Tomcat 服务器上部署 Web 应用程序

5.3.3. 部署

Web 应用程序必须遵循特定规则才能部署在 Servlet 容器中。设 <webapp> 为 Web 应用程序的目录。一个 Web 应用程序由以下部分组成：

类	位于 <webapp>\WEB-INF\classes 文件夹中的
Java归档文件	位于 <webapp>\WEB-INF\lib 文件夹中
视图、资源（.jsp、.html 等）	位于 <webapp> 文件夹或其子文件夹中

Web 应用程序通过一个 XML 文件进行配置：<webapp>\WEB-INF\web.xml。在简单的情况下，特别是当 Web 应用程序仅包含静态文件时，该文件并非必需。让我们创建以下 HTML 文件：

<html>
    <head>
      <title>Application exemple</title>
  </head>
  <body>
      Application exemple active ....
  </body>
</html>

然后将其保存到一个文件夹中：

如果我们在浏览器中加载此文件，将看到以下页面：

浏览器显示的 URL 表明该页面并非由 Web 服务器提供，而是由浏览器直接加载的。现在，我们希望通过 Tomcat Web 服务器提供该页面。

让我们回到 <tomcat> 目录树：

部署在 Tomcat 服务器上的 Web 应用程序，其配置通过位于 [<tomcat>\conf\Catalina\localhost] 文件夹中的 XML 文件进行设置：

由于这些 XML 文件的结构简单，可以手动创建。但我们不会采用这种方法，而是使用 Tomcat 提供的 Web 工具。

5.3.4. Tomcat 管理

在登录页面 http://localhost:8080 上，服务器提供了管理链接：

[Tomcat 管理] 链接允许我们配置 Tomcat 向其内部部署的 Web 应用程序提供的资源，例如数据库连接池。让我们点击该链接：

显示的页面提示，管理 Tomcat 5.x 需要一个名为“admin”的特定软件包。让我们返回 Tomcat 网站 [http://tomcat.apache.org/download-55.cgi]：

现在下载标有 [Web Application Administration] 的 zip 文件，然后解压。其内容如下：

必须将 [admin] 文件夹复制到 [<tomcat>\server\webapps] 目录下，其中 <tomcat> 是 Tomcat 5.x 的安装目录：

[localhost] 文件夹中包含一个 [admin.xml] 文件，必须将其复制到 [<tomcat>\conf\Catalina\localhost]：

如果 Tomcat 正在运行，请先停止服务，然后重启。随后，使用浏览器再次访问 Web 服务器的登录页面：

点击 [Tomcat Administration] 链接。您将看到登录页面（可能需要重新加载或刷新页面才能看到）：

在此处，您必须重新输入在 Tomcat 安装过程中提供的凭据。在本例中，我们将用户名和密码均输入为“admin”。点击 [登录] 按钮后，您将进入以下页面：

此页面允许 Tomcat 管理员定义

• 数据源、
• 发送电子邮件所需的信息（邮件会话），
• 所有应用程序均可访问的环境数据（环境条目），
• 管理 Tomcat 用户和管理员（用户），
• 管理用户组（Groups），
• 定义角色（即用户可以做什么和不能做什么），
• 定义由服务器（Catalina 服务）部署的 Web 应用程序的特性

让我们点击上方的 [角色] 链接：

角色允许您定义用户或用户组可以执行或不能执行的操作。某些权限与角色相关联。每个用户都关联一个或多个角色，并拥有与之相关的权限。下面的 [manager] 角色授予管理部署在 Tomcat 中的 Web 应用程序的权限（部署、启动、关闭、卸载）。 我们将创建一个 [manager] 用户，并将其与 [manager] 角色关联，以便其管理 Tomcat 应用程序。为此，我们点击管理页面上的 [Users] 链接：

我们可以看到已有若干用户。我们使用 [创建新用户] 选项来创建新用户：

我们将用户名设为 manager，密码设为 manager，并为其分配 manager 角色。点击 [保存] 按钮确认此操作。新用户将出现在用户列表中：

该新用户将被添加到文件 [<tomcat>\conf\tomcat-users.xml] 中：

其内容如下：

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="tomcat"/>
  <role rolename="role1"/>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="tomcat" password="tomcat" roles="tomcat"/>
  <user username="role1" password="tomcat" roles="role1"/>
  <user username="both" password="tomcat" roles="tomcat,role1"/>
  <user username="manager" password="manager" fullName="" roles="manager"/>
  <user username="admin" password="admin" roles="admin,manager"/>
</tomcat-users>

• 第 10 行：已创建的 [manager] 用户

另一种添加用户的方法是直接编辑此文件。例如，如果您忘记了 admin 或 manager 账户的密码，请按照以下步骤操作。

5.3.5. 管理已部署的 Web 应用程序

现在让我们返回登录页面 [http://localhost:8080]，并点击 [Tomcat Manager] 链接：

这将打开一个身份验证页面。我们使用 manager / manager 登录，即使用我们刚刚创建的具有 [manager] 角色的用户。实际上，只有具有此角色的用户才能使用此链接。在 [tomcat-users.xml] 的第 11 行，我们可以看到用户 [admin] 也具有 [manager] 角色。因此，我们也可以使用 [admin / admin] 的凭据。

随后将跳转至一个页面，列出了当前部署在 Tomcat 中的应用程序：

我们可以使用页面底部的表单添加一个新应用程序：

在此，我们希望将之前构建的示例应用程序部署到 Tomcat 中。具体操作如下：

上下文路径	/example	用于标识待部署 Web 应用程序的名称 的名称
目录 URL	C:\data\work\2006-2007\eclipse\dvp-jpa\annexes\tomcat\example	Web 应用程序文件夹

要获取文件 [C:\data\work\2006-2007\eclipse\dvp-jpa\annexes\tomcat\example\example.html]，我们将向 Tomcat 请求 URL [http://localhost:8080/exemple/exemple.html]。上下文（context）用于命名已部署 Web 应用程序目录树的根目录。 我们使用 [部署] 按钮来部署应用程序。如果一切顺利，我们将看到以下响应页面：

新应用程序将出现在已部署应用程序列表中：

让我们将上面的 /example 上下文行注释掉：

/example	链接至 http://localhost:8080/exemple
开始	允许您启动应用程序
停止	允许您停止应用程序
重新加载	重新加载应用程序。例如，当您在应用程序中添加、 修改或删除应用程序中的某些类时，此操作必不可少。
撤销部署	移除 [/example] 上下文。该应用程序将从 。

现在我们的 /example 应用程序已部署完成，我们可以进行一些测试。我们通过 URL [http://localhost:8080/exemple/vues/exemple.html] 请求 [example.html] 页面：

在 Tomcat 服务器上部署 Web 应用程序的另一种方法是，将通过 Web 界面输入的信息写入位于 [<tomcat>\conf\Catalina\localhost] 文件夹中的 [context].xml 文件中，其中 [context] 是 Web 应用程序的名称。

让我们回到 Tomcat 管理界面：

现在，我们通过 [Undeploy] 链接移除 [/example] 应用程序：

[/example] 应用程序已不再出现在活动应用程序列表中。现在，让我们定义以下 [example.xml] 文件：

<Context docBase="C:/data/travail/2006-2007/eclipse/dvp-jpa/annexes/tomcat/exemple">
</Context>

该 XML 文件由一个 <Context> 标签组成，其 docBase 属性定义了要部署的 Web 应用程序所在的文件夹。我们将此文件放置在 <tomcat>\conf\Catalina\localhost:

如有必要，请停止并重启 Tomcat，然后使用 Tomcat 管理员查看活动应用程序列表：

[/example] 应用程序确实存在。现在让我们在浏览器中访问该 URL：

[http://localhost:8080/exemple/exemple.html]:

以这种方式部署的 Web 应用程序可以像之前一样，通过 [Undeploy] 链接从已部署应用程序列表中移除：

此时，[example.xml] 文件将自动从 [<tomcat>\conf\Catalina\localhost] 文件夹中移除。

最后，要在 Tomcat 中部署 Web 应用程序，您还可以在 [<tomcat>\conf\server.xml] 文件中定义其上下文。本文将不对此进行详细说明。

5.3.6. 带有主页的 Web 应用程序

当我们请求 URL [http://localhost:8080/exemple/] 时，会得到以下响应：

在某些早期版本的 Tomcat 中，我们会收到应用程序物理目录 [/example] 中的内容。

我们可以配置系统，使其在请求该上下文时显示所谓的“主页”。为此，我们需要创建一个 [web.xml] 文件，并将其放置在 <example>\WEB-INF 文件夹中，其中 <example> 是 [/example] Web 应用程序的物理文件夹。该文件内容如下：

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">

  <display-name>Application Exemple</display-name>
  <description>Application web minimale</description>
    <welcome-file-list>
        <welcome-file>/exemple.html</welcome-file>
    </welcome-file-list>    
</web-app>

• 第 2–5 行：根 <web-app> 标签，其属性是从 Tomcat [/admin] 应用程序的 [web.xml] 文件（<tomcat>/server/webapps/admin/WEB-INF/web.xml）中复制并粘贴而来的。
• 第 7 行：Web 应用程序的显示名称。这是一个可自由选择的名称，其限制比应用程序上下文名称更少。例如，它可以包含空格，而上下文名称则不允许。该名称会在 Tomcat 管理界面等处显示：

1. 第 8 行：Web 应用程序的描述。该文本随后可通过编程方式获取。
2. 第 9–11 行：欢迎文件列表。<welcome-file-list> 标签用于定义当客户端请求应用程序上下文时要显示的视图列表。视图可以有多个。 系统会向客户端呈现第一个找到的视图。此处仅有一个视图：[/example.html]。因此，当客户端请求 URL [/example] 时，实际返回的 URL 将是 [/example/example.html]。

我们将此 [web.xml] 文件保存到 <example>\WEB-INF 目录下：

如果 Tomcat 仍在运行，您可以通过 [Reload] 链接强制其重新加载 [/example] Web 应用程序：

在此“重新加载”操作期间，如果 [<example>\WEB-INF] 目录中存在 [web.xml] 文件，Tomcat 会重新读取该文件。本例中即属于这种情况。如果 Tomcat 已停止运行，请重新启动它。

使用浏览器访问 URL [http://localhost:8080/exemple/]：

主机文件机制已生效。

5.3.7. 将 Tomcat 集成到 Eclipse 中

现在我们将把 Tomcat 集成到 Eclipse 中。通过此集成，您可以：

• 在 Eclipse 内部启动/停止 Tomcat
• 开发 Java Web 应用程序并在 Tomcat 上运行。通过 Eclipse 与 Tomcat 的集成，您可以跟踪（调试）应用程序的执行过程，包括由 Tomcat 运行的 Java 类（Servlet）的执行情况。

让我们启动 Eclipse，然后打开 [Servers] 视图：

• 在 [1] 中：窗口/显示视图/其他
• 在 [2] 中：选择 [服务器] 视图，然后单击 [确定]

• 在 [1] 中，现在我们有了一个新的 [服务器] 视图
• 在 [2] 中，右键单击该视图并选择 [新建/服务器]
• 在 [3] 中，选择 [Tomcat 5.5] 服务器，然后点击 [下一步]

• 在 [4] 中，指定 Tomcat 5.5 的安装目录
• 在 [5] 中，指出目前尚无 Eclipse/Tomcat 项目。点击 [完成]

添加服务器后，Eclipse 项目资源管理器 [6] 中会出现一个文件夹，且 [服务器] 视图 [7] 中会出现一个服务器：

[服务器]视图显示所有已注册的服务器；此处仅显示我们刚刚添加的Tomcat 5.5服务器。右键单击该服务器可访问用于启动、停止或重启服务器的命令：

上图中，我们正在启动服务器。启动时，[控制台]视图中会写入多条日志：

16 mai 2007 09:51:57 org.apache.catalina.core.AprLifecycleListener lifecycleEvent
...
16 mai 2007 09:51:57 org.apache.coyote.http11.Http11BaseProtocol init
INFO: Initialisation de Coyote HTTP/1.1 sur http-8080
...
INFO: Find registry server-registry.xml at classpath resource
16 mai 2007 09:51:58 org.apache.catalina.startup.Catalina start
INFO: Server startup in 828 ms

理解这些日志需要一些时间来适应。我们暂时不深入探讨它们。不过，重要的是要确认这些日志中没有出现任何上下文加载错误。实际上，在启动时，Tomcat/Eclipse 服务器会尝试加载其管理的应用程序的上下文。加载应用程序的上下文涉及处理其 [web.xml] 文件，并加载一个或多个用于初始化该上下文的类。可能会发生以下几种错误：

• [web.xml] 文件存在语法错误。这是最常见的错误。建议在创建 XML 文档时使用能够对其进行验证的工具。
• 某些待加载的类未被找到。系统会在 [WEB-INF/classes] 和 [WEB-INF/lib] 目录中搜索这些类。通常应验证必要类是否存在，并检查 [web.xml] 文件中声明的类名拼写是否正确。

从 Eclipse 启动的服务器配置与第 5.3 节中安装的配置不一致。要验证这一点，请使用浏览器访问 URL [http://localhost:8080]：

此响应并不表示服务器无法运行，而是表明所请求的资源 / 不可用。当 Tomcat 服务器集成到 Eclipse 中时，这些资源将作为 Web 项目存在。我们稍后会看到这一点。现在，让我们停止 Tomcat：

可以更改之前的运行模式。让我们返回 [Servers] 视图，双击 Tomcat 服务器以访问其属性：

复选框 [1] 负责上述行为。选中该复选框后，在 Eclipse 中开发的 Web 应用程序不会在关联的 Tomcat 服务器的配置文件中声明，而是声明在单独的配置文件中。因此，Tomcat 服务器中的默认应用程序——[admin] 和 [manager]（这两个非常实用的应用程序）——将不可用。因此，让我们取消选中 [1] 并重启 Tomcat：

完成上述操作后，请在浏览器中访问 URL [http://localhost:8080]：

我们可以看到第5.3.4节中描述的行为。

在之前的示例中，我们使用了 Eclipse 外部的浏览器。我们也可以使用 Eclipse 内置的浏览器：

上图中，我们选择了内置浏览器。要在 Eclipse 中启动它，可以使用以下图标：

实际启动的浏览器将是通过 [窗口 -> Web 浏览器] 选项所选定的浏览器。在此，我们将获得内置浏览器：

如有需要，请从 Eclipse 中启动 Tomcat，并在 [1] 中输入 URL [http://localhost:8080]：

点击 [Tomcat Manager] 链接：

系统将提示您输入访问 [manager] 应用程序所需的 [用户名/密码]。根据我们之前设置的 Tomcat 配置，您可以输入 [admin/admin] 或 [manager/manager]。随后您将看到已部署应用程序的列表：

5.4. 的 Firebird 数据库管理系统

5.4.1. Firebird 数据库管理系统

Firebird 数据库管理系统可通过以下网址获取 [http://www.firebirdsql.org/]：

• 在 [1] 中：使用 [下载 Firebird 关系型数据库] 选项
• 在 [2] 中：选择所需的 Firebird 版本
• 在 [3] 中：下载安装程序

文件 [3] 下载完成后，双击该文件以安装 Firebird 数据库管理系统。该数据库管理系统将安装在一个文件夹中，其内容大致如下：

二进制文件位于 [bin] 文件夹中：

fbguard.exe	允许您启动/停止数据库管理系统
isql.exe	用于管理数据库的命令行客户端

请注意，默认情况下，数据库管理系统管理员的用户名为 [SYSDBA]，密码为 [masterkey]。[开始] 菜单中已添加相关选项：

[Firebird Guardian] 选项允许您启动/停止 DBMS。启动后，DBMS 图标将保留在 Windows 任务栏中：

若要使用命令行客户端 [isql.exe] 创建和管理 Firebird 数据库，您必须阅读产品随附的文档，可通过 [开始/程序/Firebird 2.0] 中的 Firebird 快捷方式访问该文档。

使用图形化客户端是操作 Firebird 并学习 SQL 的快捷方式。其中一种客户端是 IB-Expert，下文将对此进行介绍。

5.4.2. 使用 IB- Expert 操作 Firebird 数据库管理系统

IB-Expert 的官方网站为 [http://www.ibexpert.com/]。

• 在[1]中，选择IBExpert
• 在 [2] 中，如需选择语言，请先选择所需语言，然后点击下载
• 在 [3] 中，选择“个人版”，因为它是免费的。不过，您必须在网站上注册。
• 在 [4] 中，下载 IBExpert

IBExpert将安装在类似于以下路径的文件夹中：

可执行文件为 [ibexpert.exe]。通常在 [开始] 菜单中会有一个快捷方式：

启动后，IBExpert 将显示以下窗口：

使用 [ 数据库/创建数据库] 选项来创建数据库：

服务器 (服务器)	可以是 [local] 或 [remote]。在此，我们的服务器与 [IBExpert] 位于同一台机器上。我们选择 [本地]
数据库 (数据库)	使用下拉菜单中的 [文件夹] 按钮选择数据库文件。Firebird 将整个 数据库存储在一个文件中。这是它的优势之一。 只需复制该文件，即可将数据库从一台计算机转移到另一台计算机。 系统会自动添加 [.fdb] 后缀。
用户名	SYSDBA 是当前 Firebird 发行版的默认管理员
密码 (用户名)	masterkey 是当前 Firebird 发行版中 SYSDBA 管理员的密码 当前 Firebird 发行版中
方言	要使用的 SQL 方言
注册数据库 (注册数据库)	如果勾选此框，IBExpert 将在数据库创建后显示一个链接

如果在点击 [确定] 按钮创建数据库时，您看到以下警告：

这意味着您尚未启动 Firebird。请启动它。随后将出现一个新窗口：

字符集 (字符集)

要使用的字符集。建议从下拉列表中选择 [ISO-8859-1]，该选项支持带重音的拉丁字符。

服务器版本 (服务器版本)

[IBExpert] 能够管理各种源自 Interbase 的数据库管理系统。 请选择您已安装的 Firebird 版本。

点击 [注册] 确认此新窗口后，您将在 [数据库资源管理器] 窗口中看到结果 [1]。此窗口可能会被意外关闭。要重新打开它，请执行以下操作 [2]：

要访问已创建的数据库，只需双击其链接。随后 IBExpert 将显示一个树形结构，供您访问数据库属性：

5.4.3. 创建数据表

现在我们来创建一个表。右键单击 [Tables]（参见上图），然后选择 [New Table] 选项。这将打开用于定义表属性的窗口：

首先，在输入字段 [1] 中将表命名为 [ARTICLES]：

使用输入字段 [2] 定义主键 [ID]：

双击 [PK]（主键）字段即可将其设为主键。现在，让我们使用上方按钮 [3] 添加字段：

在“编译”定义之前，表不会被创建。请使用上方的 [编译] 按钮来完成表的定义。IBExpert 会准备用于生成表的 SQL 查询，并请求确认：

值得注意的是，IBExpert 会显示已执行的 SQL 查询。这使您既能学习 SQL 语言，也能了解可能使用的任何专有 SQL 方言。[提交] 按钮用于确认当前事务，而 [回滚] 则用于取消事务。在此，我们点击 [提交] 进行确认。操作完成后，IBExpert 会将创建的表添加到数据库树中：

双击该表，即可访问其属性：

通过 [约束] 面板，我们可以为表添加新的完整性约束。让我们打开它：

我们可以看到之前创建的主键约束。现在可以添加其他约束：

• 外键 [Foreign Keys]
• 字段完整性约束 [检查]
• 字段唯一性约束 [Uniques]

让我们指定如下：

• 字段 [ID, PRICE, CURRENTSTOCK, MINIMUMSTOCK] 必须大于 0
• [NAME] 字段必须不为空且唯一

打开 [检查] 面板，在约束定义区域中右键单击以添加新约束：

让我们定义所需的约束条件：

请注意，上述约束 [NAME<>''] 使用的是两个单引号，而非双引号。使用上方的 [编译] 按钮编译这些约束：

IBExpert 再次通过显示已执行的 SQL 查询，展现了其用户友好性。现在让我们转到 [Constraints/Unique] 面板，指定名称必须是唯一的。这意味着同一名称不能在表中出现两次。

让我们定义该约束：

然后进行编译。完成后，打开 [ARTICLES] 表的 [DDL]（数据定义语言）面板：

该面板会显示用于生成包含所有约束条件的表的 SQL 代码。您可以将此代码保存到脚本中以便日后运行：

SET SQL DIALECT 3;
SET NAMES ISO8859_1;
CREATE TABLE ARTICLES (
    ID            INTEGER NOT NULL,
    NOM           VARCHAR(20) NOT NULL,
    PRIX          DOUBLE PRECISION NOT NULL,
    STOCKACTUEL   INTEGER NOT NULL,
    STOCKMINIMUM  INTEGER NOT NULL
);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_ID check (ID>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_PRIX check (PRIX>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKACTUEL check (STOCKACTUEL>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKMINIMUM check (STOCKMINIMUM>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_NOM check (NOM<>'');
ALTER TABLE ARTICLES ADD CONSTRAINT UNQ_NOM UNIQUE (NOM);
ALTER TABLE ARTICLES ADD CONSTRAINT PK_ARTICLES PRIMARY KEY (ID);

5.4.4. 向表中插入数据

现在是向 [ARTICLES] 表中输入数据的时候了。为此，请使用其 [数据] 面板：

通过双击表中各行的输入字段即可输入数据。使用 [+] 按钮可添加新行，使用 [-] 按钮可删除行。这些操作都在一个事务中进行，需通过 [提交事务] 按钮提交（参见上文）。如果不提交，数据将会丢失。

5.4.5. [IB-Expert] SQL 编辑器

SQL（结构化查询语言）允许用户：

1. 通过指定表将存储的数据类型以及数据必须满足的约束条件来创建表
2. 向表中插入数据
3. 修改特定数据
4. 删除其他数据
5. 利用数据检索信息
6. ……

IBExpert 允许用户以图形化方式执行步骤 1 至 4。我们刚才已经看到了这一点。当数据库包含许多表，且每张表都有数百行数据时，您需要一些难以通过视觉方式获取的信息。例如，假设一家网店每月有数千名客户。 所有购买记录都保存在数据库中。六个月后，发现产品“X”存在质量问题。公司希望联系所有购买该产品的客户，以便他们退货并免费换货。如何找到这些买家的地址？

1. 你可以手动遍历所有表并搜索这些买家，但这可能需要数小时。
2. 我们可以通过运行一条SQL查询，在几秒钟内获取这些人的名单

无论何时

• 当表中的数据量较大时
• 当多个表相互关联时
• 需要检索的信息分散在多个表中
• ……

接下来我们将介绍 IBExpert 的 SQL 编辑器。您可以通过 [工具/SQL 编辑器] 选项或按 [F12] 键访问它：

这将打开一个高级 SQL 查询编辑器，您可以在其中运行查询。让我们输入一个查询：

使用上方的 [执行] 按钮执行该 SQL 查询。您将获得以下结果：

上方的[结果]选项卡显示了[选择] SQL 命令的结果表。若要执行新的 SQL 命令，只需返回[编辑]选项卡。随后您将看到已执行的 SQL 命令。

工具栏上有几个有用的按钮：

• [新建查询] 按钮可让您进入新的 SQL 查询：

随后您将看到一个空白编辑页面：

随后您可以输入新的 SQL 查询：

并执行它：

让我们回到 [编辑] 选项卡。已执行的各种 SQL 语句均由 [IBExpert] 保存。通过 [上一个查询] 按钮，您可以返回之前执行的 SQL 语句：

随后您将返回上一个查询：

点击 [下一条查询] 按钮，即可跳转到下一条 SQL 语句：

随后，您将在存储的 SQL 语句列表中看到下一条 SQL 语句：

[删除查询] 按钮可让您从已存储语句列表中删除一个 SQL 语句：

[清除当前查询] 按钮可清除所显示 SQL 语句编辑器中的内容：

[提交] 按钮允许您将对数据库所做的更改永久保存：

[回滚] 按钮可让您撤销自上次 [提交] 以来对数据库所做的更改。如果自连接数据库以来尚未执行过 [提交]，则自该连接以来所做的更改将被撤销。

让我们看一个示例。现在向表中插入一行：

SQL 语句已执行，但未显示任何结果。我们无法确定插入操作是否成功。为确认结果，请执行以下 SQL 语句 [New Query]：

我们得到以下结果：

该行确实已被插入。现在让我们通过另一种方式查看表的内容。在数据库资源管理器中双击 [ARTICLES] 表：

我们得到如下表格：

上方的箭头按钮可用于刷新表格。刷新后，上方的表格并未发生变化。看起来新行并未被插入。让我们返回 SQL 编辑器（F12），然后使用 [提交] 按钮确认该 SQL 语句：

完成此操作后，让我们返回 [ARTICLES] 表。我们可以看到，即使使用 [刷新] 按钮，也没有任何变化：

在上方打开 [字段] 选项卡，然后返回 [数据] 选项卡。这次，插入的行已正确显示：

当开始执行各种 SQL 语句时，编辑器会在数据库上开启一个所谓的“事务”。这些 SQL 语句在 SQL 编辑器中做出的更改，只有在你保持在同一个 SQL 编辑器中时才会可见（你可以打开多个编辑器）。 这仿佛 SQL 编辑器并非在实际数据库上操作，而是在其自身的副本上操作。实际上，其工作原理并非完全如此，但这个类比有助于我们理解事务的概念。事务期间对副本所做的所有更改，只有在通过 [提交事务] 进行提交后，才会显示在实际数据库中。随后当前事务终止，并开始一个新事务。

事务期间所做的更改可以通过名为 [Rollback] 的操作撤销。让我们尝试以下实验。使用以下 SQL 语句开始一个新事务（只需对当前事务执行 [Commit] 即可）：

让我们执行这条命令，它将删除 [ARTICLES] 表中的所有行，然后执行 [New Query] 并输入以下新的 SQL 命令：

我们得到以下结果：

所有行均已被删除。请注意，此操作是在 [ARTICLES] 表的副本上执行的。要验证这一点，请双击下方的 [ARTICLES] 表：

并查看 [数据] 选项卡：

即使我们点击[刷新]按钮，或切换到[字段]选项卡后再返回[数据]选项卡，上面的内容依然保持不变。这已经解释过了。我们现在处于另一个事务中，该事务正在处理其自身的副本。现在让我们返回SQL编辑器（F12），并使用[回滚]按钮撤销之前执行的行删除操作：

系统会要求我们确认：

让我们确认一下。SQL 编辑器确认更改已被回滚：

让我们再次运行上面的 SQL 查询进行验证。之前被删除的行现在已经恢复：

[回滚]操作将SQL编辑器正在处理的副本恢复到了事务开始时的状态。

5.4.6. 将 Firebird 数据库导出为 SQL 脚本

在处理各种数据库管理系统（DBMS）时，例如在教程《Java 5 持久化实践》中所述，能够将数据库从 DBMS 1 导出为 SQL 脚本，然后将该脚本导入到 DBMS 2 中，会非常有用。这可以避免许多手动操作。然而，这并非总是可行，因为数据库管理系统通常具有专有的 SQL 扩展。

下面我们将演示如何将前面的 [dbarticles] 数据库导出为 SQL 脚本：

• 在 [1] 中：选择“工具 / 提取元数据”，以提取元数据
• 在 [2] 中：元对象选项卡
• 在 [3] 中：选择您想要提取其结构（元数据）的 [Articles] 表
• 在 [4]：将左侧选中的对象移至右侧

• 在 [5] 中：[ARTICLES] 表将被包含在提取的元数据中
• 在 [6] 中：[数据表] 选项卡用于选择要从中提取内容的表（在上一步中，导出的是表结构）
• 在 [7] 中：将左侧选中的对象移至右侧
• 在 [8] 中：获得的结果

• 在 [9] 中：[选项] 选项卡允许您配置某些提取设置
• 在 [10] 中：取消勾选与生成连接数据库的 SQL 语句相关的选项。这些选项仅适用于 Firebird，因此与我们无关。
• 在 [11] 中：[输出] 选项卡允许您指定 SQL 脚本的生成位置
• 在 [12] 中：指定脚本应生成到文件中
• 在 [13] 中：指定该文件的位置
• 在 [14] 中：开始生成 SQL 脚本

移除注释后的生成的脚本如下：

SET SQL DIALECT 3;
SET NAMES ISO8859_1;

CREATE TABLE ARTICLES (
    ID            INTEGER NOT NULL,
    NOM           VARCHAR(20) NOT NULL,
    PRIX          DOUBLE PRECISION NOT NULL,
    STOCKACTUEL   INTEGER NOT NULL,
    STOCKMINIMUM  INTEGER NOT NULL
);

INSERT INTO ARTICLES (ID, NOM, PRIX, STOCKACTUEL, STOCKMINIMUM) VALUES (1, 'article1', 100, 10, 1);
INSERT INTO ARTICLES (ID, NOM, PRIX, STOCKACTUEL, STOCKMINIMUM) VALUES (2, 'article2', 200, 20, 2);
INSERT INTO ARTICLES (ID, NOM, PRIX, STOCKACTUEL, STOCKMINIMUM) VALUES (3, 'article3', 300, 30, 3);

COMMIT WORK;

ALTER TABLE ARTICLES ADD CONSTRAINT CHK_ID check (ID>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_PRIX check (PRIX>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKACTUEL check (STOCKACTUEL>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_STOCKMINIMUM check (STOCKMINIMUM>0);
ALTER TABLE ARTICLES ADD CONSTRAINT CHK_NOM check (NOM<>'');
ALTER TABLE ARTICLES ADD CONSTRAINT UNQ_NOM UNIQUE (NOM);
ALTER TABLE ARTICLES ADD CONSTRAINT PK_ARTICLES PRIMARY KEY (ID);

注意：第 1-2 行是 Firebird 特有的。必须从生成的脚本中删除这些行，才能获得通用的 SQL 语句。

5.4.7. Firebird JDBC 驱动程序

Java 程序通过针对所用数据库管理系统（DBMS）的专用 JDBC 驱动程序访问数据库中的数据：

在如上所述的多层架构中，[DAO]（数据访问对象）层使用 JDBC 驱动程序 [1] 从数据库中访问数据。

Firebird JDBC 驱动程序可在下载 Firebird 的网址处获取：

• 在 [1] 中：选择下载 JDBC 驱动程序
• 在 [2] 中：选择一个与 JDK 1.5 兼容的 JDBC 驱动程序
• 在 [3] 中：包含 JDBC 驱动程序的压缩包为 [jaybird-full-2.1.1.jar]。请解压此文件。该文件将用于所有基于 Firebird 的 JPA 示例。

我们将它放置在一个名为 <jdbc> 的文件夹中：

为了验证此 JDBC 驱动程序，我们将使用 Eclipse 及其 SQL Explorer 插件（第 5.2.6 节）。首先声明 Firebird JDBC 驱动程序：

• 在 [1] 中：转到“窗口”/“首选项”
• 在 [2]：选择“SQL Explorer / JDBC 驱动程序”选项
• 在 [3] 中：选择 Firebird 的 JDBC 驱动程序
• 在 [4] 中：进入配置阶段
• 在 [5] 中：转到 [额外类路径] 选项卡
• 在 [6] 中，选择 JDBC 驱动程序文件。选择后，它将出现在 [7] 中。在此处，选择之前放置在 <jdbc> 文件夹中的驱动程序
• 在 [8] 中：输入 JDBC 驱动程序的 Java 类名。可通过点击 [8b] 按钮获取该信息。
• 点击 [确定] 确认配置

• 在 [9] 中：Firebird JDBC 驱动程序现已配置完成。您可以开始使用它。

• 在 [1] 中：打开一个新的视图
• 在 [2] 中：选择 [SQL Explorer] 视图

• 在 [3] 中：创建一个新连接
• 步骤 [4]：为其命名
• 在 [5] 中：从下拉列表中选择 Firebird JDBC 驱动程序
• 在 [6] 中：指定要连接的数据库的 URL，此处为：[jdbc:firebirdsql:localhost/3050:C:\data\2006-2007\eclipse\dvp-jpa\annexes\jpa\jpa.fdb]。[jpa.fdb] 是之前使用 IBExpert 创建的数据库。
• 在 [7] 中：输入连接用户名，本例中为 [sysdba]，即 Firebird 管理员
• 在 [8] 中：输入密码 [masterkey]
• 点击 [OK] 确认连接设置

• 在 [1] 中：双击您要打开的连接名称
• 在 [2] 中：登录（sysdba, masterkey）
• 在 [3] 中：连接已建立
• 在 [4] 中：显示数据库结构。[ARTICLES] 表可见。请选中它。

• 在 [5] 中：在 [数据库详细信息] 窗口中，您将看到在 [4] 中所选对象的详细信息，本例中即 [ARTICLES] 表
• 在 [6] 中：[列] 选项卡显示了表结构
• 在 [7] 中：[预览] 选项卡显示了表结构

您可以在 [SQL 编辑器] 窗口中运行 SQL 查询：

• 在 [1] 中：选择一个已打开的连接
• 在 [2] 中：输入要执行的 SQL 语句
• 在 [3] 中：执行该语句
• 在 [4] 中：查看已执行的语句
• 在 [5] 中：查看其结果

5.5. 数据库管理系统（DBMS） 的MySQL5

5.5.1. 安装

MySQL5 数据库管理系统可在以下网址获取 [http://dev.mysql.com/downloads/]：

• 在 [1] 中：选择所需版本
• 在 [2] 中：选择 Windows 版本

• 在 [3] 中：选择所需的 Windows 版本
• 在 [4] 中：下载的 ZIP 文件包含一个可执行文件 [Setup.exe] [4b]，您必须将其解压并运行以安装 MySQL5

• 在 [5] 中：选择“典型安装”
• 在 [6] 中：安装完成后，您可以配置 MySQL5 服务器

• 在 [7] 中：选择标准配置，即提问最少的那个
• 在 [8] 中：MySQL5 服务器将作为 Windows 服务运行

• 在 [9] 中：默认情况下，服务器管理员为 root，且无密码。您可以保留此配置，或为 root 设置新密码。如果本次 MySQL5 安装是在卸载旧版本之后进行的，此步骤可能会失败。且无法撤销此操作。
• 在 [10]：系统将提示您配置服务器

MySQL5 的安装会在 [开始 / 程序] 中创建一个文件夹：

您可以使用 [MySQL 服务器实例配置向导] 来重新配置服务器：

• 在 [3] 中：我们将 root 密码更改为（此处为 root/root）

5.5.2. 启动/停止 MySQL5

MySQL5 服务器被安装为 Windows 服务，会自动启动，即在 Windows 启动时运行。这种运行模式并不实用。我们将进行更改：

[开始 / 控制面板 / 性能和维护 / 管理工具 / 服务]：

• 在 [1] 中：双击 [服务]
• 在 [2] 中：我们可以看到有一个名为 [MySQL] 的服务，该服务正在运行 [3]，并且设置为自动启动 [4]。

要更改此设置，请双击 [MySQL] 服务：

• 在 [1] 中：将服务设置为手动启动
• 在 [2] 中：停止该服务
• 在 [3] 中：确认新的服务配置

要手动启动和停止 MySQL 服务，我们可以创建两个快捷方式：

• 在 [1] 中：用于启动 MySQL5 的快捷方式
• 在 [2] 中：用于停止 MySQL 的快捷方式

5.5.3. MySQL 管理客户端

在 MySQL 官网上，您可以找到 DBMS 管理客户端：

• [1]：选择 [MySQL GUI Tools]，其中包含用于管理 DBMS 或使用 DBMS 的各种图形化客户端
• 在 [2] 中：选择相应的 Windows 版本

• 在 [3] 中：下载 .msi 文件并运行
• 在 [4] 中：安装完成后，[开始菜单 / 程序 / MySQL] 文件夹中将出现新的快捷方式。

启动 MySQL（使用您创建的快捷方式），然后通过上方菜单启动 [MySQL Administrator]：

• 在 [1] 中：输入 root 用户的密码（此处为 root）
• 在 [2] 中：您已登录，并可看到 MySQL 正在运行

5.5.4. 创建 jpa 用户和 jpa 数据库

本教程使用 MySQL 5，数据库名为 jpa，用户名也同为 jpa。现在我们将创建它们。首先是用户：

• 在 [1] 中：选择 [用户管理]
• 在 [2]：右键单击 [用户账户] 部分以创建新用户
• 在 [3] 中：用户名为 jpa，密码为 jpa
• 在 [4]：确认创建
• 在 [5] 中：用户 [jpa] 出现在 [用户账户] 窗口中

现在是数据库：

• 在 [1] 中：选择 [目录] 选项
• 在 [2] 中：右键单击 [Schemas] 窗口以创建一个新模式（用于指定数据库）
• 在 [3] 中：为新模式命名
• 在 [4] 中：该模式将显示在 [模式] 窗口中

• 在 [5] 中：选择 [jpa] 模式
• 在 [6] 中：[jpa] 模式中的对象（包括表）会显示出来。目前还没有任何对象。右键单击即可创建它们。具体操作留给读者自行尝试。

让我们回到 [jpa] 用户，为其授予 [jpa] 模式的全部权限：

• 在 [1] 中，然后 [2]：选择用户 [jpa]
• 在 [3] 中：选择 [模式权限] 选项卡
• 在 [4] 中：选择 [jpa] 模式
• 在 [5] 中：授予用户 [jpa] 对 [jpa] 模式的所有权限

• 在 [6] 中：确认更改

要验证用户 [jpa] 能否使用 [jpa] 模式，请关闭 MySQL 管理器。重新启动它，并这次以 [jpa/jpa] 身份登录：

• 在 [1] 中：登录 (jpa/jpa)
• 在 [2] 中：连接成功，在 [Schemas] 中，我们可以看到我们拥有权限的模式。我们看到了 [jpa] 模式。

现在，我们将使用第5.4.6节生成的SQL脚本[schema-articles.sql]，创建与Firebird数据库管理系统中相同的[ARTICLES]表。

• 在 [1] 中：使用 [MySQL Query Browser] 应用程序
• 在 [2]、[3]、[4] 中：登录 (jpa / jpa / jpa)

• 在 [5] 中：打开一个 SQL 脚本以执行它
• 在 [6] 中：选择第 5.4.6 节中创建的脚本 [schema-articles.sql]。

• 在 [7] 中：脚本已加载
• 在 [8] 中：执行该脚本
• 在 [9] 中：已创建 [ARTICLES] 表

5.5.5. 适用于 MySQL 5 的 JDBC 驱动程序

MySQL JDBC 驱动程序可从与 DBMS 相同的地址下载：

• 在 [1] 中：选择合适的 JDBC 驱动程序
• 在 [2] 中：选择相应的 Windows 版本
• 在 [3] 中：在下载的 ZIP 文件中，包含 JDBC 驱动程序的 Java 存档文件为 [mysql-connector-java-5.0.5-bin.jar]。我们将解压该文件，以便在 JPA 教程示例中使用。

我们将它放置在 <jdbc> 文件夹中，位置与之前（第 5.4.7 节）相同：

为了测试此 JDBC 驱动程序，我们将使用 Eclipse 及其 SQL Explorer 插件。建议读者按照第 5.4.7 节中的说明进行操作。以下展示了一些相关的屏幕截图：

• 图 [1] 中：我们已选中 MySQL5 JDBC 驱动程序压缩包
• 在 [2] 中：MySQL5 JDBC 驱动程序已提供

• 在 [3] 中：连接定义 (用户名, 密码)=(jpa, jpa)
• 在 [4] 中：连接处于活动状态
• 在 [5] 中：已连接到数据库

5.6. PostgreSQL 数据库管理系统

5.6.1. 安装

PostgreSQL 数据库管理系统可通过以下网址获取 [http://www.postgresql.org/download/]：

• 在 [1]：PostgreSQL 下载站点
• 在 [2] 中：选择 Windows 版本
• 在 [3]：选择带安装程序的版本

• [4]：下载的 ZIP 文件内容。双击 [postgresql-8.2.msi] 文件
• 在 [5] 中：安装向导的第一页

• 在 [6] 中：接受默认值，选择典型安装
• 在 [6b] 中：创建将用于运行 PostgreSQL 服务的 Windows 账户；此处，账户名为 pgres，密码为 pgres。

• 在 [7] 中：如果 [pgres] 账户尚未存在，则让 PostgreSQL 创建该账户
• 在 [8] 中：定义数据库管理系统 (DBMS) 管理员账户，此处为 postgres，密码为 postgres

• 在 [9] 和 [10] 中：接受默认值直至向导结束。PostgreSQL 将被安装。

PostgreSQL 安装程序会在 [开始 / 程序] 中创建一个文件夹：

5.6.2. 启动/停止 PostgreSQL

PostgreSQL 服务器已作为 Windows 服务安装，会自动启动，即 Windows 启动时它也会随即启动。这种设置并不太实用。我们将对其进行修改：

[开始 / 控制面板 / 性能和维护 / 管理工具 / 服务]：

• 在 [1] 中：双击 [服务]
• 在 [2] 中：我们可以看到有一个名为 [PostgreSQL] 的服务，该服务正在运行 [3]，并且设置为自动启动 [4]。

要更改此设置，请双击 [PostgreSQL] 服务：

• 在 [1] 中：将服务设置为手动启动
• 在 [2] 中：停止该服务
• 在 [3] 中：确认新的服务配置

要手动启动和停止 PostgreSQL 服务，您可以使用 [PostgreSQL] 文件夹中的快捷方式：

• 在 [1] 中：启动 PostgreSQL 的快捷方式
• 在 [2] 中：停止 PostgreSQL 的快捷方式

5.6.3. PostgreSQL 管理

在上图中，[pgAdmin III] 应用程序 (3) 允许您管理 PostgreSQL 数据库管理系统。让我们先启动数据库管理系统，然后通过上方的菜单启动 [pgAdmin III]：

• 在 [1] 处：双击 PostgreSQL 服务器以连接到它
• 在 [2,3]：以数据库管理系统管理员身份登录，此处为 (postgres / postgres)

• 在[4]中：现存的唯一数据库
• 在 [5] 中：唯一现有的用户

5.6.4. 创建一个 JPA 用户和一个 JPA 数据库

本教程使用 PostgreSQL，数据库名为 jpa，用户名也同为 jpa。现在我们将创建它们。首先是用户：

• 在 [1] 中：创建一个新角色（~user）
• 在 [2] 中：创建 jpa 用户
• 在 [3] 中：其密码为 jpa
• 在 [4] 中：我们再次输入密码
• 在 [5] 中：授予该用户创建数据库的权限
• 在 [6] 中：用户 [jpa] 出现在登录角色列表中

现在处理数据库：

• 在 [1] 中：建立与服务器的全新连接
• 在 [2] 中：将其命名为 jpa
• 在 [3] 中：输入我们要连接的机器
• 在 [4] 中：登录用户
• 在 [5] 中：输入密码。点击 [确定] 确认连接设置
• 在 [6] 中：新连接已创建。该连接属于用户 jpa。该用户现在将创建一个新数据库：

• 在 [1] 中：添加新数据库
• 在 [2] 中：其名称为 jpa
• 在 [3] 中：其所有者是之前创建的 jpa 用户。点击 [确定] 确认
• 在 [4] 中：jpa 数据库已创建。单击该数据库即可连接并显示其结构：

• 在 [5] 中：[jpa] 模式的对象（尤其是表）已显示出来。目前尚无任何对象。右键单击可创建它们。具体操作留给读者自行尝试。

现在，我们将使用第5.4.6节生成的SQL脚本[schema-articles.sql]，创建与之前DBMS中相同的[ARTICLES]表。

• 在 [1] 中：打开 SQL 编辑器
• 在 [2] 中：打开一个 SQL 脚本
• 在 [3] 中：选择在第 5.4.6 节中创建的脚本 [schema-articles.sql]

• 在 [4] 中：脚本已加载。我们执行它。
• 在 [5] 中：[ARTICLES] 表已创建。
• 在 [6, 7] 中：其内容

5.6.5. PostgreSQL JDBC 驱动程序

PostgreSQL JDBC 驱动程序位于 PostgreSQL 安装目录下的 [jdbc] 文件夹中：

我们像之前那样（第 5.4.7 节），将 JDBC 归档文件放置在 <jdbc> 文件夹中：

为了测试此 JDBC 驱动程序，我们将使用 Eclipse 及其 SQL Explorer 插件。建议读者按照第 5.4.7 节中的说明进行操作。以下是几个相关的屏幕截图：

• 图 [1]：我们已选中 PostgreSQL JDBC 驱动程序压缩包
• 在 [2] 中：PostgreSQL JDBC 驱动程序已就绪

• 在 [3] 中：连接定义 (用户名, 密码)=(jpa, jpa)
• 在 [4] 中：连接处于活动状态
• 在 [5] 中：已连接的数据库
• 在 [6] 中：[ARTICLES] 表的内容

5.7. Oracle 10g Express 数据库管理系统

5.7.1. 安装

Oracle 10g Express 数据库管理系统可在 [http://www.oracle.com/technology/software/products/database/xe/index.html] 获取：

• 在 [1]：Oracle 10g Express 下载站点
• 在 [2]：选择 Windows 版本。文件下载完成后，运行它：

• 在 [1] 中：双击 [OracleXE.exe] 文件
• 在 [2]：安装向导的第一页

• 在 [3]：接受许可协议
• 在 [4] 中：接受默认设置。

• 在 [5,6]：SYSTEM 用户的密码为 "system"。
• 在 [7] 中：开始安装

安装 Oracle 10g Express 将在 [开始 / 程序] 中创建一个文件夹：

5.7.2. 启动/停止 Oracle 10g

与之前的 DBMS 一样，Oracle 10g 已作为 Windows 服务安装，并会自动启动。我们将更改此配置：

[开始 / 控制面板 / 性能和维护 / 管理工具 / 服务]：

• 在 [1] 中：双击 [服务]
• 在 [2] 中：我们可以看到有一个名为 [OracleServiceXE] 的服务，该服务正在运行 [3]，并且设置为自动启动 [4]。
• 在 [5] 中：另一个名为“Listener”的 Oracle 服务也处于活动状态，并设置为自动启动。

要更改此行为，请双击 [OracleServiceXE] 服务：

• 在 [1] 中：将服务启动类型设置为“手动”
• 在 [2] 中：停止该服务
• 在 [3] 中：确认新的服务配置

我们将对 [OracleXETNSListener] 服务执行相同的操作（参见上文 [5]）。要手动启动和停止 OracleServiceXE 服务，我们可以使用 [Oracle] 文件夹中的快捷方式：

• 在 [1] 中：用于启动 DBMS
• 在 [2] 中：停止它
• 在 [3] 中：管理它（如果它尚未运行，则会启动它）

5.7.3. 创建 JPA 用户和 JPA 数据库

在上图的截图中，[3] 应用程序允许您管理 Oracle 10g Express 数据库管理系统。让我们先启动数据库管理系统 [1]，然后通过上方的菜单启动管理应用程序 [3]：

• 在 [1] 中：以 DBMS 管理员身份登录（此处为 system/system）
• 在 [2] 中：创建新用户

• 在 [4] 中：用户名
• 在 [5, 6] 中：输入密码，此处为 jpa
• 在 [7] 中：用户 jpa 已创建

在 Oracle 中，用户会自动与同名的数据库相关联。因此，jpa 数据库与 jpa 用户同时存在。

5.7.4. 在 jpa 数据库中创建 [ARTICLES] 表

OracleXE 的安装包含一个在命令行模式下运行的 SQL 客户端。您也可以使用 Oracle 提供的 SQL Developer 进行更便捷的操作。该工具可通过以下链接获取：

[http://www.oracle.com/technology/products/database/sql_developer/index.html]

• 在 [1] 中：下载站点
• 在 [2] 中：如果已安装 JRE（如本例所示），请选择不含 JRE 的 Windows 版本，因为 [SQL Developer] 是一款 Java 应用程序。

• [3]：解压下载的文件
• 在 [4] 中：运行可执行文件 [sqldeveloper.exe]

• 在 [5] 中：首次启动 [SQL Developer] 时，请指定计算机上已安装的 JRE 路径
• 在 [5b] 中：创建一个新连接

• 在 [6] 中：SQL Developer 允许您连接到各种数据库管理系统（DBMS）。请选择 Oracle。
• 在 [7] 中：为正在创建的连接命名
• 在 [8] 中：连接的所有者
• 在 [9] 中：其密码（jpa）
• 在 [10] 中：保留默认值
• 在 [11]：测试连接（Oracle 必须正在运行）
• 在 [12] 中：完成连接配置
• 在 [13] 中：JPA 数据库中的对象
• 在 [14] 中：您可以创建表。与前面的情况一样，我们将使用第 5.4.6 节中创建的脚本创建 [ARTICLES] 表。

• 在 [15] 中：打开一个 SQL 脚本
• 在 [16] 中：选择第 5.4.6 节中创建的 SQL 脚本
• 在 [17] 中：待执行的脚本

• 在 [18] 中：执行结果：已创建 [ARTICLES] 表。双击该表以查看其属性。
• 在 [19] 中：该表的内容。

5.7.5. OracleXE JDBC 驱动程序

OracleXE JDBC 驱动程序位于 OracleXE 安装目录 [1] 内的 [jdbc/lib] 文件夹中：

我们将 JDBC 归档文件 [ojdbc14.jar] 放置在 <jdbc> 文件夹中 [2]，与之前（第 5.4.7 节）的做法相同：

为了测试此 JDBC 驱动程序，我们将使用 Eclipse 及其 SQL Explorer 插件。建议读者按照第 5.4.7 节中的说明进行操作。以下展示了一些相关的屏幕截图：

• 图 [1]：我们已指定 OracleXE JDBC 驱动程序存档
• 在 [2] 中：OracleXE JDBC 驱动程序已就绪

• 在 [3] 中：连接定义 (用户名, 密码)=(jpa, jpa)
• 在 [4] 中：连接处于活动状态
• 在 [5] 中：已连接的数据库
• 在 [6] 中：[ARTICLES] 表的内容

5.8. 数据库管理系统（DBMS）为 的SQL Server Express 2005

5.8.1. 安装

SQL Server Express 2005 可从 [http://msdn.microsoft.com/vstudio/express/sql/download/] 下载：

• 在 [1] 中：首先下载并安装 .NET 2.0 平台
• 在 [2] 中：随后安装并下载 SQL Server Express 2005
• 步骤 [3]：接下来，安装并下载 SQL Server Management Studio Express，该工具可用于管理 SQL Server

安装 SQL Server Express 会在 [开始 / 程序] 中创建一个文件夹：

• 在 [1] 中：SQL Server 配置应用程序。还可用于启动/停止服务器
• 在 [2] 中：服务器管理应用程序

5.8.2. 启动/停止 SQL Server

与之前的 DBMS 一样，SQL Server Express 已作为 Windows 服务安装，并会自动启动。我们将更改此配置：

[开始 / 控制面板 / 性能和维护 / 管理工具 / 服务]：

• 在 [1] 中：我们双击 [服务]
• 在 [2] 中：我们可以看到有一个名为 [SQL Server] 的服务，该服务正在运行 [3]，并且设置为自动启动 [4]。
• 在 [5] 中：另一个与 SQL Server 相关的服务，名为“SQL Server 浏览器”，也处于活动状态，并设置为自动启动。

要更改此行为，请双击 [SQL Server] 服务：

• 在 [1] 中：将服务启动类型设置为“手动”
• 在 [2] 中：停止该服务
• 在 [3] 中：确认新的服务配置

我们将对 [SQL Server Browser] 服务执行相同的操作（参见上文 [5]）。要手动启动和停止 SQL Server 服务，我们可以使用 [SQL Server] 文件夹中的 [1] 应用程序：

• 在 [1] 中：确保已启用 TCP/IP 协议，然后进入协议属性。
• 在 [2] 中：在 [IP 地址] 选项卡中，[IPAll] 选项：
  • 将 [TCP 动态端口] 字段留空
  • 在 [TCP 端口] 中，将服务器的监听端口设置为 1433

• 在 [3] 中：右键单击 [SQL Server] 服务可访问服务器的启动/停止选项。在此，我们启动该服务。
• 在 [4] 中：SQL Server 已启动

5.8.3. 创建 JPA 用户和 JPA 数据库

按上述方法启动数据库管理系统，然后通过下方菜单启动管理应用程序 [1]：

• 在 [1] 中：以 Windows 管理员身份登录到 SQL Server
• 在 [2] 中：配置连接属性

• 在 [3] 中：我们启用混合模式以连接到服务器：既可以使用 Windows 登录（Windows 用户），也可以使用 SQL Server 登录（在 SQL Server 内部定义的账户，与任何 Windows 账户无关）。
• 在 [3b] 中：创建一个 SQL Server 用户

• 在 [4] 中：[常规] 选项卡
• 在 [5] 中：登录名
• 在 [6] 中：密码（此处为 jpa）
• 在 [7]：[服务器角色] 选项
• 在 [8] 中：用户 jpa 将拥有创建数据库的权限

请确认此配置：

• 在 [9] 中：已创建用户 jpa
• 在 [10]：注销
• 在 [11]：重新登录

• 在 [12] 中：以用户 jpa/jpa 身份登录
• 在 [13] 中：登录后，用户 jpa 创建一个数据库

• 在 [14] 中：该数据库将命名为 jpa
• 在 [15] 中：该数据库将归属于用户 jpa
• 在 [16] 中：jpa 数据库已创建

5.8.4. 在 jpa 数据库中创建 [ARTICLES] 表

与前面的示例一样，我们将使用第5.4.6节中创建的脚本来创建 [ARTICLES] 表。

• 在 [1] 中：我们打开一个 SQL 脚本
• 在 [2] 中：选择第 5.4.6 节（第 240 页）中创建的 SQL 脚本。
• 在 [3] 中：重新登录（jpa/jpa）
• 在 [4] 中：待执行的脚本
• 在 [5] 中：选择将要执行脚本的数据库
• 在 [6]：执行它

• 在 [7] 中：执行结果：已创建 [ARTICLES] 表。
• 在 [8] 中：我们请求查看其内容
• 在 [9] 中：表的内容。

5.8.5. SQL Server Express JDBC 驱动程序

• 在 [1] 中：通过 Google 搜索 [Microsoft SQL Server 2005 JDBC 驱动程序]，即可进入 JDBC 驱动程序下载页面。我们选择最新版本
• 在 [2] 中：下载的文件。我们双击该文件。文件被解压，生成一个包含 JDBC 驱动程序的文件夹 [3]
• 在 [4] 中：我们将 JDBC 压缩包 [sqljdbc.jar] 放入 <jdbc> 文件夹中，操作方式与之前相同（第 5.4.7 节）

为了测试此 JDBC 驱动程序，我们将使用 Eclipse 及其 SQL Explorer 插件。建议读者按照第 5.4.7 节中的说明进行操作。以下展示几张相关截图：

• 图 [1]：我们已指定 SQL Server JDBC 驱动程序存档
• 在 [2] 中：SQL Server JDBC 驱动程序已就绪

• 在 [3] 中：连接定义 (用户名, 密码)=(jpa, jpa)
• 在 [4] 中：连接处于活动状态
• 在 [5] 中：已连接的数据库
• 在 [6] 中：[ARTICLES] 表的内容

5.9. HSQLDB 数据库管理系统

5.9.1. 安装

HSQLDB 数据库管理系统可通过 URL [http://sourceforge.net/projects/hsqldb] 获取。这是一个用 Java 编写的、内存占用极小的数据库管理系统，它在内存中而非磁盘上管理数据库。因此，查询执行速度极快，这也是其主要优势。 以这种方式在内存中创建的数据库，在服务器关闭并重新启动后可以恢复。这是因为用于创建数据库的 SQL 命令会被存储在日志文件中，以便在服务器下次启动时重放。这确保了数据库随时间的持久性。

该方法存在局限性，且 HSQLDB 并非商用级数据库管理系统。其主要价值在于测试或演示应用。 例如，由于 HSQLDB 采用 Java 编写，因此可以将其纳入 Java 任务自动化工具 Ant（Another Neat Tool）的任务中。这样，由 Ant 自动执行的开发中软件的日常代码测试，便可整合由 HSQLDB DBMS 管理的数据库测试。服务器的启动、停止及管理都将由 Java 任务完成。

• [1]：下载地址
• 在 [2] 中：下载最新版本

• 在 [3] 中：解压下载的文件
• 在 [4] 中：解压后生成的 [hsqldb] 文件夹
• 在 [5] 中：包含用于启动 [hsql] 服务器的脚本的 [demo] 文件夹 [6]，以及在 [7] 中，用于启动基本服务器管理工具的脚本。

5.9.2. 启动/停止 HSQLDB

要启动 HSQLDB 服务器，请双击上文中的 [runManager.bat] 应用程序 [6]：

• 在 [1] 中：您可以看到，要停止服务器，只需在窗口中按下 Ctrl-C 即可。

5.9.3. [test] 数据库

默认数据库位于 [data] 文件夹中：

• 在 [1] 中：启动时，HSQL 数据库管理系统会执行名为 [test.script] 的脚本

CREATE SCHEMA PUBLIC AUTHORIZATION DBA
CREATE USER SA PASSWORD ""
GRANT DBA TO SA
SET WRITE_DELAY 10

• 第 1 行：创建了一个 [public] 模式
• 第 2 行：创建了一个密码为空的用户 [sa]
• 第 3 行：授予用户 [sa] 管理员权限

最终，已创建了一个具有管理权限的用户。这就是我们今后将要使用的用户。

5.9.4. HSQL JDBC 驱动程序

HSQL 数据库管理系统（DBMS）的 JDBC 驱动程序位于 [lib] 文件夹中：

• 在 [1] 中：[hsqldb.jar] 压缩包包含 HSQL DBMS 的 JDBC 驱动程序
• 在 [2] 中：我们将此压缩包（与前文第 5.4.7 节所述操作相同）放置在 <jdbc> 文件夹中

为了验证此 JDBC 驱动程序，我们将使用 Eclipse 及其 SQL Explorer 插件。建议读者按照第 5.4.7 节中所述的步骤进行操作。以下展示了一些相关的屏幕截图：

• 在 [1] 中：[窗口 / 首选项 / SQL Explorer / JDBC 驱动程序]
• 在 [2] 中：配置 [HSQLDB] 服务器
• 在 [3] 中：指定包含 JDBC 驱动程序的 [hsqldb.jar] 文件
• 在 [4] 中：JDBC 驱动程序的 Java 类名称
• 在 [5] 中：JDBC 驱动程序已配置

完成上述配置后，我们连接到 HSQL 服务器。首先启动服务器。

• 在 [6] 中：创建一个新连接
• 在 [7] 中：为其命名
• 在 [8] 中：我们需要连接到 HSQLDB 服务器
• 在 [9] 中：输入要连接的数据库的 URL。这将是之前看到的 [test] 数据库。
• 在 [10] 中：以用户 [sa] 登录。我们看到他是数据库管理系统 (DBMS) 管理员。
• 在 [11] 中：用户 [sa] 没有密码。

我们验证连接配置。

• 在 [12] 中：我们连接
• 在 [13] 中：我们登录
• 在 [14]：您已登录

• 在 [15] 中：[PUBLIC] 模式下尚未有表
• 在 [16]：我们将使用第 5.4.6 节中创建的 [schema-articles.sql] 脚本创建 [ARTICLES] 表。
• 在 [17] 中：选择该脚本

• 在 [18] 中：待执行的脚本
• 在 [19] 中：我们会在移除所有注释后运行它，因为 HSQLB 不支持注释。

• 脚本运行完成后，请刷新 [20] 中的数据库视图
• 在 [21] 中：[ARTICLES] 表已存在
• 在 [22] 中：其内容

现在让我们停止并重新启动 HSQLDB 服务器。完成后，让我们查看 [test.script] 文件：

CREATE SCHEMA PUBLIC AUTHORIZATION DBA
CREATE MEMORY TABLE ARTICLES(ID INTEGER NOT NULL,NOM VARCHAR(20) NOT NULL,PRIX DOUBLE NOT NULL,STOCKACTUEL INTEGER NOT NULL,STOCKMINIMUM INTEGER NOT NULL,CONSTRAINT PK_ARTICLES PRIMARY KEY(ID),CONSTRAINT CHK_ID CHECK(ARTICLES.ID>0),CONSTRAINT CHK_PRIX CHECK(ARTICLES.PRIX>0),CONSTRAINT CHK_STOCKACTUEL CHECK(ARTICLES.STOCKACTUEL>0),CONSTRAINT CHK_STOCKMINIMUM CHECK(ARTICLES.STOCKMINIMUM>0),CONSTRAINT CHK_NOM CHECK(ARTICLES.NOM!=''),CONSTRAINT UNQ_NOM UNIQUE(NOM))
CREATE USER SA PASSWORD ""
GRANT DBA TO SA
SET WRITE_DELAY 10
SET SCHEMA PUBLIC
INSERT INTO ARTICLES VALUES(1,'article1',100.0E0,10,1)
INSERT INTO ARTICLES VALUES(2,'article2',200.0E0,20,2)
INSERT INTO ARTICLES VALUES(3,'article3',300.0E0,30,3)

我们可以看到，DBMS 已存储了上一会话期间执行的各种 SQL 语句，并在新会话开始时重新执行它们。 我们还可以看到（第 2 行），[ARTICLES] 表是在内存（MEMORY）中创建的。在每个会话开始时，发出的 SQL 语句会被存储在 [test.log] 中，以便在下个会话开始时复制到 [test.script] 中，并在会话开始时重放。

5.10. Apache Derby 数据库管理系统

5.10.1. 安装

Apache Derby 数据库管理系统可在 URL [http://db.apache.org/derby/] 获取。它同样是用 Java 编写的 DBMS，且在内存占用上同样非常轻量。它提供了与 HSQLDB 类似的优势。它同样可以嵌入到 Java 应用程序中，即成为应用程序的组成部分，并在同一 JVM 内运行。

• 在 [1] 中：下载站点
• 在 [2,3] 中：下载最新版本

• 在 [3] 中：解压下载的文件
• 在 [4] 中：解压后生成的 [db-derby-*-bin] 文件夹
• 在 [5] 中：包含用于启动 [db derby] 服务器的脚本的 [bin] 文件夹 [6]，以及在 [7] 中，包含用于停止该服务器的脚本。

5.10.2. 启动/停止 Apache Derby (DB Derby)

要启动 Db Derby 服务器，请双击上文中的 [startNetworkServer] 应用程序 [6]：

• 在 [1] 中：服务器已启动。将使用上方的 [stopNetworkServer] 应用程序 [7] 停止服务器。

5.10.3. Db Derby JDBC 驱动程序

Db Derby 数据库管理系统（DBMS）的 JDBC 驱动程序位于安装目录的 [lib] 文件夹中：

• 在 [1] 中：[derbyclient.jar] 压缩包包含 Db Derby 数据库管理系统（DBMS）的 JDBC 驱动程序
• 在 [2] 中：我们将此压缩包（与前文第 5.4.7 节所述操作相同）放置在 <jdbc> 文件夹中

为了测试此 JDBC 驱动程序，我们将使用 Eclipse 及其 SQL Explorer 插件。建议读者按照第 5.4.7 节中所述的步骤进行操作。以下展示了一些相关的屏幕截图：

• [1] 中：[窗口 / 首选项 / SQL Explorer / JDBC 驱动程序]
• 在 [2] 中：Apache Derby JDBC 驱动程序未出现在列表中。我们将它添加进去。

• 在 [3] 中：我们为新驱动程序命名
• 在 [4] 中：指定 JDBC 驱动程序支持的 URL 格式
• 在 [5] 中：指定 JDBC 驱动程序的 .jar 文件
• 在 [5b] 中：指定 JDBC 驱动程序的 Java 类名称
• 在 [5c] 中：JDBC 驱动程序已配置完毕

完成上述操作后，连接到 Apache Derby 服务器。请预先启动服务器。

• 在 [6] 中：建立一个新的连接
• 在 [7] 中：为其命名
• 在 [8] 中：我们希望连接到 Apache Derby 服务器
• 在 [9] 中：指定要连接的数据库 URL。在标准前缀 [jdbc:derby://localhost:1527] 之后，我们将指定磁盘上包含 Derby 数据库的目录路径。[create=true] 选项允许我们在该目录不存在时自动创建它。
• 在 [10,11] 中：我们以用户 [jpa/jpa] 身份连接。我尚未深入研究，但似乎可以使用任意登录名和密码。在此处，若 create=true，则需指定数据库所有者。

我们验证连接配置。

• 在 [12] 中：登录
• 在 [13]：登录 (jpa/jpa)
• 在 [14] 中：您已登录

• 在 [15] 中：[jpa] 模式尚未出现。
• 在 [16] 中：我们将根据第 5.4.6 节中创建的 [schema-articles.sql] 脚本创建 [ARTICLES] 表。
• 在 [17] 中：选择该脚本

• 在 [18] 中：待执行的脚本
• 在 [19] 中：我们在移除所有注释后执行该脚本，因为 Apache Derby 和 HSQLB 一样，不支持注释。

• 脚本运行完成后，请刷新 [20] 中的数据库视图
• 在 [21] 中：[jpa] 模式和 [ARTICLES] 表已存在
• 在 [22] 中：[ARTICLES] 表的内容

• 在 [23] 中：数据库创建所在的 [derby\jpa] 文件夹的内容。

5.11. Spring 2 框架

Spring 2 框架可通过以下网址获取 [http://www.springframework.org/download]：

• 在 [1]：下载最新版本
• 在 [2] 中：请下载标有“含依赖项”的版本，因为该版本包含 Spring 集成的第三方工具所需的 .jar 文件，这些文件您始终需要。

• 在 [3]：解压下载的压缩包
• 在 [4]：Spring 2.1 安装文件夹

• 在 [5] 中：在 <dist> 文件夹内，您将找到 Spring 压缩包。[spring.jar] 压缩包包含 Spring 框架的所有类。这些类也可以按模块形式在 [6] 中的 <modules> 文件夹内找到。如果您知道需要哪些模块，可以在这里找到它们。这样，您就可以避免在应用程序中包含它不需要的压缩包。

• 在 [7] 中：<lib> 文件夹包含 Spring 所使用的第三方工具的归档文件
• 在 [8] 中：[jakarta-commons] 项目的部分归档文件

当本教程使用 Spring 归档文件时，您必须从 Spring 安装目录中的 <dist> 文件夹或 <lib> 文件夹中获取它们。

5.12. JBoss EJB3 容器

JBoss EJB3 容器可通过以下 URL 访问 [http://labs.jboss.com/jbossejb3/downloads/embeddableEJB3]：

• 在 [1] 中：下载 JBoss EJB3。请注意产品日期（2006 年 9 月），尽管下载操作是在 2007 年 5 月进行的。人们可能会怀疑该产品是否仍在开发中。
• 在 [2] 中：下载的文件

• 在 [3] 中：解压后的 ZIP 文件
• 在 [4] 中：[hibernate-all.jar、jboss-ejb3-all.jar、thirdparty-all.jar] 这些归档文件构成了 JBoss EJB3 容器。使用该容器的应用程序必须将它们放置在类路径中。