成为一名 Web开发人员恰逢其时。从来不曾像现在一样有如此多的技术选择 。大量优秀的开源 Web 服务器、数据库、编程语言和开发框架供您使用。无论 您希望使用哪种技术组合，都存在可以提高生产力的集成开发环境 (IDE)： Eclipse。本教程是三部分系列教程 “Web development with Eclipse Europa” 的第 1 部分，将介绍如何通过 Eclipse 实现使用 Java™ 技术、PHP 和 Ruby 的 Web 开发，查看如何使用 Eclipse 的最新版本 —— Europa —— 来快速开发 Java Web 应用程序。我 们将使用 Java Platform, Enterprise Edition 5 (Java EE) for Eclipse 来 构建用于跟踪和计算棒球统计信息的 Web 应用程序。
开始之前
Eclipse 开发人员一直致力于使 Web开发人员可以更轻松 地工作。Eclipse 的 Europa 发行版提供了几个经过调整的 Eclipse 版本，包 括适用于 Web 开发人员的版本。
关于本系列
在 “用 Eclipse Europa 进行 Web 开发” 系列中，您将了解到无论选择何种语言 ，Eclipse 都是适用于 Web开发的平台。灵活的插件系统使它可以轻松地创建 各种针对使用 Java 技术、PHP 和 Ruby 的 Web 开发而定制的 Eclipse 版本。 您将看到不同的插件怎样为每种语言提供独特的 Eclipse 功能，还将看到所有 Web 开发人员都可以利用的一些常用功能。在本系列中，我们将创建一个样例棒 球 Web 应用程序，该应用程序将允许我们输入棒球球员的比赛数据并计算那些 球员的统计信息。
关于本教程
作为三部分系列教程的第 1 部分 ，本教程将使用 Eclipse Java EE 版本进行 Java Web 开发，使用 Eclipse 连 接到数据库、创建表并在数据库中创建测试数据。配置 Eclipse 以使用 Web 服 务器，然后使用 Eclipse 的向导来创建 Web 应用程序、Web 页面和数据访问代 码。最后，将使用 Eclipse 控制 Web 服务器，发布应用程序，甚至当应用程序 在服务器上运行时调试应用程序。
先决条件
拥有 Java 编程背景 对于发挥本教程的最大功效至关重要。熟悉 Eclipse IDE 将十分有帮助，但并 非必要。
系统要求
需要满足以下条件：
Eclipse Europa 本教程将使用 Eclipse V3.3 (Europa)。Java Development Kit (JDK) 本教程 将向您展示如何使用 Java 技术开发 Web 应用程序，因此需要使用 Java Development Kit (JDK) 5.0 或更高版本。下载 V5.0 或 V6.0。Eclipse IDE for Java EE Developers 还需要使用 Eclipse IDE for Java EE Developers。 Java 运行时环境（Java Runtime Environment，JRE） 要运行 Eclipse，必须 配备 JRE。Apache Tomcat 应用程序将使用 Apache Tomcat 作为容器。MySQL V5.0 应用程序将使用 MySQL V5.0 作为数据库。Java Persistence API 还需要 使用 Java Persistence API，特别是 OpenJPA 实现。
Eclipse：哪个版本？
如果查看 Eclipse.org 的下载部分，您将看到 若干个可用的 Eclipse 发行版。我们将使用 Eclipse IDE for Java EE Developers。
Java EE
Eclipse IDE for Java EE Developers 将 为您提供进行 Java Web 开发所需的功能：Java 编译器和调试器；对 Java 应 用服务器、数据库客户端的支持；适用于 Web 应用程序、Web 服务和 Enterprise JavaBean (EJB) 的向导等。值得注意的是 HTML 文件和 Java Server Page (JSP) 的图形编辑器。附带的大多数功能都可以在 Eclipse 的先 前版本中找到。在 Europa 发行之前，需要下载现在被称为 Eclipse 经典版的 版本并安装附加插件。使用 Europa 发行版，这一操作已经被全部简化，并且针 对 Java Web 开发对 Java EE 包进行了全面的调整。
提示：Java EE 包 是按功能打包的。要支持所有这些功能，需要消耗开发计算机中的一些资源。建 议编辑 eclipse.ini 配置文件来增加 Europa 的内存使用量。根据所用操作系 统的不同，此文件的存放位置会有所不同。要增加内存使用量，请编辑 -vmargs 。在本教程中开发应用程序期间所使用的内存设置如下所示：
清单 1. eclipse.ini -vmargs
-Xms256m
-Xmx512m
- Xmn128m
-XX:+UseParallelGC
- XX:MaxPermSize=128m
安装 Europa 的 Java EE 版本，然后配置 数据库和 Web 服务器。接下来将查看这些步骤。
基础设施
Eclipse 使 Web 开发比以往更简单，但是我们仍然需要一些基础设施。 需要用于保存和检索数据的数据库。Eclipse 为使用数据库提供了优秀工具，因 此需要做的就是创建一个空数据库，也可以重用已有的数据库。下面所示的 MySQL 命令将创建一个空数据库。
清单 2. 创建数据库
mysql>
Newton:~ michael$ mysql -u root -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 9
Server version: 5.0.41 MySQL Community Server (GPL)
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql> create database baseball;
Query OK, 1 row affected (0.04 sec)
mysql>
已经完成了一部分基础设施。现在需要一个 Web 服务器。可以使用任意的 Java Web 容器，包括应用服务器，例如 Apache Geronimo 或 IBM® WebSphere®。保持所有内容尽量简单并且只使用一个 Web 容器 —— 在本例中为 Apache Tomcat V6.0。您不需要对 Tomcat 进行任 何特殊操作。现在基础设施已经就绪，让我们接着使用 Eclipse 来开发 Web 应 用程序。
Baseball 应用程序：使用数据库
为了演示 Eclipse 的 强大，我们将构建用于跟踪棒球统计信息的 Java Web 应用程序。它是一个非常 简单的应用程序，允许我们输入棒球球员的比赛数据并计算那些球员的统计信息 。首先需要做的是创建数据库模式。
创建模式
打开 Eclipse 时 ，将需要打开 Data Source Explorer 窗口。右键单击 Databases 文件夹并选 择 New，如下所示：
图 1. Data Source Explorer
Eclipse 将询问您应当将哪类连接用于数据库。选择 Generic JDBC Connection。
图 2. 连接类型
现在配置连接。需要告诉 Eclipse 连接到哪个数据库。我们在清单 2 中已经创建了一个 baseball 数据库，因此就使用那个数据库。
图 3. JDBC 连接配置
需要通过单击 Browse 按钮创建一个新驱动程序，如上所示。此操作 将打开各种数据库类型列表。
图 4. 数据库类型
向下滚动找到 MySQL V5.1（或者任何一种适用于您所用数据库的类型 ）。单击 Add 打开驱动程序定义对话框。
图 5. JDBC 驱动程序定义
单击 Add Jar/Zip。此操作将打开一个简单的文件浏览器，您可以使 用该浏览器浏览到已下载的 MySQL 驱动程序的 JAR 文件。选中 JDBC JAR 之后 ，应当会刷新驱动程序定义列表。
图 6. 更新驱动程序定义列表
现在可以选择刚创建的驱动程序定义并单击 OK。此操作将打开连接属 性。您可能需要编辑此属性以反映将使用的用户名和密码。
图 7. JDBC 连接属性
输入相应的连接信息后，可以测试连接。应当会显示一个成功对话框 。
图 8. 测试连接
如果未获得如上所示的成功消息，则需要调整设置。连接测试通过后，应当 能够在 Data Source Explorer 中启动与数据库的连接。
图 9. 从 Data Source Explorer 连接
现在已经创建了与数据库的连接。该来为将要存储的数据创建一些表了。
创建表
要创建表，首先要查看 Data Source Explorer 中的表列表。
图 10. 列出的数据库表
目前还没有表，因为还未创建。如果重用现有数据库，则应当会看到表列表 。无论是哪一种情况，都请右键单击 Tables 文件夹，然后选择 New Table。
图 11. 选择新建表
此操作将打开创建选项列表。
图 12. 创建表选项
此操作将打开新建表对话框。
图 13. 新建表
我们将创建一张名为 Players 的表并给它提供三列：Id、First_Name 和 Last_Name。所有这三列都是必需的，并且以 Id 为主键。
图 14. 主键定义
单击 Finish。此操作不对数据库执行任何 SQL DDL。相反，它将为您生成 SQL 语句。
图 15. 生成的 SQL 语句
这其中最棒的是可以在执行前亲自调整 SQL。把 Id 列设置为自动累加的列 ，并把 first-name 和 last-name 列中的字符长度限制为 50 个字符。该 SQL 将类似清单 3。
清单 3. Players 表 SQL
CREATE TABLE Players (
Id INT NOT NULL AUTO_INCREMENT,
First_Name VARCHAR(50) NOT NULL,
Last_Name VARCHAR(50) NOT NULL,
PRIMARY KEY (Id)
);
要执行 SQL，请高亮选中并右键单击 Execute selected Text。
图 16. 执行 SQL
执行 SQL 后应当会在 SQL Results 窗口中生成一条确认成功的消息。
图 17. 确认 SQL 执行成功
您已经从 Eclipse 中创建了 Players 表，还可以打开 Data Source Explorer 来检验劳动成果。
图 18. 从 Data Source Explorer 查看 Players 表
还需要另外一张表，该表将保存棒球应用程序的比赛数据。可以按照上面的 方法创建。需要执行的最后一条 SQL 语句如清单 4 所示：
清单 4. Games 表 SQL
CREATE TABLE Games (
Id INT NOT NULL AUTO_INCREMENT,
Player_Id INT DEFAULT '' NOT NULL,
AB INT DEFAULT 0 NOT NULL,
H INT DEFAULT 0 NOT NULL,
2B INT DEFAULT 0 NOT NULL,
3B INT DEFAULT 0 NOT NULL,
HR INT DEFAULT 0 NOT NULL,
BB INT DEFAULT 0 NOT NULL,
R INT DEFAULT 0 NOT NULL,
RBI INT DEFAULT 0 NOT NULL,
PRIMARY KEY (Id)
);
CREATE INDEX Player_Id ON Games (Player_Id ASC);
执行完该 SQL 语句后，就已经创建了应用程序所需的两张表。在使用数据库 期间，让我们继续并输入一些测试数据。
输入测试数据
使用 Eclipse 创建表非常简单。管理那些表中的数据甚至更简单。可以右键 单击 Data Source Explorer 中的表名并选择 Data > Edit 开始添加数据。
图 19. 向 Players 表中添加数据
此操作将打开用于输入表格数据的简单图形界面。
图 20. 输入数据
可以根据需要添加任意数目的数据。只需要为 First_Name 和 Last_Name 输 入值。完成后，在表内右键单击鼠标并选择 Save。
图 21. 保存测试数据
在 SQL Results 窗口中，您将看到正被执行的实际 SQL 以及数据库的返回 消息。可以在 Players 窗口中右击并选择 Refresh。此操作将从数据库中重新 查询数据。您将看到行的 ID，因为这些数据是由数据库创建的。现在我们可以 对 Games 表执行相同操作。根据需要创建测试数据。完成后，就可以设置 Eclipse 来使用 Web 服务器。
使用 Web 服务器
在此部分中，先了解 Eclipse 的基本概念和透视图，然后再设置 Eclipse 来使用 Web 服务器。完成后，将开始实际编写应用程序的过程。
用 Eclipse 设置 Tomcat
Eclipse 中的一个重要概念是透视图。不同的透视图将为您提供适用于具体 开发类型的窗口和命令组。让我们通过选择 Window > Open Perspective > Other 再选择 Java EE 切换到 Java EE 透视图。
图 22. 切换到 Java EE 透视图
现在选择 File > New > Other 并从列表中选择 Server。
图 23. 新服务器
单击 Next 并为服务器定义选择 Tomcat v6.0 Server。需要选择一个运行时 。
图 24. 选择服务器运行时
在文件浏览器中浏览到 Tomcat 安装目录。当 Eclipse 知道 Tomcat 目录的 所在位置后，单击 Finish。现在已经设置了应用程序的所有基础设施，该开始 编写一些代码了。
创建 Web 应用程序
是时候开始开发此 Web 应用程序了。这是 Eclipse 发挥实际作用的部分。 选择 File > New > Other 并选择 Dynamic Web Application 来创建新 Web 应用程序。
图 25. 新动态 Web 应用程序
接下来，填写项目名称 —— 称为 baseball。还要将目标运行时设为刚创建 的 Tomcat V6.0 服务器。
图 26. 项目信息
完成后，该开始开发应用程序的域模型了。单击 Next 以打开 Project Facets。将使用 Java Persistence API 来管理数据访问（下一部分中将介绍有 关该操作的更多信息），因此确保选中该选项。
图 27. Project facets
单击 Next。此操作将打开 Web 模块元数据。在这里可以使用默认值，但我 喜欢把 Web 模块目录称为 “war”，可以一目了然地理解所构建的内容。
图 28. Web 模块信息
单击 Next 将打开 JPA 配置。由于使用的是 Tomcat，因此没有 “内置的” JPA 实现。如 “系统要求” 中所述，使用 OpenJPA。需要选择 Configure default JPA implementation library。
图 29. JPA 配置
此操作将打开 Default JPA Implementation Library 首选项。单击 Configure user libraries。
图 30. 为默认 JPA 实现库设置用户库
这将使您可以选择 OpenJPA（或者其他实现，例如 TopLink 或 Hibernate） JAR 文件。配置了 JPA 实现后，系统将把您带回到 JPA 配置屏幕中，您可以在 该屏幕中选择新库，然后单击 Finish。
图 31. JPA 配置完成
单击 Finish，然后 Eclipse 将开始工作。它将创建 Web 应用程序所需的目 录结构以及所需的许多工件，例如 web.xml 和 persistence.xml 文件。现在应 用程序已经建立，让我们开始创建它的域模型。
Eclipse 和数据访问代码：使用 JPA
了解 Java Persistence API 如何能减轻在 Java 语言中使用数据库的痛苦 ，并了解 Java EE for Eclipse 如何在开始创建应用程序的域模型时支持该域 模型。
创建域模型：使用 JPA
如果您是一名早期 Java 开发人员，则知道使用数据库有多么痛苦。通常涉 及创建大量 JDBC 代码或人工编写的长串 SQL 字符串，还涉及用许多接口创建 实体 EJB 并编写部署描述符。那种日子已经一去不复返，这要归功于 EJB V3.0 和 JPA 的出现。现在不但 EJB 易于使用，而且无需使用重量级应用服务器就可 以使用它们。
Java EE for Eclipse 可以充分支持 JPA。甚至还提供了 JPA 透视图。要切 换到该透视图，请选择 Window > Open Perspective > Other 并选择 JPA Development。
图 32. 打开 JPA 开发透视图
要创建域模型，只需创建简单的 Java 类。首先为 Players 表创建一个名为 org.developerworks.baseball.Player 的类。该类的代码如清单 5 所示：
清单 5. Player 类
package org.developerworks.baseball;
public class Player {
private int id;
private String firstName;
private String lastName;
}
您将需要此类的 getter 和 setter。幸运的是，Eclipse 使这一切变得十分 简单。选择 Source > Generate Getters and Setters。
图 33. 生成代码
此操作将打开 Generate Getters and Setters 对话框。单击 Select All 和 OK。
图 34. 生成 getter 和 setter
得到的代码如清单 6 所示：
清单 6. 带有 getter 和 setter 的 Player 类
package org.developerworks.baseball;
public class Player {
private int id;
private String firstName;
private String lastName;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}
要把类与数据库表关联起来，请在 JPA Structure 窗口中单击 Player 类。
图 35. JPA 结构
在 JPA Details 中，选择 Map As > Entity。
图 36. JPA 详细信息
在 Table 部分中，选择模式，并且可以在 Name 下拉框中选择 Players 表 。
图 37. 指定表
此操作应当会使代码发生更改。
图 38. 生成的 player 代码
在 Package Explorer 中选择 persistence.xml 文件，右键单击该文件，然 后选择 JPA Tools > Synchronize Classes。
图 39. 与数据库同步
此操作将使 Eclipse 针对数据库验证代码。您将注意到自己的代码无效。
图 40. 无效的 Player 类
这是怎么回事？看看 Problems 窗口。
图 41. Problems 窗口
第一个问题是我们的类未指定主键。要解决此问题，请在 JPA Structure 窗 口中单击 Id 属性。在 JPA Details 窗口中，选择 Map As > Id。
图 42. ID 属性的 JPA 详细信息
另请注意，由于 ID 列已设置为自动累加的列，因此需要指定主键使用 Identity 键生成策略。如果再执行一次 JPA 同步，就应当会看到已经解决了一 个问题。
其他问题源自 JPA 不能把 firstName 和 lastName 字段映射到 Players 表 的列中。那是因为没有把 Java 字段命名为与表列完全相同的名称。在 JPA Structure 窗口中选择 firstName 字段。在 JPA Details 的下拉列表中选择相 应的列。
图 43. 把 firstName 映射到 First_Name
对 lastName 字段执行相同的操作。再执行一次 JPA 同步，所有问题都应当 会解决。应当会更新 Player 类的代码，如清单 7 所示：
清单 7. 完成的 Player 类
package org.developerworks.baseball;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY;
import javax.persistence.Column;
@Entity
@Table(schema="baseball", name = "Players")
public class Player {
@Id
@GeneratedValue(strategy=IDENTITY)
private int id;
@Column(name="First_Name")
private String firstName;
@Column(name="Last_Name")
private String lastName;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}
现在可以执行相同的过程并创建映射到 Games 表的 Game 类。Game 类的代 码如清单 8 所示：
清单 8. Game 类
package org.developerworks.baseball;
import javax.persistence.Entity;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY;
import javax.persistence.Column;
@Entity
@Table(schema="baseball", name = "Games")
public class Game {
@Id
@GeneratedValue(strategy=IDENTITY)
private int id;
@ManyToOne(optional=false)
@JoinColumn(name="Player_Id", nullable=false, updatable=false)
private Player player;
@Column(name="H")
private int hits;
@Column(name="2B")
private int doubles;
@Column(name="3B")
private int triples;
@Column(name="HR")
private int homeRuns;
@Column(name="BB")
private int walks;
@Column(name="R")
private int runs;
@Column(name="RBI")
private int rbis;
@Column(name="AB")
private int atBats;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Player getPlayer() {
return player;
}
public void setPlayer(Player player) {
this.player = player;
}
public int getHits() {
return hits;
}
public void setHits(int hits) {
this.hits = hits;
}
public int getDoubles() {
return doubles;
}
public void setDoubles(int doubles) {
this.doubles = doubles;
}
public int getTriples() {
return triples;
}
public void setTriples(int triples) {
this.triples = triples;
}
public int getHomeRuns() {
return homeRuns;
}
public void setHomeRuns(int homeRuns) {
this.homeRuns = homeRuns;
}
public int getWalks() {
return walks;
}
public void setWalks(int walks) {
this.walks = walks;
}
public int getRuns() {
return runs;
}
public void setRuns(int runs) {
this.runs = runs;
}
public int getRbis() {
return rbis;
}
public void setRbis(int rbis) {
this.rbis = rbis;
}
public int getAtBats() {
return atBats;
}
public void setAtBats(int atBats) {
this.atBats = atBats;
}
}
所有的类都完成了映射。最后需要做的就是编辑 persistence.xml。这是 Java Persistence API 的键元数据类并包含连接信息。
清单 9. persistence.xml
<?xml version="1.0" encoding="UTF-8"?>
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
org.developerworks.baseball.Game
org.developerworks.baseball.Player
"openjpa.ConnectionURL" value="jdbc:mysql://localhost:3306/baseball"/>
Eclipse 应当已经为您把类放到此文件中。您只需放入数据库的连接信息。 现在已经使用 Eclipse 设置了 Java Persistence API 以进行数据访问，接下 来可以为这些数据创建 UI。
Eclipse 和 Web 页面
在此部分中，将为要访问的数据创建 UI，把 JSP Model 2 架构用于我们的 应用程序。首先创建用于处理业务逻辑的 servlet，然后将其转发给用于呈现输 出的 JSP。
创建 servlet
使用 Eclipse 创建 servlet。返回到 Java EE 透视图，右键单击 baseball 项目并选择 New > Servlet。
图 44. 新建 servlet
此操作将打开 Create Servlet 对话框。填写 servlet 的 Java package 和 Class name 并单击 Next。
图 45. 创建 servlet
在这里无需进行任何编辑操作，但是请注意指向 servlet 的 URL 映射。这 是访问 servlet 所需的相关 URL。Eclipse 将自动为我们在 web.xml 文件中设 置此 servlet 映射。根本不需要改动该文件。记住此映射并单击 Finish。
图 46. Servlet 信息
在 Servlet 类中，使用 Java Persistence API 来获得所有球员的列表并将 此列表转发给 JSP。该 servlet 的代码如清单 10 所示：
清单 10. PlayerServlet 代码
package org.developerworks.baseball.web;
import java.io.IOException;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.developerworks.baseball.Player;
/**
* Servlet implementation class for Servlet: PlayersServlet
*
*/
public class PlayersServlet extends javax.servlet.http.HttpServlet
implements javax.servlet.Servlet {
static final long serialVersionUID = 1L;
private EntityManagerFactory factory;
private EntityManager em;
/* (non-Java-doc)
* @see javax.servlet.http.HttpServlet#HttpServlet()
*/
public PlayersServlet() {
super();
factory = Persistence.createEntityManagerFactory ("baseball");
em = factory.createEntityManager();
}
/* (non-Java-doc)
* @see javax.servlet.http.HttpServlet#doGet (HttpServletRequest request,
HttpServletResponse response)
*/
@SuppressWarnings("unchecked")
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
|-------10--------20--------30--------40--------50--------60-------- 70--------80--------9|
|-------- XML error: The previous line is longer than the max of 90 characters ---------|
List players =
em.createQuery("select p from Player p").getResultList ();
request.setAttribute("players", players);
request.getRequestDispatcher("/players.jsp").forward (request, response);
}
/* (non-Java-doc)
* @see javax.servlet.http.HttpServlet#doPost (HttpServletRequest request,
HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
|-------10--------20--------30--------40--------50--------60-------- 70--------80--------9|
|-------- XML error: The previous line is longer than the max of 90 characters ---------|
this.doGet(request, response);
}
}
注意，在 servlet 的构造函数中，使用 Java Persistence API 创建引用 “baseball” 持久单元的 EntityManager 实例。此持久单元来自 persistence.xml，如清单 9 所示：
创建视图的 JSP
用 Eclipse 创建 JSP 十分轻松。只需右键单击 baseball 项目并选择 New > JSP。
图 47. 新建 JSP
首先只需列出棒球球员。该列表的代码如清单 11 所示：
清单 11. players.jsp
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
"http://www.w3.org/TR/html4/loose.dtd">
Baseball Players
| First Name | Last Name |
| ${player.firstName} | ${player.lastName} |
用 Eclipse 进行部署
我们创建了一个基本应用程序，且已经准备好测试。此时可以想到可能要用 Ant 或诸如 Perl 或 Groovy 之类的脚本语言编写部署脚本。您可以那样做 — — Eclipse 可以很好地支持 Ant 和 Maven —— 但是有一种更轻松的方法。
从 Eclipse 运行
要从 Eclipse 部署应用程序，只需右键单击 baseball 项目并选择 Run As > Run On Server。
图 48. 在服务器上运行应用程序
Eclipse 将询问需要部署到哪台服务器。只需选择先前创建的 Tomcat 实例 并单击 Finish。
图 49. 选择服务器
此操作将打开 Servers 窗口并显示 baseball 应用程序已经发布到 Tomcat 中。
图 50. 发布到 Tomcat 中的 Baseball 应用程序
现在可以在 Web 浏览器中键入 http://localhost:9762/baseball/PlayersServlet 打开应用程序，并且将显示 先前创建的样例数据。
图 51. Baseball 应用程序
此列表应当与先前创建的样例数据完全相同。如果得到任何错误，则可能需 要确保连接属性都正确并且所有相应的 JAR 均已被复制到 /WEB-INF/lib 目录 中。例如，OpenJPA JAR（及依赖性）是必需的，并且 JDBC 驱动程序 JAR 应当 在该目录中。我们使用了一些 JSTL，因此也需要 JSTL JAR。记住，使用 Eclipse 也可以轻松地进行调试。
用 Eclipse 进行调试
让我们返回到应用程序并执行一些调试。Eclipse 的调试功能是其主要功能 之一，而且这种能够调试在 Web 服务器运行的活动代码的功能非常重要。返回 到 servlet 类并在使用 Java Persistence API 查询数据库的位置设置一个断 点。
图 52. 设置断点
现在在 Server 窗口中右键单击我们使用的服务器并选择 Stop 来停止服务 器。将重新启动服务器，但是这次选择 Debug。
图 53. 调试服务器
现在可以重新装载 Web 页面，而 Eclipse 应当切换到 Debug 透视图。
图 54. Eclipse Debug 透视图
从调试透视图中，您可以逐步完成代码、设置监视方式等。无需对服务器执 行任何特殊操作。我们可以像调试 Java 主方法的可执行类一样调试 Web 应用 程序。
结束语
我们已经看到如何使用 Eclipse 设置 Web开发所需的一切内容。Eclipse 集成了数据库、Web 服务器以及所需的其他内容；拥有可以帮助您快速利用 Java EE 技术集的许多工具。我们使用 Eclipse 连接到数据库以创建表并填充 数据，然后返回并利用相同的工具创建 Java Persistence API 映射以简化数据 访问代码。使用了 Eclipse 创建 JSP 和 servlet。然后可以部署 Web 应用程 序，并且甚至直接从 Eclipse 进行调试。现在，我们可以添加更多用于创建球 员和比赛及计算统计信息的 Web 页面，详见共分三部分的系列教程 “用 Eclipse Europa 进行 Web 开发” 的第 2 部分。
文章来源：
http://www.ibm.com/developerworks/cn/edu/os-dw-os-eclipse- europa1.html
658
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
