成為一名 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"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence"
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">
<persistence-unit name="baseball">
<class>org.developerworks.baseball.Game</class>
<class>org.developerworks.baseball.Player</class>
<properties>
<property name=\
"openjpa.ConnectionURL" value="jdbc:mysql://localhost:3306/baseball"/>
<property name="openjpa.ConnectionDriverName" value="com.mysql.jdbc.Driver"/>
<property name="openjpa.ConnectionUserName" value="root"/>
<property name="openjpa.ConnectionPassword" value="password"/>
<property name="openjpa.Log" value="DefaultLevel=WARN, Tool=INFO"/>
</properties>
</persistence-unit>
</persistence>
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<Player> 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" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO -8859-1">
<title>Baseball Players</title>
</head>
<body>
<table>
<thead>
<tr>
<td>First Name</td>
<td>Last Name</td>
</tr>
</thead>
<c:forEach items="${players}" var="player">
<tr>
<td>${player.firstName}</td>
<td>${player.lastName}</td>
</tr>
</c:forEach>
</table>
</body>
</html>
用 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
