程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> 使用Apache OpenJPA開發EJB 3.0應用，第2部分:開發第一個Open JPA應用

使用Apache OpenJPA開發EJB 3.0應用，第2部分:開發第一個Open JPA應用

編輯：關於JAVA

在上一部分中，我們了解了 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.　<?xml 　version="1.0"　encoding="UTF-8"?> 2.　<persistence　 xmlns="http://java.sun.com/xml/ns/persistence" 3.　　　 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4.　　　 version="1.0"> 5.　　　<!—persistence-unit的name屬性提供了創建EntityManagerFacotry時的　 6.　　　　　關鍵字， transaction-type則指定了使用的事務管理類型，這裡使 7.　　　　　用 ‘RESOURCE_LOCAL’參數表示使用本地事務　 8.　　　<persistence-unit　name="mysql"　transaction- type="RESOURCE_LOCAL"> 9.　　　　　<!—JPA的提供類， OpenJPA的設置如下，如果使用其它的JPA實現，這裡 10.　　　　　　　的內容需要修改成相應的提供類　 11.　　　　　 <provider> 12.　　　　　　　 org.apache.openjpa.persistence.PersistenceProviderImpl 13.　　　　　</provider> 14. 15.　　　　　<! —OpenJPA容器中管理的實體類列表　 16.　　　　　 <class>org.vivianj.openjpa.entity.Animal</class> 17.　　　　　<!—OpenJPA容器訪問數據庫的參數　 18.　　　　　<properties> 19.　　　　　　　<property　 name="openjpa.ConnectionURL" 20.　　　　　　　　　 value="jdbc:mysql://localhost/openjpa"/> 21.　　　　　　　 <property　name="openjpa.ConnectionDriverName" 22.　　　　　　　　　value="com.mysql.jdbc.Driver"/> 23.　　　　　　　 <property　name="openjpa.ConnectionUserName" 24.　　　　　　　　　value="openjpa"/> 25.　　　　　　　<property　 name="openjpa.ConnectionPassword" 26.　　　　　　　　　 value="openjpa"/> 27.　　　　　</properties> 28.　　　</persistence-unit> 29.　</persistence>

創建實體類

新創建實體類 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.　@Entity 14.　public　class　Animal　{ 15.　//　編號 16.　　　/*　使用Id注釋表示該字段是標識字段　*/ 17.　@Id 18.　　　/* 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:\OpenJPA C:\OpenJPAExamples>set　classpath=%OPENJPA_HOME%\lib\persistence- api-1.0.jar C:\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:\OpenJPA 2.　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.jar 3.　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.Animal 2.　　　extends　java.lang.Object 3.　　　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.　<persistence　…> 2.　　　<persistence-unit　…> 3.　　　　　… 4.　　　　　 <class>org.vivianj.openjpa.entity.Animal</class> 5.　　　　　… 6.　　　</persistence-unit> 7.　</persistence>

准備數據庫

在 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.　<persistence　 xmlns="http://java.sun.com/xml/ns/persistence" 2.　　　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 3.　　　version="1.0"> 4.　　　<persistence-unit　name="mysql"　transaction- type="RESOURCE_LOCAL"> 5.　… 6.　　　</persistence-unit> 7.　</persistence>

為了提升軟件的執行效率，我們通常選擇在某一個范圍內緩存 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　id 23.　　*　　　　　　Animal對象的編號 24.　　*/ 25.　public　void　removeAnimal（int　id）　{ 26.　　//　獲取EntityManagerFactory 27.　　EntityManagerFactory　factory　=　Persistence 28.　　　.createEntityManagerFactory（"mysql"）； 29.　　//　獲取EntityManager 30.　　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.　　//　關閉EntityManager 48.　　em.close（）； 49.　　//　關閉EntityManagerFactory 50.　　factory.close（）； 51. 52.　} 53. 54.　/** 55.　　*　findAnimalsByName　通過輸入的name內容模糊查找符合條件的 Animal對象列表 56.　　* 57.　　*　@param　name 58.　　*　　　　　　Animal對象的name 59.　　*　@return　符合模糊查找條件的Animal對象列表 60.　　*/ 61.　public　List<Animal>　findAnimalsByName（String　name）　 { 62.　　//　獲取EntityManagerFactory 63.　　EntityManagerFactory　factory　=　Persistence 64.　　　.createEntityManagerFactory（"mysql"）； 65.　　//　獲取EntityManager 66.　　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<Animal>　l　=　q.getResultList（）； 79.　　//　關閉EntityManager 80.　　em.close（）； 81.　　//　關閉EntityManagerFactory 82.　　factory.close（）； 83. 84.　　return　l； 85.　} 86. 87.　/** 88.　　*　getAnimalByPrimaryKey　方法可以查找符合條件的單個Animal對象，　　 *　如果不存在對應的Animal對象將返回null 89.　　* 90.　　*　@param　id 91.　　*　　　　　　Animal對象的編號 92.　　*　@return　唯一符合條件的Animal對象 93.　　* 94.　　*/ 95.　public　Animal　getAnimalByPrimaryKey（int　id）　{ 96.　　//　獲取EntityManagerFactory 97.　　EntityManagerFactory　factory　=　Persistence 98.　　　.createEntityManagerFactory（"mysql"）； 99.　　//　獲取EntityManager 100.　　EntityManager　em　=　factory.createEntityManager（）； 101. 102.　　//　查找符合條件的對象 103.　　Animal　animal　=　em.find（Animal.class，　id）； 104. 105.　　//　關閉EntityManager 106.　　em.close（）； 107.　　//　關閉EntityManagerFactory 108.　　factory.close（）； 109. 110.　　return　animal； 111.　} 112. 113.　/** 114.　　*　將對象持久化到數據庫中 115.　　* 116.　　*　@param　animal 117.　　*　　　　　　需要被持久化的對象 118.　　*/ 119.　public　void　persistAnimal（Animal　animal）　{ 120.　　//　獲取EntityManagerFactory 121.　　EntityManagerFactory　factory　=　Persistence 122.　　　.createEntityManagerFactory（"mysql"）； 123.　　//　獲取EntityManager 124.　　EntityManager　em　=　factory.createEntityManager（）； 125.　　//　開始事務處理 126.　　em.getTransaction（）.begin（）； 127. 128.　　//　持久化對象 129.　　em.persist（animal）； 130. 131.　　//　提交事務　 132.　　em.getTransaction（）.commit（）； 133.　　//　關閉EntityManager 134.　　em.close（）； 135.　　//　關閉EntityManagerFactory 136.　　factory.close（）； 137.　} 138. 139.　/** 140.　　*　將Animal對象被更新的屬性持久化到數據庫中 141.　　* 142.　　*　@param　animal 143.　　*　　　　　　被更新過的Animal對象 144.　　*/ 145.　public　void　updateAnimal（Animal　animal）　{ 146.　　//　獲取EntityManagerFactory 147.　　EntityManagerFactory　factory　=　Persistence 148.　　　.createEntityManagerFactory（"mysql"）； 149.　　//　獲取EntityManager 150.　　EntityManager　em　=　factory.createEntityManager（）； 151.　　//　開始事務處理 152.　　em.getTransaction（）.begin（）； 153. 154.　　//　更新持久化對象狀態　 155.　　em.merge（animal）； 156. 157.　　//　提交事務　 158.　　em.getTransaction（）.commit（）； 159.　　//　關閉EntityManager 160.　　em.close（）； 161.　　//　關閉EntityManagerFactory 162.　　factory.close（）； 163. 164.　} 165. 166.　}