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

红薯 发布于 2010/05/05 21:15
阅读 797
收藏 2

简介: 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 和 DB2

启动 WebSphere Application Server。在 First Steps Console 中,选择 Start the server。该 WebSphere 服务器就会启动,如图 1 所示。


图1. 启动 WebSphere v7 Application Server
屏幕截图显示 WebSphere Application Server V7 启动时的控制台信息

下一步,通过选择 Administrative Console 链接启动 Administrative Console/Integrated Solutions Console。在 Integrated Solution Console 窗口中,选择 JDBC 供应商表中的 Resources > JDBC > JDBC > New,如图 2 所示。


图 2. 创建一个新的 JDBC 供应商
屏幕截图显示配置了 JDBC 供应商的 WebSphere Application Server  Administrative Console

Create a new JDBC Provider 窗口中,先选择 Database > DB2, Provider > DB2 Universal JDBC Driver Provider,然后选择 Implementation > Connection pool datasource,然后单击 Next,如图 3 所示。


图 3. 设置配置值
屏幕截图显示特定 JDBC 数据资源配置

Summary 页面中列出 JDBC 供应商配置的汇总。选择 Finish。一个新的 JDBC 供应商被添加到 JDBC providers 表中。选择这个新的 JDBC 供应商,接着单击 Save 将 JDBC 供应商存储到主配置中,如图 4 所示。


图 4. 新的 JDBC 供应商
屏幕截图显示成功配置的 JDBC 供应商的 Administrative Console

在配置数据源之前,需要配置一个 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. 数据源
屏幕截图显示定义了 JDBC 数据源后的 WebSphere Application Server V7  Administrative Console

在 Data sources 表中单击 New,创建一个新的数据源,指定一个 JNDI 名,然后单击 Next,如图 9 所示。这个 JNDI 名必须被用在将来创建 EJB V3.0 实体 Bean 的 persistence.xml 文件中。


图 9. 创建一个数据源
屏幕截图显示配置了一个数据源后的 WebSphere Application Server V7  Administrative Console

为这个数据源指定一个数据源的相关属性。分别选择 Driver Type > 4Database Name > SAMPLEServer Name > localhostPort Number > 50000。单击 Next,如图 10 所示。


图 10. 指定数据源属性
屏幕截图显示定义了数据源属性的 WebSphere Application Server V7  Administrative Console

为这个数据源选择 J2C 验证数据,要选择之前创建的验证别名,单击 Next,如图 11 所示。


图 11. 设置安全别名
屏幕截图显示定义了数据库安全别名后的 WebSphere Application Server V7  Administrative Console

在数据源的 Summary 页中,选择 Finish。一个新的数据源会被添加到这个表中。单击 Save 将数据源存储到主配置中。选择表中的 Data Source > Test Connection。 该数据源连接测试将会显示这个测试是否成功,如图 12 所示。


图 12. 测试数据源连接
屏幕截图显示测试数据连接性时的 WebSphere Application Server V7  Administrative Console

创建一个 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 项目

  1. 在 Eclipse IDE 中,选择 File > New > Project
  2. New Project 窗口,选择 EJB > EJB Project > Next
  3. New EJB Project 窗口,指定一个项目名称(例如, EJB3EntityBean)。选择 EJB Module Version > 3.0 > Next
  4. 在 EJB Module 窗口,选择默认的 Source Folder > ejbModule > Finish
  5. 下一步,添加一个实体 Bean Java 类到 EJB V3.0 项目。选择 File > New > Other,然后在 New 窗口中,选择 Java > Class > Next
  6. New Java Class 窗口中,默认的 Source 文件夹是 EJB3EntityBean/ejbModule。指定一个包名(例 如,com.ejb3.websphere)以及一个类名(Catalog),然后单击 Finish
  7. 一个实体 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 中引用的库
屏幕截图显示 Java Build Path 中定义了库时的 Eclipse 配置

添加源代码文件夹 ejbModule 到 Java Build Path,如图 14。


图 14. Java Build Path 的 Source 文件夹
屏幕截图显示添加文件夹 ejbModule 后的 Eclipse Java Build Path 配置

采用与添加 Catalog.java Bean 类相似的方式,添加 Java 类 CatalogTestBean.java(会话 Bean),CatalogTestLocal.java(本 地业务接口)和 CatalogTestRemote.java(远程业务接口)。一个 EJB V3.0 实体 Bean 也需要在 META-INF 目录中创建一个 persistence.xml 配置文件。

  1. 在 Project Explorer,选择 META-INF > File > New > Other
  2. New 窗口中,选择 XML > XML > Next
  3. New XML File 窗口中,选择 ejbModule > META-INF 文件夹。指定 File Name > persistence.xml > Finish。一个 persistence.xml 文件会被添加到 META-INF 文件夹中。
  4. 在 EJB V3.0 项目中通过 File > New > Other > XML > XML 创建一个 build.xml 脚本。在项目文件夹中创建一个 META-INF 文件夹,并将 application.xml 添加到该文件夹中。
  5. 在项目文件夹中为实体 Bean 的一个 JSP 客户端创建一个 webModule 文件夹,然后将 EJB3Client.jsp 添加到该文件夹中。
  6. 添加一个 WEB-INF 文件夹到 webModule 文件夹中,然后添加一个 web.xml 文件到 WEB-INF 文件夹中。EJB V3.0 项目的目录结构如图 15 所示。


图 15. EJB V3.0 项目的目录结构
Eclipse 中的项目的屏幕截图,显示了文件结构

创建一个 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.xmljta-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 实现了 CatalogTestLocalCatalogTestRemote 接口。使用 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
屏幕截图显示 Eclipse 中的上下文菜单打开到 'Run As' 并显示选项

编译脚本中的默认编译目标是 deploy,而每一个目标都依赖于之前一个目标。在 preparecompilejarwarassemble-appdeploy 目标运行后,所产生的 EAR 文件 ejb3.ear 会被部署到 WebSphere 服务器上,如图 17 所示。


图 17. 运行 build.xml
Eclipse 屏幕截图显示 Ant 编译过程的执行

在 WebSphere Application Server 上安装 EJB V3.0

在 Administrative Console 上,单击 Applications > New Application。在 New Application 标题上,单击 New Enterprise Application。指定 ejb3.ear 文件的路径,然后单击 Next,如图 18 所示。


图 18. 指定要安装的 EAR 文件
屏幕截图显示 WebSphere Application Server 管理控制台中 EAR 文件正在进行部署配置

在 “How do you want to install the application” 选项中,选择 Detailed > Next。对于 “Select installation options header” 选项,单击复选框 Precompile JavaServer Pages filesDeploy 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.5JDK compilation level > 6.0Database access > JDBC> Next, 如图 20 所示。


图 20. 指定 EJB 部署选项
屏幕截图显示部署应用程序的 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 名称
屏幕截图显示应用程序部署的 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 文件
屏幕截图显示 EAR 文件的成功安装

单击 Start 初始化 EJB3 应用程序,然后应用程序会被安装和启动,如图 23 所示。


图 23. 启动 EAR 应用程序
屏幕截图显示运行在 WebSphere Application Server V7 Administrative  Console 中的 EJB3 应用程序

要运行 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 实体 Bean 客户端

结束语

EJB V3.0 支持是 WebSphere V7 的一个新特性。Eclipse、WebSphere7 和 DB2 9.5 的组合是一个开发 EJB v3.0 实体 Bean 的理想方法。

加载中
返回顶部
顶部