在上一部分中，我们了解了 EJB 3.0 标准和 OpenJPA 的基本特性，现在我们 将开始讲述如何使用 OpenJPA 开发企业应用。本文中，我们将假设有一个 Animal 对象，在某一个应用场景中，我们需要使用 OpenJPA 框架提供的工具和 接口完成 Animal 对象的持久化、属性修改、删除、查找功能。本文将通过简单 的文字和代码描述使用 OpenJPA 开发的步骤和方法，以及开发过程中如何使用 OpenJPA 提供的工具协助完成开发任务。
下载及安装 OpenJPA
支持环境准备
由于 OpenJPA 是基于注释机制的框架，这需要用到 JDK 5.0 或者以上版本， 因此请确保在工作机器上已经下载和安装了 JDK 5.0。
演示过程中，我们需要一个数据库作为对象持久化的目标数据库。出于简单和 方便的考虑，我们选择采用 MySQL 数据库，因此您需要下载 MySQL 数据库安装 包。如果需要 MySQL 很好的支持中文字符（GB2312 编码），您可选择下载 MySQL 5.0 或者以上版本，安装的时候选择数据库字符集为 GB2312 即可。
下载、安装 OpenJPA
OpenJPA 的最新稳定版本是 Open JPA 0.97。OpenJPA 的安装比较简单，只需 要将下载的压缩文件解压即可。我们假设将下载的压缩包解压到 C:/OpenJPA 目 录下（本文后面将使用 %OPENJPA_HOME% 来引用这个目录）。
使用 OpenJPA 开发 EJB 3.0 应用
成功安装 OpenJPA 后，我们就可以开始应用 OpenJPA 框架开发 EJB 3.0 应 用了。下面的章节中我们将讲述应用 OpenJPA 框架开发 EJB 3.0 应用的主要步 骤。为了把描述集中在 OpenJPA 本身而不涉及太多的其它内容，在本演示场景中 ，我们在轻量级应用中来使用 OpenJPA，开发出的应用基于 Java SE 环境运行， 而不依赖于 EJB 容器，关于如何在 Java EE 中配置使用 OpenJPA 将是另外一个 主题，本文将暂不涉及，本系列的后续文章中将会讨论这个主题。
通常情况下，使用 OpenJPA 框架开发持久层主要有以下步骤：
编写（或修改）OpenJPA 配置文件；
在非 JavaEE 环境下，OpenJPA 通常使用 CLASSPATH 环境下的 META- INF/persistence.xml 文件来创建 EntityManagerFacTory，而每一个被管理的 Java 实体类必须在 persistence.xml 中注册后才能被 EneityManager 处理。
根据业务需要设计 Java 对象、编写对应的 Java 实体类；
用 JDK 编译 Java 实体类；
用 OpenJPA 提供的工具 — PCEnhancer 来增强（enhance）编译好的 Java 实体类；被增强过的类可以提供更好的运行性能、灵活的 “懒加载” 等方面的优 势，更多详细的内容请参考 OpenJPA 的帮助文档。
使用 OpenJPA 提供的工具 MappingTool 从 Java 对象生成数据库定义文件（ DDL）；
可以通过 MappingTool 工具直接保持 Entity 和数据库之间的一致性，也可 以使用 MappingTool 工具生成的数据库定义文件（DDL）创建应用正常运行所需 要的数据库结构。
将创建的实体类注册到 OpenJPA 容器中；
应用 JPA 接口编写实体类访问代码，实现相应的业务逻辑。
下面我们将用一个简单的例子来说明创建 OpenJPA 应用的典型步骤，实例中 我们将创建名为 Animal 的持久化对象，它有两个属性，分别是 “id”和 “name”，Animal 对象将被持久化到本地的 MySQL 数据库中，其中 id 属性对 应的数据库字段由 MySQL 数据库自动生成。
开发环境说明
本文的演示说明均基于 Windows XP 平台，JDK 版本为 1.5.0_11，数据库服 务器为 MySQL 5.0，和演示代码位于同一台机器上。所有演示用例对应的 MySQL 数据库为“openjpa”，访问 MySQL 的用户名和密码也均为“openjpa”。
OpenJPA 应用开发典型步骤
请读者注意，后面章节中关于操作的说明 均基于 Windows XP 操作系统，如果您使用的开发环境运行在其它类型的操作系 统之上，请根据实际情况做出相应的调整。
建立工程目录
在 C: 盘根目下创建名为 OpenJPAExamples 的目录，我 们所有的类文件和配置文件都将放在这个目录下。
编写 JPA 配置文件
在 C:/OpenJPAExamples 新建 META-INF 目录，随后在该目录下创建 persistence.xml 文件。persistence.xml 是 OpenJPA 的配置文件，提供 OpenJPA 容器初始化、运行所需要的配置信息。比如 OpenJPA 的事务策略、数据 库的连接信息等。清单 1 中是我们演示实例中所使用的 persistence.xml 文件 的内容。
清单 1 META-INF/persistence.xml
1. 2. 5. <!—persistence-unit的name属性提 供了创建EntityManagerFacotry时的 6. 关键字， transaction-type则指定了使用的事务管理类型，这里使7. 用 ‘RESOURCE_LOCAL’参数表示使用本地事务 8. 9. <!—JPA的提供类， OpenJPA的设置如下，如果使用其它的JPA实现，这里10. 的 内容需要修改成相应的提供类 11. 12. org.apache.openjpa.persistence.PersistenceProviderImpl13. 14.15. <! —OpenJPA容器中管理的实体类列表 16. org.vivianj.openjpa.entity.Animal17. <!—OpenJPA容器访问数据库的参数 18. 19. 21. 23. 25. 27. 28. 29.
创建实体类
新创建实体类 Animal，为了说明的简单，该类只有两个属性：id 和 name， 其中 id 字段代表的是编号（编号由 MySQL 数据库自动生成），name 属性表示 名称。实体类的全部代码见清单 2，请注意其中的黑体部分，它们是 JPA 中定义 的注释（Annotation），Animal 中仅仅用到了非常少的几个注释，了解其它更多 注释的细节请参看 OpenJPA 的帮助文档。
清单 2 Animal.java
1. package org.vivianj.openjpa.entity；2.3. import javax.persistence.Basic；4. import javax.persistence.Entity；5. import javax.persistence.GeneratedValue；6. import javax.persistence.GenerationType；7. import javax.persistence.Id；8.9. /*10. * 使用Entity注释表示该类是实体类，它的name属性是该实体在查询中 对应的11. * 唯一名称，如果没有提供Entity的name属性，默认的name属性是类名 。12. */13. @Entity14. public class Animal {15. // 编号16. /* 使用Id注释表示该字段是标识字段 */17. @Id18. /*19. * 使用GeneratedValue注释定义该标识字段的产生方式，我们的演 示系统中20. * id由mysql数据库字段自动生成，因此选择 GenerationType.IDENTITY，21. * 另外的可选方式包括GeneraTorType.AUTO， GenerationType.SEQUENCE，22. * GenerationType.TABLE。23. */24. @GeneratedValue（strategy = GenerationType.IDENTITY）25. private int id；26.27. // 名称28. /*29. * Basic注释表示该属性是持久化属性，没有使用Basic注释的属性 将不会30. * 被持久化到数据库中31. */32. @Basic 33. private String name；34.35. public int getId（） {36. return id；37. }38.39. public void setId（int id） {40. this.id = id；41. }42.43. public String getName（） {44. return name；45. }46.47. public void setName（String name） {48. this.name = name；49. }50.51. }
编译实体类
打开命令行控制台，进入 C:/OpenJPAExamples 目录，执行下面的系列语句可 以编译实体类 Animal.java。
C:/OpenJPAExamples>set OPENJPA_HOME=C:/OpenJPAC:/OpenJPAExamples>set classpath=%OPENJPA_HOME%/lib/persistence- api-1.0.jarC:/OpenJPAExamples>javac Animal.java -d
[注] 上面的命令行中第一行出现的 C:/OpenJPA 是指 OpenJPA 框架的安装目 录。如果您没有使用 C:/OpenJPA 作为 OpenJPA 的安装目录，请将 OPENNJPA_HOME 的值修改为您安装 OpenJPA 的目录。
增强（Enhance）实体类
Enhance 是使用 OpenJPA 必须的一个步骤，所谓 Enhance 是指使用 OpenJPA 提供的工具 PCEnhancer（org.apache.openjpa.enhance.PCEnhancer）对实体类 进行处理的过程，被 Enhance 过的实体类能够支持性能优化、懒惰式装载等高级 特性。
OpenJPA 支持在编译时、部署时、运行时增强实体类，我们以编译时为例了解 如何增强实体类。我们使用下面的系列语句完成实体类的增强（Enhance）。
1. C:/OpenJPAExamples>set OPENJPA_HOME=C:/OpenJPA2. C:/OpenJPAExamples>set classpath= %OPENJPA_HOME% /lib/commons-collections-3.2.jar; %OPENJPA_HOME%/lib/commons-lang-2.1.jar; %OPENJPA_HOME%/lib/commons-logging-1.0.4.jar; %OPENJPA_HOME%/lib/commons-pool-1.3.jar; %OPENJPA_HOME%/lib/geronimo-j2ee-connecTor_1.5_spec-1.0.1.jar; %OPENJPA_HOME%/lib/geronimo-jms_1.1_spec-1.0.1.jar; %OPENJPA_HOME%/lib/geronimo-jta_1.0.1B_spec-1.0.1.jar; %OPENJPA_HOME%/lib/persistence-api-1.0.jar; %OPENJPA_HOME%/lib/serp-1.11.0.jar; %OPENJPA_HOME%/openjpa-all-0.9.6-incubating.jar3. C:/OpenJPAExamples>java org.apache.openjpa.enhance.PCEnhancer Animal.java
有兴趣的读者可以使用反射（Reflect）机制获取经过 Enhance 的类的信息， 清单 3 中给出了被 Enhance 过后 Animal 实体类的类声明和方法签名信息，从 中我们可以看到 Animal 被增加了新的 org.apache.openjpa.enhance.PersistenceCapable 接口，而该接口声明的方法 都是和实体创建、状态保持等相关的。事实上，OpenJPA 通过 Enhance 过程修改 我们的实体类，扩充了实体类的能力，从而实现性能优化、懒惰式装载等高级特 性。
清单 3 Animal 被 Enhance 过后的类声明和方法信息
1. public class org.vivianj.openjpa.entity.Animal2. extends java.lang.Object3. implements org.apache.openjpa.enhance.PersistenceCapable {4. protected transient org.apache.openjpa.enhance.StateManager pcStateManager;5. protected transient byte pcFlags;6. static java.lang.Class class$Ljava$lang$String;7. static java.lang.Class class$Lorg$vivianj$openjpa$entity$Animal;8. public org.vivianj.openjpa.entity.Animal（）;9. public int getId（）;10. public void setId（int）;11. public java.lang.String getName（）;12. public void setName（java.lang.String）;13. static final {};14. static java.lang.Class class$（java.lang.String）;15. protected void pcClearFields（）;16. public org.apache.openjpa.enhance.PersistenceCapable pcNewInstance（17. org.apache.openjpa.enhance.StateManager, java.lang.Object, boolean）;18. public org.apache.openjpa.enhance.PersistenceCapable pcNewInstance（19. org.apache.openjpa.enhance.StateManager, boolean）;20. protected static int pcGetManagedFieldCount（）;21. public void pcReplaceField（int）;22. public void pcReplaceFields（int[]）;23. public void pcProvideField（int）;24. public void pcProvideFields（int[]）;25. protected void pcCopyField （org.vivianj.openjpa.entity.Animal, int）;26. public void pcCopyFields（java.lang.Object, int[]）;27. public java.lang.Object pcGetGenericContext（）;28. public java.lang.Object pcFetchObjectId（）;29. public boolean pcIsDeleted（）;30. public boolean pcIsDirty（）;31. public boolean pcIsNew（）;32. public boolean pcIsPersistent（）;33. public boolean pcIsTransactional（）;34. public boolean pcSerializing（）;35. public void pcDirty（java.lang.String）;36. public org.apache.openjpa.enhance.StateManager pcGetStateManager（）;37. public java.lang.Object pcGetVersion（）;38. public void pcReplaceFlags（）;39. public synchronized void pcReplaceStateManager（40. org.apache.openjpa.enhance.StateManager）41. throws java.lang.SecurityException;42. public void pcCopyKeyFieldsToObjectId（43. org.apache.openjpa.enhance.FieldSupplier, java.lang.Object）;44. public void pcCopyKeyFieldsToObjectId （java.lang.Object）;45. public void pcCopyKeyFieldsFromObjectId（46. org.apache.openjpa.enhance.FieldConsumer, java.lang.Object）;47. public void pcCopyKeyFieldsFromObjectId（java.lang.Object ）;48. public java.lang.Object pcNewObjectIdInstance （java.lang.Object）;49. public java.lang.Object pcNewObjectIdInstance（）;50. public java.lang.Boolean pcIsDetached（）;51. public java.lang.Object pcGetDetachedState（）;52. public void pcSetDetachedState（java.lang.Object）;53. }
将新创建的实体类注册到 OpenJPA 容器中
在 OpenJPA 框架中，如果创建了新的实体类，必须通过修改配置文件，将它 注册到 OpenJPA 容器中，该实体类才能够被 OpenJPA 管理。将实体类方法注册 到 OpenJPA 容器中的方法是在 persistence.xml 中对应的 persistence-unit 元素下增加子元素 class，元素的内容就是被注册持久类的全名。比如我们要把 org.vivianj.openjpa.entity.Animal 注册到 OpenJPA 容器中，我们可以在 persistence.xml 中加入如下内容：
1. 2. 3. …4. org.vivianj.openjpa.entity.Animal5. …6. 7.
准备数据库
在 MySQL 数据库中新建名为“openjpa”的数据库。新创建数据库的访问用户 为“openjpa”，密码设置为“openjpa”，新创建的用户“openjpa”必须具有访 问读写“openjpa”数据库数据的权限。
保持实体类和数据库表结构一致性
OpenJPA 中提供了专门的 MappingTool （org.apache.openjpa.jdbc.meta.MappingTool）工具协助开发者保持实体类和 数据库表结构之间的一致性。MappingTool 工具能够自动的根据实体类中提供的 注释（Annotation），识别出对象、对象之间的继承/包含等关系以及如何在关系 型数据库中处理这些关系的设置，自动保证实体类和数据库之间的一致性，开发 者也可以选择使用 OpenJPA 生成创建数据库所需要的 SQL 语句，然后手动的保 持实体类和数据库之间的一致性。
可以使用下面的命令语句直接通过 MappingTool 在数据库中创建 OpenJPA 应 用所需要的数据库表。
java org.apache.openjpa.jdbc.meta.MappingTool Animal.java
命令执行完成后，我们通过 MySQL 的客户端访问 OpenJPA 数据库，可以发现 里面已经创建了名为“animal”的数据表。如果开发者不想让 MappingTool 自动 维护 OpenJPA 和数据库之间的映射，而只是想让 MappingTool 协助生成创建数 据库所需要的数据库表定义文件（DDL），可以使用下面的命令语句，其中的参数 -sql 的值就是生成数据库表定义文件的位置。
比如要将生成的数据库表定义文件写入当前文件夹下 animal.sql 文件的命令 如下：
java org.apache.openjpa.jdbc.meta.MappingTool –sql animal.sql Animal.java
[注] 要成功执行 MapptingTool 工具，必须先将数据库的 JDBC 驱动放入到 classpath 中，否则会得到一个 org.apache.openjpa.util.SToreException 类 型的异常信息。
访问持久化对象
访问 OpenJPA 容器中管理的持久化对象所需要的基本步骤如下：
获取 OpenJPA 容器中配置好的 EntityManagerFacTory 对象；
从 EntityManagerFacTory 中获取 EntityManager 对象；
如果是处理持久化对象的创建、更新、删除动作，还需要从 EntityManager 中获取 EntityTransaction，并且调用其 begin（commit）方法显式的启动（提 交）事务；
操作持久化对象
调用 EntityManager 的 persist 方法可以持久化对象到数据库中；
调用 EntityManager 的 merge 方法可以更新对象状态；
调用 EntityManager 的 remove 方法可以删除持久化对象，另外一种选择是 通过 Query 接口删除对象。
查询持久化对象
根据对象的主键查找符合条件的对象，可以直接使用 EntityManager 的 find 方法；
要查询 EntityManager 中符合条件的对象列表，还需要借助 Query 接口和 JPQL（Java Persistence Query Language）查询语言。
下面的章节中我们将逐一了解如何通过 OpenJPA 中的相关接口完成这些步骤 。
获取 OpenJPA 容器中的 EntityManagerFacTory
EntityManagerFacTory 是 OpenJPA 中创建 EntityManager 的工厂，要想得 到 EntityManager，就必须获取的相应的 EntityManagerFacTory。
EntityManagerFacTory 通过 Persistence 的静态方法 createEntityManagerFacTory 获得，该方法是一个重载的方法，支持不同的输入 参数。最常用的是使用一个字符串作为参数，该字符串的内容是 EntityManagerFacTory 的标识名，该标识名需要和 persistence.xml 文件中的 persistence-unit 元素的 name 属性保持一致。可以使用 null 作为 createEntityManagerFacTory 方法的参数，这时候将使用 persistence.xml 中 没有提供 name 属性的 persistence-unit 元素提供的参数来配置 EntityManagerFacTory。
下面的代码段可以从 OpenJPA 容器中获取名为“mysql”的 EntityManagerFacTory。
EntityManagerFacTory facTory = Persistence.createEntityManagerFacTory（"mysql"）；
而它对应的 persistence.xml 文件中，应该有相应的 name 属性为“mysql” 的 persistence-unit 元素，下面的配置是一个示例。
1. 4. 5. …6. 7.
为了提升软件的执行效率，我们通常选择在某一个范围内缓存 EntityManagerFacTory 对象。在 EntityManagerFacTory 使用完后，我们需要调 用它的 close 方法来释放相应的资源。获取、使用 EntityManagerFacTory 的实 际例子请参考 清单 4 AnimalDAOImpl.java 中的源代码。
获取 EntityManager
要访问 OpenJPA 容器中的实体类，必须首先获得相应的 EntityManager。可 以通过 EntityManagerFacTory 对象的 createEntityManager() 方法来获取 EntityManager 对象。获取、使用 EntityManager 的实际例子请参考 清单 4 AnimalDAOImpl.java 中的源代码。
EntityTransaction的启动（提交）
对于 OpenJPA 容器中的持久化对象的创建、修改、删除操作必须在代码中显 式的处理事务，而对于查询操作则不需要在代码中显式的处理事务。JPA 应用中 的事务由 EntityTransaction 接口处理，EntityTransaction 可以直接通过 EntityManager 对象的 getTransaction 方法获得。我们可以调用 EntityTransaction 的 begin(commit) 方法显式的启动（提交）事务。获取、使 用 EntityTransaction 的实际例子请参考 清单 4 AnimalDAOImpl.java 中的源 代码。
Query 接口和 JPQL 查询语言
要查询 EntityManager 中符合条件的对象列表，需要借助 Query 接口和 JPQL。Query 接口可以直接通过 EntityManager 的 createQuery 方法获得。 Query 对象目前支持 JPQL 和原生态 SQL 两种方式。
JPQL 是 OpenJPA 中支持的对象查询语言，是 EJB SQL 的一种实现。通过 JPQL，我们可以用一种面向对象的方式编写持久化对象的查询条件。比如要查找 编号为“1”的 Animal 对象，我们可以使用下面的 JPQL 语法：
select animal form. Animal animal where animal.id=1）
关于 JPQL 的更多信息请参考 OpenJPA 的帮助文档。Query 接口和 JPQL 的 实际例子请参考 清单 4 AnimalDAOImpl.java 中的源代码。
清单 4 中列出了如何使用 OpenJPA 操作、查找持久化对象 Animal 的源代码 ，读者可以从中了解使用 OpenJPA 时所应该完成的步骤和方法。
清单 4 AnimalDAOImpl.java
1. package org.vivianj.openjpa.impl.ejb3；2.3. import java.util.List；4.5. import javax.persistence.EntityManager；6. import javax.persistence.EntityManagerFacTory；7. import javax.persistence.Persistence；8. import javax.persistence.Query；9.10. import org.vivianj.openjpa.dao.AnimalDAO；11. import org.vivianj.openjpa.entity.Animal；12.13. /**14. * AnimalDAOImpl 演示了如何使用OpenJPA访问数据库的方法和步骤 15. *16. */17. public class AnimalDAOImpl implements AnimalDAO {18.19. /**20. * removeAnimal方法可以从数据库中删除指定编号的Animal对象21. *22. * @param id23. * Animal对象的编号24. */25. public void removeAnimal（int id） {26. // 获取EntityManagerFacTory27. EntityManagerFacTory facTory = Persistence28. .createEntityManagerFacTory（"mysql"）；29. // 获取EntityManager30. EntityManager em = facTory.createEntityManager（）；31. // 开始事务处理32. em.getTransaction（）.begin（）；33.34. // 使用Query删除对象35. em.createQuery（"delete from Animal animal where animal.id=" + id）36. .executeUpdate（）；37.38. // 我们还可以选择通过Query对象来完成 39. /*40. * // 从EntityManager中查询到符合条件的对象 Animal animal = 41. * em.find（Animal.class，id）； // 调用EntityManager的 remove方法删除对象42. * em.remove（animal）；43. */44.45. // 提交事务 46. em.getTransaction（）.commit（）；47. // 关闭EntityManager48. em.close（）；49. // 关闭EntityManagerFacTory50. facTory.close（）；51.52. }53.54. /**55. * findAnimalsByName 通过输入的name内容模糊查找符合条件的 Animal对象列表56. *57. * @param name58. * Animal对象的name59. * @return 符合模糊查找条件的Animal对象列表60. */61. public List findAnimalsByName（String name） {62. // 获取EntityManagerFacTory63. EntityManagerFacTory facTory = Persistence64. .createEntityManagerFacTory（"mysql"）；65. // 获取EntityManager66. EntityManager em = facTory.createEntityManager（）；67.68. /*69. * 通过EntityManager的createQuery方法获取Query对象70. * createQuery方法的参数是JPQL查询语句，JPQL语句的语法请参考 OpenJPA的帮助文档.71. *72. * 由于查询不需要事务的支持，因此Query操作的前后没有出现begin 、commit方法的调用73. *74. */75. Query q = em 76. .createQuery（"select animal from Animal animal where animal.name like '%"|-------10--------20--------30--------40--------50--------60-------- 70--------80--------9||-------- XML error: The previous line is longer than the max of 90 characters ---------|77. + name + "%' ESCAPE ''"）；78. List l = q.getResultList（）；79. // 关闭EntityManager80. em.close（）；81. // 关闭EntityManagerFacTory82. facTory.close（）；83.84. return l；85. }86.87. /**88. * getAnimalByPrimaryKey 方法可以查找符合条件的单个Animal对象 ， * 如果不存在对应的Animal对象将返回null89. *90. * @param id91. * Animal对象的编号92. * @return 唯一符合条件的Animal对象93. *94. */95. public Animal getAnimalByPrimaryKey（int id） {96. // 获取EntityManagerFacTory97. EntityManagerFacTory facTory = Persistence98. .createEntityManagerFacTory（"mysql"）；99. // 获取EntityManager100. EntityManager em = facTory.createEntityManager（）；101.102. // 查找符合条件的对象103. Animal animal = em.find（Animal.class， id）；104.105. // 关闭EntityManager106. em.close（）；107. // 关闭EntityManagerFacTory108. facTory.close（）；109.110. return animal；111. }112.113. /**114. * 将对象持久化到数据库中115. *116. * @param animal117. * 需要被持久化的对象118. */119. public void persistAnimal（Animal animal） {120. // 获取EntityManagerFacTory121. EntityManagerFacTory facTory = Persistence122. .createEntityManagerFacTory（"mysql"）；123. // 获取EntityManager124. EntityManager em = facTory.createEntityManager（）；125. // 开始事务处理126. em.getTransaction（）.begin（）；127.128. // 持久化对象129. em.persist（animal）；130.131. // 提交事务 132. em.getTransaction（）.commit（）；133. // 关闭EntityManager134. em.close（）；135. // 关闭EntityManagerFacTory136. facTory.close（）；137. }138.139. /**140. * 将Animal对象被更新的属性持久化到数据库中141. *142. * @param animal143. * 被更新过的Animal对象144. */145. public void updateAnimal（Animal animal） {146. // 获取EntityManagerFacTory147. EntityManagerFacTory facTory = Persistence148. .createEntityManagerFacTory（"mysql"）；149. // 获取EntityManager150. EntityManager em = facTory.createEntityManager（）；151. // 开始事务处理152. em.getTransaction（）.begin（）；153.154. // 更新持久化对象状态 155. em.merge（animal）；156.157. // 提交事务 158. em.getTransaction（）.commit（）；159. // 关闭EntityManager160. em.close（）；161. // 关闭EntityManagerFacTory162. facTory.close（）；163.164. }165.166. }
总结
本文中首先描述了如何准备 OpenJPA 开发环境所需要的支持环境，接着说明 了 OpenJPA 下载、安装的步骤。随后，通过一个简单的例子，作者讲解了如何应 用 OpenJPA 开发 EJB 3.0 应用的步骤和方法，并且通过合适的代码演示了如何 使用 JPA 标准接口访问持久化对象。
在本系列的 下一部分 中，我们将介绍 OpenJPA 对实体继承的三种支持方式 ，我们还将通过简单的例子来介绍其中的一种方式的具体实现细节。
原文 ：http://www.ibm.com/developerworks/cn/java/j-lo- openjpa2/index.html
即使爬到最高的山上，一次也只能脚踏实地地迈一步。
