學習使用 Eclipse-WebSphere7-DB2 數據庫創建 EJB V3.0 實體 Bean
簡介：EJB V3.0 提供了一個關於使用 Java™ 技術實現數據持久化的健壯工具集。使用 EJB並 不會很難。了解如何在 Eclipse 環境中使用這些功能，以及使您的應用程序更緊密地與有用數據集成。 雖然本文采用了IBM® WebSphere® 應用服務器和 DB2® 的試用版本作為示例，但是所討 論的技術可以被應用到WebSphere 應用服務器和 DB2 的社區版。
簡介
在應用程序開發領域中，數據可用性發生了變化。不同的數據來自不同的來源。一方面，這使得應用 程序比以前更加豐富；另一方面，所有這些數據可能會變得難以處理。如果您需要去持久化數據，而不僅 僅是讀取它，情況會變得更加復雜。
在 Java 環境中，EJB 作為一種可靠的持久化方法出現，它能夠實現很好的維護和恰當的角色分離。 EJB V3.0 在繼續發展，越來越多的工具和方法也不斷地出現。使用 EJB 不會很難。對於 Eclipse 和一 些基本的概念，您可以在您的應用程序中利用它們。
EJB V3.0
EJB V3.0 通過使用基於注釋的 API 來簡化 EJB 的開發，其中 remote/local 接口、home/local 接 口以及部署描述符都不再需要，但是可以繼續使用。開發 Entity EJB 需要一個 Java IDE，一個應用服 務器，以及一個關系數據庫。WebSphere V6.x 要求使用 WebSphere Application Server V6.1 Feature Pack 創建 EJB V3.0 實體 Bean。WebSphere V7 本身就擁有對 EJB V3.0 的支持。Eclipse IDE 是一種 最普遍使用的開源 Java IDE。在本文中，我們將會通過使用 Eclipse、IBM WebSphere7 和 IBM DB2 9.5 來開發一個 EJB V3.0 實體 Bean。
WebSphere 的 EJB V3.0 規范使用 Java Persistence API (JPA) 實現持久化。而 JPA 又基於其他的 持久化技術，比如：Hibernate、JDO 和 TopLink。JPA 是一種用於對象-關系映射的 POJO 持久化 API， 它利用元數據注釋來定義在 Java 對象與一個關系數據庫之間的映射。JPA 支持靜態和動態查詢的類 SQL 語言。JPA 被集成到 JSR220：Enterprise JavaBeans V3.0 規范中。
本文使用的是 WebSphere Application Server 和 DB2 數據庫的試用版本，但是這裡所討論的技術都 可以應用到 WebSphere Application Server 和 DB2 的社區版上。WebSphere Application Server 的試 用版本包含 免費支持。WebSphere Application Server 的社區版也有對應的 支持。
環境准備
下載和安裝 WebSphere Application Server V7。
下載和安裝 Eclipse IDE for JavaEE Developers。
下載和安裝 DB2 V9.5。
在 DB2 中創建數據實例 SAMPLE。
配置 WebSphere 和 DB2
啟動 WebSphere Application Server。在 First Steps Console 中，選擇 Start the server。該 WebSphere 服務器就會啟動，如圖 1 所示。
圖1. 啟動 WebSphere v7 Application Server
下一步，通過選擇 Administrative Console 鏈接啟動 Administrative Console/Integrated Solutions Console。在 Integrated Solution Console 窗口中，選擇 JDBC 供應商表中的 Resources > JDBC > JDBC > New，如圖 2 所示。
圖 2. 創建一個新的 JDBC 供應商
在 Create a new JDBC Provider 窗口中，先選擇 Database > DB2, Provider > DB2 Universal JDBC Driver Provider，然後選擇 Implementation > Connection pool datasource，然 後單擊 Next，如圖 3 所示。
圖 3. 設置配置值
Summary 頁面中列出 JDBC 供應商配置的匯總。選擇 Finish。一個新的 JDBC 供應商被添加到 JDBC providers 表中。選擇這個新的 JDBC 供應商，接著單擊 Save 將 JDBC 供應商存儲到主配置中，如圖 4 所示。
圖 4. 新的 JDBC 供應商
在配置數據源之前，需要配置一個 J2EE 連接器驗證數據項。J2EE 連接器驗證數據項用於供 JDBC 數 據源登錄數據庫。在 Integrated Solutions Console 中選擇 Security > Global security。下一步 ，在 Authentication 小標題中選擇 Java Authentication and Authorization Service > J2C authentication data 連接，如圖 5 所示。
圖 5. 創建 J2C 身份驗證數據
在用戶憑證和密碼表中，單擊 New。在新的標題中，在 Alias 字段中指定用戶別名，指定登錄 DB2 數據庫的 User Id，指定登錄 DB2 的密碼，如圖 6 所示。
圖 6. 指定 J2C 驗證數據屬性
單擊 Save 以將 J2C 驗證數據項保存到主配置中。一個 DB2 數據庫的登錄別名會被添加到 J2C 身份 認證數據表中，如圖 7 所示。
圖 7. 新的 J2C 驗證數據
為了配置一個 JDBC 數據源，選擇先前配置好的 JDBC 供應商。在 DB2 Universal JDBC Provider 標 題上，單擊 Datasources 鏈接，如圖 8 所示。
圖 8. 數據源
在 Data sources 表中單擊 New，創建一個新的數據源，指定一個 JNDI 名，然後單擊 Next，如圖 9 所示。這個 JNDI 名必須被用在將來創建 EJB V3.0 實體 Bean 的 persistence.xml 文件中。
圖 9. 創建一個數據源
為這個數據源指定一個數據源的相關屬性。分別選擇 Driver Type > 4，Database Name > SAMPLE，Server Name > localhost，Port Number > 50000。單擊 Next，如圖 10 所示。
圖 10. 指定數據源屬性
為這個數據源選擇 J2C 驗證數據，要選擇之前創建的驗證別名，單擊 Next，如圖 11 所示。
圖 11. 設置安全別名
在數據源的 Summary 頁中，選擇 Finish。一個新的數據源會被添加到這個表中。單擊 Save 將數據 源存儲到主配置中。選擇表中的 Data Source > Test Connection。該數據源連接測試將會顯示這個 測試是否成功，如圖 12 所示。
圖 12. 測試數據源連接
創建一個 DB2 數據表
通過一個命令行工具進入這個 DB2 數據庫，比如 Command Editor 或者 Command Line Processor。 為了在默認的示例數據庫 SAMPLE 中創建一個數據庫表，需要運行如下的 SQL 腳本。它會為 EJB v3.0 的實體 Bean 創建一個 Catalog 表。
CREATE TABLE Catalog (id INT PRIMARY KEY NOT NULL,
journal VARCHAR(100), publisher VARCHAR(100), date VARCHAR(100),
title VARCHAR(100), author VARCHAR(100));
在 Eclipse 中創建一個 EJB V3.0 項目
在 Eclipse IDE 中，選擇 File > New > Project。
在 New Project 窗口，選擇 EJB > EJB Project > Next。
在 New EJB Project 窗口，指定一個項目名稱（例如， EJB3EntityBean）。選擇 EJB Module Version > 3.0 > Next。
在 EJB Module 窗口，選擇默認的 Source Folder > ejbModule > Finish。
下一步，添加一個實體 Bean Java 類到 EJB V3.0 項目。選擇 File > New > Other，然後在 New 窗口中，選擇 Java > Class > Next。
在 New Java Class 窗口中，默認的 Source 文件夾是 EJB3EntityBean/ejbModule。指定一個包名（ 例如，com.ejb3.websphere）以及一個類名（Catalog），然後單擊 Finish。
一個實體 Bean Java 類被添加到 EJB V3.0 項目中。WebSphere V7 要求使用 JDK V6。如果還沒有安 裝，必須安裝 JDK V6。右鍵單擊 EJB 3.0 > Properties，然後選擇 Java Build Path 節點。添加 JRE System Library [jre6]，以及包含在 WebSphere V7 的 J2EE V5 JAR。創建一個庫 EJB3，然後添加 j2ee.jar 到這個庫中，如圖 13 所示。
圖 13. Java Build Path 中引用的庫
添加源代碼文件夾 ejbModule 到 Java Build Path，如圖 14。
圖 14. Java Build Path 的 Source 文件夾
采用與添加 Catalog.java Bean 類相似的方式，添加 Java 類 CatalogTestBean.java（會話 Bean） ，CatalogTestLocal.java（本地業務接口）和 CatalogTestRemote.java（遠程業務接口）。一個 EJB V3.0 實體 Bean 也需要在 META-INF 目錄中創建一個 persistence.xml 配置文件。
在 Project Explorer，選擇 META-INF > File > New > Other。
在 New 窗口中，選擇 XML > XML > Next。
在 New XML File 窗口中，選擇 ejbModule > META-INF 文件夾。指定 File Name > persistence.xml > Finish。一個 persistence.xml 文件會被添加到 META-INF 文件夾中。
在 EJB V3.0 項目中通過 File > New > Other > XML > XML 創建一個 build.xml 腳本 。在項目文件夾中創建一個 META-INF 文件夾，並將 application.xml 添加到該文件夾中。
在項目文件夾中為實體 Bean 的一個 JSP 客戶端創建一個 webModule 文件夾，然後將 EJB3Client.jsp 添加到該文件夾中。
添加一個 WEB-INF 文件夾到 webModule 文件夾中，然後添加一個 web.xml 文件到 WEB-INF 文件夾 中。EJB V3.0 項目的目錄結構如圖 15 所示。
圖 15. EJB V3.0 項目的目錄結構
創建一個 EJB V3.0 實體 Bean
與 EJB V2.0 不同，EJB V3.0 實體 Bean 都是 Plain Old Java Objects (POJO)。實體 Bean 映射使 用注釋定義，注釋在 JDK V5 中引入，位於 javax.persistence 包中。帶有 @Entity 注釋的 POJO 類就 是一個實體 Bean。實體 Bean 映射的模式和表是在類的級別上使用 @Table 注釋設置的。如果沒有 @Table 注釋，默認的表名就是實體 Bean 的類名。我們應該創建一個被映射到 Catalog 表的實體 Bean Catalog。
@Entity
@Table(name="Catalog")
public class Catalog implements Serializable {
...
}
如果一個啟用了緩存的實體 Bean 通過實體管理器持久化到一個數據庫中，實體 Bean 會由緩存進行 序列化。因此，建議實體 Bean 實現 java.io.Serializable 接口。在實體 Bean 類中，指定 POJO 屬性 。同時還要指定 serialVersionUID，序列化運行時使用它將版本號與可序列化的類關聯起來。為實體 Bean 屬性添加 getter 和 setter 方法。使用 @Id 注釋指定標識符（identifier）屬性。除此之外，還 有一些其他的 EJB V3.0 注釋，它們可以在實體 Bean 中指定。Catalog 實體 Bean 如清單 1 所示。
清單 1. 實體 Bean 類 Catalog.java
import java.io.Serializable;
import javax.persistence.*;
@Entity
@Table(name="Catalog")
public class Catalog implements Serializable {
private static final long serialVersionUID = 7422574264557894633L;
private long id;
private String journal;
private String publisher;
private String date;
private String title;
private String author;
public Catalog(){ super();}
public Catalog(Integer id, String journal, String publisher, String date,
String title, String author){
super();
this.id=id;
this.journal=journal;
this.publisher=publisher;
this.date=date;
this.title=title;
this.author=author;
}
@Id
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getJournal() {
return journal;
}
public void setJournal(String journal) {
this.journal = journal;
}
public String getPublisher() {
return publisher;
}
public void setPublisher(String publisher) {
this.publisher = publisher;
}
public String getEdition() {
return date;
}
public void setEdition(String date) {
this.date = date;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
}
創建一個持久化配置文件
persistence.xml 文件的根元素就是 persistence。其中 persistence-unit 需要指定名稱。 WebSphere V7 應用服務器已經配置了一個 JDBC 數據源，JNDI 名稱為 jdbc/DB2DS。在 persistence.xml 的 jta-data-source 元素中指定 JNDI 名稱。這個 properties 元素指定的是供應商 專用的屬性。屬性 hibernate.hbm2ddl.auto 被設置為 create-drop，這表示數據庫表會在每次解除部署 時刪除，而在每次重新部署時創建。在 Eclipse 中復制清單 2 到 persistence.xml 文件中。
清單 2. 配置文件 persistence.xml
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
<persistence-unit name="catalog">
<jta-data-source>jdbc/DB2DS</jta-data-source>
<properties>
<property name="hibernate.hbm2ddl.auto" value="create-drop"/>
</properties>
</persistence-unit>
</persistence>
WebSphere V7 的一個限制是，如果 persistence.xml 文件的 schema 位置在 persistence 元素中指 定了以下屬性，會產生一個錯誤。
xmlns:xsi="http://www.w3.org/2001/XMLSchema"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
創建一個會話 Bean
為了實現更好的性能，開發 EJB 的最佳實踐之一是從會話 Bean 訪問實體 Bean。使用無狀態會話 bean（消耗比有狀態會話 bean 更少的資源）調用實體 bean 方法。一個無狀態會話 Bean 類是用 @Stateless 注釋的。無狀態會話 Bean 類 CatalogTestBean 實現了 CatalogTestLocal 和 CatalogTestRemote 接口。使用 EntityManager API 創建、查找、查詢和刪除實體實例。使用注釋 @PersistenceContext 來注入一個 EntityManager。
@PersistenceContext
EntityManager em;
被部署到 WebSphere 服務器的會話 Bean（JNDI 綁定名稱 Session_Bean_Class_Name）對本地業務接 口使用默認的 JNDI 綁定名稱 ejblocal:Session_Bean_Class_Name。為了方便從一個 JSP 客戶端訪問 JNDI 名稱，可以為一個本地 JNDI 名稱賦予 public static final 變量。
public static final String LocalJNDIName = "ejblocal:"
+ CatalogTestBean.class.getSimpleName();
接下來，創建一個 test() 方法，它從測試客戶機返回一個 String。使用 test() 方法創建和持久化 實體實例，查詢一個實體實例，以及刪除一個實體實例，這些操作都需要使用一個 EntityManager 對象 ，這個對象之前已經注入到會話 Bean 類中。注入一個 EntityManager 表示該會話 Bean 能夠訪問 EntityManager 的一個實例。可以創建一個實體 Bean 類的實例。
Catalog catalog = new Catalog(new Integer(1), "IBM developerWorks", "IBM",
"July 2006", "The Java XPath API", "Elliotte Rusty Harold");
使用 persist() 方法持久化該實體實例。
em.persist(catalog);
類似地，持久化另外兩個實體實例。接下來，使用 EntityManager 對象的 createQuery 方法創建一 個查詢。字符串被指定為一個 EJB-QL 查詢。執行並使用 getResultList() 方法返回一個 List 形式的 結果。例如，選擇與作者 Elliotte Rusty Harold 相關的 catalog 記錄。
List catalogEntry = em.createQuery("SELECT c from Catalog c where c.author=:name").
setParameter("name", "Elliotte Rusty Harold").getResultList ();
為 test 方法的返回值創建字符串變量。
String retValue = "<b>A catalog entry: </b>";
遍歷結果列表以輸出實體實例的屬性。
for (Iterator iter = catalogEntry.iterator(); iter.hasNext();) {
Catalog element = (Catalog) iter.next();
retValue = retValue + "<br/>" + element.getJournal() + "<br/>"+
element.getPublisher() + "<br/>" + element.getDate() + "<br/>"+ element.getTitle() +
"<br/>" + element.getAuthor()+"<br/>";
}
創建和運行一個 EJB-QL 查詢以返回 Catalog 數據庫中的所有標題。
List allTitles = em.createQuery("SELECT c from Catalog c").getResultList();
實體實例可以使用 remove() 方法刪除。
em.remove(catalog2);
相關的數據庫記錄會從 Catalog 表刪除。然後，創建和運行一個查詢，列出所有映射到數據庫的其他 實體實例。會話 Bean 類 CatalogTestBean 如清單 3 所示。
清單 3. 會話 Bean CatalogTestBean.java
package com.ejb3.websphere;
import java.util.Iterator;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
@Stateless
public class CatalogTestBean implements CatalogTestRemote, CatalogTestLocal {
@PersistenceContext
EntityManager em;
public static final String LocalJNDIName = "ejblocal:"
+ CatalogTestBean.class.getSimpleName();
public String test() {
Catalog catalog = new Catalog(new Integer(1), "IBM developerWorks",
"IBM", "July 2006", "The Java XPath API",
"Elliotte Rusty Harold");
em.persist(catalog);
Catalog catalog2 = new Catalog(new Integer(2), "IBM developerWorks",
"IBM", "March 2009", "Use XQuery for the presentation layer",
"Brian M. Carey");
em.persist(catalog2);
Catalog catalog3 = new Catalog(new Integer(3), "IBM developerWorks",
"IBM", "April 2008", "Use XQuery from a Java environment",
"Brett McLaughlin");
em.persist(catalog3);
String retValue = "<b>A catalog entry: </b>";
List catalogEntry = em.createQuery(
"SELECT c from Catalog c where c.author=:name").setParameter(
"name", "Elliotte Rusty Harold").getResultList();
for (Iterator iter = catalogEntry.iterator(); iter.hasNext();) {
Catalog element = (Catalog) iter.next();
retValue = retValue + "<br/>" + element.getJournal() + "<br/>"
+ element.getPublisher() + "<br/>" + element.getDate()
+ "<br/>" + element.getTitle() + "<br/>"
+ element.getAuthor() + "<br/>";
}
retValue = retValue + "<b>All Titles: </b>";
List allTitles = em.createQuery("SELECT c from Catalog c")
.getResultList();
for (Iterator iter = allTitles.iterator(); iter.hasNext();) {
Catalog element = (Catalog) iter.next();
retValue = retValue + "<br/>" + element.getTitle() + "<br/>";
}
em.remove(catalog2);
retValue = retValue + "<b>All Entries after removing an entry: </b>";
List allCatalogEntries = em.createQuery("SELECT c from Catalog c")
.getResultList();
for (Iterator iter = allCatalogEntries.iterator(); iter.hasNext();) {
Catalog element = (Catalog) iter.next();
retValue = retValue + "<br/>" + element + "<br/>";
}
return retValue;
}
}
為該會話 Bean 添加一個遠程和本地接口（見清單 4）。
清單 4. 會話 Bean 的遠程和本地接口
package com.nubean.jboss.ejb3;
import javax.ejb.Remote;
@Remote
public interface CatalogTestRemote {
public String test();
}
package com.nubean.jboss.ejb3;
import javax.ejb.Local;
@Local
public interface CatalogTestLocal {
public String test();
}
創建一個測試客戶端
到目前為止，我們已經創建了一個包含業務邏輯的實體 Bean 和一個封裝實體 Bean 的會話 Bean。接 下來，我們要創建一個測試客戶端 JSP EJB3Client.jsp，其中會運行會話 Bean 的一個 test() 方法。 使用 JNDI 查找創建一個 CatalogTestLocal 實例，首先要創建一個 IntialContext 對象。使用會話 Bean 中的 JNDI 查找獲得一個 CatalogTestLocal 實例。
InitialContext context = new InitialContext();
CatalogTestLocal beanLocal = (CatalogTestLocal)
context.lookup(CatalogTestBean.LocalJNDIName);
調用會話 Bean 的 test() 方法並輸出下面的返回值。
String catalog=beanLocal.test();
<%=catalog %>
測試客戶端 JSP EJB3Client.jsp 如清單 5 所示。
清單 5. EJB3Client.jsp
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<%@ page import="com.ejb3.websphere.*, javax.naming.*" %>
<!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>EJB3 Client</title>
</head>
<body>
<% InitialContext context = new InitialContext();
CatalogTestLocal beanLocal = (CatalogTestLocal)
context.lookup(CatalogTestBean.LocalJNDIName);
String catalog=beanLocal.test();
%>
<%=catalog %>
</body>
</html>
WEB-INF/web.xml 指定了 Web 部署描述符。由於還沒有指定任何的 Web 配置，我們只需要將下面列 出的內容復制到 web.xml 中。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" version="2.5">
</web-app>
為 EJB 和 Web 模塊創建 application.xml 部署描述符。復制清單 6 中的內容到 application.xml 文件中。
清單 6. application.xml
<?xml version="1.0" encoding="UTF-8"?>
<application xmlns="http://java.sun.com/xml/ns/javaee" version="5"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/javaee/application_5.xsd">
<display-name></display-name>
<description></description>
<module>
<ejb>ejb3.jar</ejb>
</module>
<module>
<web>
<web-uri>websphere.war</web-uri>
<context-root>websphere</context-root>
</web>
</module>
</application>
將實體 Bean 部署到 WebSphere 中
現在，創建 EJB V3.0 實體 Bean 所需的所有類和配置文件都已經完成。下一步，我們要編譯類以創 建一個 EJB JAR 文件、一個 WAR 文件和一個 EAR 文件，然後將 EAR 文件部署到 WebSphere 服務器上 。我們使用一個 build.xml 腳本編譯 EJB 類，創建一個 EJB EAR 文件，並將 EJB EAR 文件部署到 WebSphere 上。對於 Apahce Ant 的介紹，可以參考 Apache Ant User Manual。在編譯腳本中，要指定 腳本所使用的各種目錄的屬性，如 WebSphere 服務器目錄，編譯目錄和 WebSphere 部署目錄。同時，也 要指定編譯 EJB 類所需要的各種 JAR 文件的類路徑。最後，指定表 1 所列的目標。
表 1. build.xml 中的目標
目標 描述 prepare 創建編譯目錄及編譯後的類的目錄 compile 編譯 EJB 類 jar 創建一個 EJB JAR 文件 war 創建一個 WAR 文件 assemble-app 創建一個 EAR 文件 deploy 部署 EAR 文件到 WebSphere 服務器。WebSphere 的部署目錄是 C:\Program Files\IBM\WebSphere\AppServer\installableApps clean 刪除 JAR、WAR 和 EAR 文件
Build.xml 腳本的內容如清單 7 所示。
清單 7. build.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
WebSphere build file
-->
<project name="ejb3" default="deploy" basedir=".">
<property environment="env" />
<property name="src.dir" value="${basedir}/ejbModule" />
<property name="src.resources" value="${basedir}/ejbModule" />
<property name="websphere.home" value="C:\Program Files\IBM\WebSphere" />
<property name="websphere.server" value="C:\Program Files\IBM\WebSphere\
AppServer"/>
<property name="build.dir" value="${basedir}/build" />
<property name="build.classes.dir" value="${build.dir}/classes" />
<property name="deploy.dir" value="${websphere.server}/installableApps" />
<path id="classpath">
<fileset dir="${websphere.server}/java/lib">
<include name="*.jar" />
</fileset>
<fileset dir="${websphere.server}/lib">
<include name="*.jar" />
</fileset>
<pathelement location="${build.classes.dir}" />
</path>
<property name="build.classpath" refid="classpath" />
<target name="prepare">
<mkdir dir="${build.dir}" />
<mkdir dir="${build.classes.dir}" />
</target>
<target name="compile" depends="prepare">
<javac srcdir="${src.dir}" destdir="${build.classes.dir}"
debug="on" deprecation="on" optimize="off" includes="**">
<classpath refid="classpath" />
</javac>
</target>
<target name="jar" depends="compile">
<jar jarfile="${build.dir}/${ant.project.name}.jar">
<fileset dir="${build.classes.dir}">
<include name="**/*.class" />
</fileset>
<fileset dir="${src.resources}/">
<include name="META-INF/persistence.xml" />
</fileset>
</jar>
</target>
<target name="war" depends="jar">
<war warfile="${build.dir}/websphere.war">
<fileset dir="webModule">
<include name="*.jsp" />
</fileset>
<fileset dir="webModule">
<include name="WEB-INF/web.xml" />
</fileset>
</war>
</target>
<target name="assemble-app" depends="war">
<jar jarfile="${build.dir}/${ant.project.name}.ear">
<metainf dir="META-INF">
<include name="application.xml" />
</metainf>
<fileset dir="${build.dir}" includes="*.jar,*.war" />
</jar>
</target>
<target name="deploy" depends="assemble-app">
<copy file="${build.dir}/${ant.project.name}.ear" todir="${deploy.dir}" />
</target>
<target name="clean">
<delete file="${build.dir}/${ant.project.name}.ear" />
<delete file="${build.dir}/${ant.project.name}.jar" />
<delete file="${build.dir}/websphere.war" />
</target>
</project>
在 Eclipse 中運行編譯腳本。在 Package Explorer中，右鍵單擊 build.xml > Run As > Ant Build，如圖 16 所示。
圖 16. 運行 build.xml
編譯腳本中的默認編譯目標是 deploy，而每一個目標都依賴於之前一個目標。在 prepare、compile 、jar、war、assemble-app 和 deploy 目標運行後，所產生的 EAR 文件 ejb3.ear 會被部署到 WebSphere 服務器上，如圖 17 所示。
圖 17. 運行 build.xml
在 WebSphere Application Server 上安裝 EJB V3.0
在 Administrative Console 上，單擊 Applications > New Application。在 New Application 標題上，單擊 New Enterprise Application。指定 ejb3.ear 文件的路徑，然後單擊 Next，如圖 18 所 示。
圖 18. 指定要安裝的 EAR 文件
在 “How do you want to install the application” 選項中，選擇 Detailed > Next。對於 “Select installation options header” 選項，單擊復選框 Precompile JavaServer Pages files 和 Deploy enterprise beans。指定安裝應用程序的目錄為 “C:\Program Files\IBM\WebSphere\AppServer\profiles\AppSrv01\installedApps\dvohra09- PCNode01Cell” （Windows 環境中），然後單擊 Next，如圖 19 所示。安裝路徑的 scope 目錄可能會與本例不同。
圖 19. 指定安裝選項
在 “Clusters and server” 標題中選擇默認設置，然後單擊 Next。在 “Provide options to compile JSPs” 中選擇默認設置，然後單擊 Next。在 “Provide options to perform the EJB deploy ” 標題中，選擇 Database > 9.5，JDK compilation level > 6.0 和 Database access > JDBC> Next，如圖 20 所示。
圖 20. 指定 EJB 部署選項
在 “Provide JSP reloading options for Web module” 標題上，選擇默認設置，然後單擊 Next。 在 “Map shared libraries” 標題中，選擇默認設置，然後單擊 Next。在 “Map shared library relationships” 標題中，選擇默認設置，然後單擊 Next。在 “Provide JNDI names for beans” 標 題中，選擇 JNDI name for all interfaces，然後指定 Target Resource JNDI name，如圖 21 所示， 然後單擊 Next。
圖 21. 指定會話 Bean 的 JNDI 名稱
在 “Bind EJB Business” 標題中，選擇默認設置，然後單擊 Next。在 “Map virtual hosts for Web modules” 標題中，選擇 WAR 文件 websphere.war，並選擇 “default_host” Virtual Host，然 後單擊 Apply。單擊 Next。在 Map context roots for Web modules 標題中，指定 websphere.war Web 模塊的上下文根目錄為 “websphere”。單擊 Next。在 “Metadata for modules” 標題中，選擇默認 設置，然後單擊 Next。在 “Summary” 頁面，單擊 Finish。這樣就部署了 EAR 文件 ejb3.ear 和 EJB JAR 文件 ejb3.jar，如圖 22 所示。單擊 Save 保存主配置文件修改。
圖 22. 安裝 EAR 文件
單擊 Start 初始化 EJB3 應用程序，然後應用程序會被安裝和啟動，如圖 23 所示。
圖 23. 啟動 EAR 應用程序
要運行 EJB V3.0 實體 Bean 的 JSP 客戶端，必須通過 URL 地址 http://localhost:9080/websphere/Catalog.jsp 訪問 JSP。然後會話 Bean 的 test() 方法會被調用。 其中有三個實體 Bean 實例會被創建並持久化到 DB2 中。如圖 24 所示的客戶端 JSP 輸出，實體實例中 與作者 Elliotte Rusty Harold 相關的實體 Bean 屬性會被列出。所有實體實例的標題都會被列出。用 於檢索所有實體實例的後續查詢表明刪除了一個實體實例，因此只列出了兩個實體實例。
圖 24. 運行 EJB V3 實體 Bean 客戶端
結束語
EJB V3.0 支持是 WebSphere V7 的一個新特性。Eclipse、WebSphere7 和 DB2 9.5 的組合是一個開 發 EJB v3.0 實體 Bean 的理想方法。
原文地址：http://www.ibm.com/developerworks/cn/opensource/os-eclipse-ejb3/index.html
本文配套源碼：http://www.bianceng.net/java/201212/692.htm
