Eclipse 中的 EJB V3.0 数据库持久化

核心提示：简介在应用程序开发领域中，数据可用性发生了变化，Eclipse 中的 EJB V3.0 数据库持久化，不同的数据来自不同的来源，一方面，因此只列出了两个实体实例，图 24. 运行 EJB V3 实体 Bean 客户端结束语EJB V3.0 支持是 WebSphere V7 的一个新特性，这使得应用程序比以前更加丰富；另

简介

在应用程序开发领域中，数据可用性发生了变化。不同的数据来自不同的来源。一方面，这使得应用程序比以前更加丰富；另一方面，所有这些数据可能会变得难以处理。如果您需要去持久化数据，而不仅仅是读取它，情况会变得更加复杂。

在 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 的理想方法。

本文示例源代码或素材下载