在应用程序开发领域中，数据可用性发生了变化。不同的数据来自不同的来源。一方面，这使得应用程序比以前更加丰富；另一方面，所有这些数据可能会变得难以处理。如果您需要去持久化数据，而不仅仅是读取它，情况会变得更加复杂。
在 Java 环境中，EJB 作为一种可靠的持久化方法出现，它能够实现很好的维护和恰当的角色分离。EJB V3.0 在继续发展，越来越多的工具和方法也不断地出现。使用 EJB 不会很难。对于 Eclipse 和一些基本的概念，您可以在您的应用程序中利用它们。
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 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 数据库，比如 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 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 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" |
为了实现更好的性能，开发 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> |
现在，创建 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 的理想方法。
下载
| 描述 | 名字 | 大小 | 下载方法 |
|---|---|---|---|
| EJB 3.0 类 | os-eclipse-ejb3-EJB3EntityBean.zip | 5KB | HTTP |
学习
- 查看 EJB 3.0 Specification，了解 EJB V3.0 Specification。
- 阅读 Apache Ant User Manual 以了解 Apache Ant 编译脚本中使用的元素。
- 阅读 “最佳实践：EJB — 从 EJB 会话 bean 访问 EJB 实体 bean” 以了解访问实体 Bean 的最佳实践指南。
- 阅读 “使用 WebSphere Application Server 构建 EJB 3.0 应用程序”，了解在 WebSphere V6.1 中创建 EJB V3.0 应用程序的方法。
- 在 SOA 项目的需求过程，第 1 部分: 为 SOA 应用获取需求，获取帮助您提升体系结构方面的技能的资源。
- 获取 “推荐 Eclipse 阅读清单”。
- 浏览 developerWorks 上的所有 Eclipse 内容。
- 如果是 Eclipse 初学者，请阅读 developerWorks 上的文章 “Eclipse 平台入门” 以了解它的起源和架构，以及如何通过插件扩展 Eclipse。
- 通过浏览 IBM developerWork 的 Eclipse 项目资源 扩展您的 Eclipse 技能。
- 要收听面向软件开发人员的有趣访谈和讨论，请查看 developerWorks 播客。
- My developerWorks 社区涵盖了大量主题，是一个成功的社区典范。
- 随时关注 developerWorks 技术活动和网络广播。
- 查看免费的 developerWorks 演示中心 观看并了解 IBM 及开源技术和产品功能。
- 查阅最近将在全球举办的面向 IBM 开放源码开发人员的研讨会、交易展览、网络广播和其他 活动。
- 访问 developerWorks Open source 专区获得丰富的 how-to 信息、工具和项目更新以及最受欢迎的文章和教程，帮助您用开放源码技术进行开发，并将它们与 IBM 产品结合使用。
获得产品和技术
- 下载 WebSphere V7 Application Server。
- 下载 Eclipse (Ganymede) V3.4.0 IDE for Java EE Developers。
- 下载 IBM DB2 V9.5 Trial edition。
- 下载 IBM DB2 V9.7 Trial and Community editions。
- 下载 WebSphere Application Server Community Edition。
- 下载 JDK V6。
- 获取 IBM alphaWorks 上最新的 Eclipse 技术下载。
- 下载 Eclipse Foundation 的 Eclipse Platform 及其他项目。
- 下载 IBM 产品评估试用版软件 或 IBM SOA Sandbox for People，并使用来自 DB2®、Lotus®、Rational®、Tivoli® 和 WebSphere® 的应用程序开发工具和中间件产品。
- 使用 IBM 产品评估试用版软件 改进您的下一个开发项目，这些软件可以通过下载获得。
讨论
- Eclipse Platform 新闻组 应当是讨论关于 Eclipse 的问题的第一站（选择此链接将启动默认的 Usenet 新闻阅读器应用程序并打开 eclipse.platform）。
- Eclipse 新闻组 中有很多参考资料适用于对使用和扩展 Eclipse 感兴趣的人员。
- 参与 developerWorks 博客 并加入 developerWorks 社区。
4969
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
