9.3.原生查询
EJB QL中富有大量的查询语句并且基本上能符合你的绝大多数的查询需求.有时,你想要使用特定厂商提供的数据库上的专有能力.
实体管理服务提供了一个方法来建立原生的SQL查询并且映射他们到你的对象上.原生查询能反回实体,栏位值,或者两者的组合.EntityManager接口有三种方法来建立原生查询:一种返回标量值,一种是返回实体类型,最后一种是定义一个复杂的结果集,它能映射到多个实体的混合和标量值.
你可以进行JDBC的连接通过javax.sql.DataSource,使用@Resource注入和执行你的SQL语句.要意识到你所做的改变不会被当前的持久化上下文所反映.

9.3.1. 标量原生查询
Query createNativeQuery(String sql)
这将建立一个原生查询返回一个标量结果.它需要一个参数:你的原生SQL.它执行并且返回结果集同EJB QL相同的形式,返回标量值.

9.3.2.简单的实体原生查询
Query createNativeQuery(String sql, Class entityClass)
一个简单的原生查询通过一个SQL语句和隐式的映像到一个实体,映射元数据为基础的一个实体.它认为原生查询的结果集中的栏将完全匹配实体的O/R映射.原生SQL查询的映射实体的确定通过entityClass 参数:
Query query = manager.createNativeQuery(
"SELECT p.phone_PK, p.phone_number, p.type
FROM PHONE AS p", Phone.class
);
实体的所有属性被列出:

9.3.3.复杂的原生查询
这个实体管理方法允许你有一个复杂的映射为原生SQL.你可以同时返回多个实体和标量栏.mappingName 参数参考@javax.persistence.SqlResultSetMapping定义.这个批注用来定义一个怎能样查询原生结果的钓子到O/R模型.如果返回的栏位名与批注映射的属性不匹配,你可以提代一个字段到栏位的映射为他们,使用@javax.persistence.FieldResult :
package javax.persistence;

public @interface SqlResultSetMapping {
String name( );
EntityResult[] entities( ) default {};
ColumnResult[] columns( ) default {};
}

public @interface EntityResult {
Class entityClass( );
FieldResult[] fields( ) default {};
String discriminatorColumn( ) default "";
}

public @interface FieldResult {
String name( );
String column( );
}

public @interface ColumnResult {
String name( );
}
让我们做一系列的例子表示这会如何工作.

9.3.3.1. 使用多个实体的原生查询
@Entity
@SqlResultSetMapping(name="customerAndCreditCardMapping",
entities={@EntityResult(entityClass=Customer.class),
@EntityResult(entityClass=CreditCard.class,
fields={@FieldResult(name="id",
column="CC_ID"),
@FieldResult(name="number",
column="number")}
)})
public class Customer {...}

// execution code
{
Query query = manager.createNativeQuery(
"SELECT c.id, c.firstName, cc.id As CC_ID,
cc.number" +
"FROM CUST_TABLE c, CREDIT_CARD_TABLE cc" +
"WHERE c.credit_card_id = cc.id",
"customerAndCreditCardMapping");
}
因为结果集返回多个实体类型,我们必需使用一个@SqlResultSetMapping.这个批注可以被放在一个实体类或方法上.entities( )属性用来设置@EntityResult批注组成的队列.每一个@EntityResult注释指定将要通过原生SQL查询返回的实体.
@javax.persistence.FieldResult注释用来明确查询中与实体属性对应的映射栏位.@FieldResult批注的name()属性标识实体组件的属性, column( ) 属性标识通过原生查询返回的结果集栏位.
在这个例子中,我们需要指定@FieldResults为客户.原生查询为实体引用的每一个栏位.因为我们只查询CreditCard 实体的ID和number栏,@FieldResult批注需要被指定.在 CreditCard的@EntityResult批注中,fields()属性定义CreditCard 属性每次查询的映射.因为Customer和CreditCard主键栏有相同的名子,SQL查询需要辨别出他们的不同.cc.id As CC_ID这段SQL代码演示出这种标识.
我们也可以使用XML来表达：
<entity-mappings>
<sql-result-set-mapping name="customerAndCreditCardMapping">
<entity-result entity-class="com.titan.domain.Customer"/>
<entity-result entity-class="com.titan.domain.CreditCard"/>
<field-result name="id" column="CC_ID"/>
<field-result name="number" column="number"/>
</entity-result>
</sql-result-set-mapping>
</entity-mappings>
9.3.3.2.混合标量和实体结果
在我们的最终例子,显示一个实体和一个标量值的混合.我们写一个原生查询,来返回一个每次巡行由多少预定组成的巡行列表.
@SqlResultSetMapping(name="reservationCount",
entities=@EntityResult(name="com.titan.domain.Cruise",
fields=@FieldResult(name="id", column="id")),
columns=@ColumnResult(name="resCount"))
@Entity
public class Cruise {...}

{
Query query = manager.createNativeQuery(
"SELECT c.id, count(Reservation.id) as resCount

        FROM Cruise c LEFT JOIN Reservation ON c.id = Reservation.CRUISE_ID
GROUP BY c.id",
"reservationCount");
}
reservationCount映射的定义,原生查询表现对一个巡航实体和一个所有巡航预定的数目的请求.@FieldResult批注标识c.id栏同Cruise实体相关联.@ColumnResult批注标识resCount栏同一个标量值.
等价的XML文件:
<entity-mappings>
<sql-result-set-mapping name="reservationCount">
<entity-result entity-class="com.titan.domain.Cruise">
<field-result name="id" column="id"/>
</entity-result>
<column-result name="resCount"/>
</sql-result-set-mapping>
</entity-mappings>

9.4命名查询
JAVA持久化提供了一种机制,所以在建立一个查询时,你可以预先定义EJB QL或原SQL查询,并且引用它们通过名字.你可以先建立查询,然后建立JAVA语言中的String类型的常量:在多种不同的情形中重复使用他们.你预先定义一个查询,当在后面用到的时候,可以很容易的进行调整.@javax.persistence.NamedQuery 批注用在预定义EJB QL中:
package javax.persistence;
public @interface NamedQuery {
String name( );
String query( );
QueryHint[] hints( ) default {};
}
public @interface QueryHint {
String name( );
String value( );
}
public @interface NamedQueries {
NamedQuery[] value( );
}
当你定义一个或多个查询在类或包中,你可以使用@javax.persistence.NamedQueries 批注.@javax.persistence.QueryHint批注定义厂商提供的暗示.这些暗示工作方式与Query.setHint( )方法类似,它的描述在本单的前面.这是一个例:
package com.titan.domain;
import javax.persistence.*;
@NamedQueries({
@NamedQuery
(name="getAverageReservation",
query=
"SELECT AVG( r.amountPaid)
FROM Cruise As c, JOIN c.reservations r
WHERE c = :cruise"),

    @NamedQuery(name="findFullyPaidCruises",
query=
"FROM Cruise cr
WHERE 0 < ALL (
SELECT res.amountPaid from cr.reservations res
)")
})
@Entity
public class Cruise {...}
在这个例子中定义了两个EJB QL查询在Cruise实体组件类.你可以引用这些定义在EntityManager.createNamedQuery( )方法中:
Query query = em.createNamedQuery("findFullyPaidCruises");
Query.setParameter("cruise", cruise);
等价于@NamedQuery的XML文件:
<entity-mappings>
<named-query
name="getAverageReservation">
<query>
SELECT AVG( r.amountPaid)
FROM Cruise As c JOIN c.reservations r
WHERE c = :cruise
</query>
</named-query>
</entity-mappings>

9.4.1.命名原生查询
@javax.persistence.NamedNativeQuery 批注用于预处理原生SQL查询:
package javax.persistence;

public @interface NamedNativeQuery {
String name( );
String query( );
Class resultClass( ) default void.class;
String resultSetMapping( ) default "";
}

public @interface NamedNativeQueries {
NamedNativeQuery[] value( );
}
resultClass() 属性是为当你有一个原生查询时,只返回一个实体类型.(看这章的前面"Native Queries" 节).resultSetMapping( ) 属性解决一个预定@SqlResultSetMapping.这两个属性是可选的,但是你必需至少定义它们中的一个.这是@NamedNativeQuery批注的一个例子:
@NamedNativeQuery(
name="findCustAndCCNum",
query="SELECT c.id, c.firstName, c.lastName, cc.number AS CC_NUM
FROM CUST_TABLE c, CREDIT_CARD_TABLE cc
WHERE c.credit_card_id = cc.id",
resultSetMapping="customerAndCCNumMapping")
@SqlResultSetMapping(name="customerAndCCNumMapping",
entities={@EntityResult(entityClass=Customer.class)},
columns={@ColumnResult(name="CC_NUM")}
)
@Entity
public class Customer {...}
你可以参考EntityManager.createNamedQuery( ) 的定义:
Query query = em.createNamedQuery("findCustAndCCNum");
等价的XML文件:
<entity-mappings>
<named-native-query name="findCustAndCCNum"
result-set-mapping="customerAndCCNumMapping"/>
<query>
SELECT c.id, c.firstName, c.lastName,
cc.number AS CC_NUM
FROM CUST_TABLE c, CREDIT_CARD_TABLE cc
WHERE c.credit_card_id = cc.id
</query>
</named-native-query>
</entity-mappings>

Phone实体中加入
@NamedNativeQuery(name="NativePhone",
query="SELECT p.phone_PK, p.phone_number, p.type FROM PHONE AS p",
resultClass=Phone.class)
Named Native Query, implicit mapping
--------------------------------
Executing @NamedNativeQuery(name="NativePhone")
Exception in thread "main" javax.persistence.RollbackException: Transaction marked as rollbackOnly
at org.hibernate.ejb.TransactionImpl.commit(TransactionImpl.java:50)
at com.lyh.ejb3.clients.NativeQueries.main(NativeQueries.java:42)

Initialize DB
Exception in thread "main" javax.persistence.PersistenceException: org.hibernate.MappingException: Named query not known: NativePhone
at org.hibernate.ejb.AbstractEntityManagerImpl.throwPersistenceException(AbstractEntityManagerImpl.java:567)
at org.hibernate.ejb.AbstractEntityManagerImpl.createNamedQuery(AbstractEntityManagerImpl.java:90)
at com.lyh.ejb3.clients.NativeQueries.nativeSql(NativeQueries.java:54)
at com.lyh.ejb3.clients.NativeQueries.main(NativeQueries.java:34)
Caused by: org.hibernate.MappingException: Named query not known: NativePhone

Named Native Query, implicit mapping
--------------------------------
Executing @NamedNativeQuery(name="NativePhone")

at org.hibernate.impl.AbstractSessionImpl.getNamedQuery(AbstractSessionImpl.java:70)
at org.hibernate.impl.SessionImpl.getNamedQuery(SessionImpl.java:1260)
at org.hibernate.ejb.AbstractEntityManagerImpl.createNamedQuery(AbstractEntityManagerImpl.java:87)
... 2 more

Customer实体中加入
@Table(name="CUST_TABLE")
@SqlResultSetMapping(name="customerAndCreditCardMapping",
entities={@EntityResult(entityClass=Customer.class),
@EntityResult(entityClass=CreditCard.class,
fields={@FieldResult(name="id", column="CC_ID"),
@FieldResult(name="number", column="number")}
)})
Exception in thread "main" javax.persistence.PersistenceException: org.hibernate.MappingException: Unknown SqlResultSetMapping [customerAndCreditCardMapping]
at org.hibernate.ejb.AbstractEntityManagerImpl.throwPersistenceException(AbstractEntityManagerImpl.java:567)
at org.hibernate.ejb.AbstractEntityManagerImpl.createNativeQuery(AbstractEntityManagerImpl.java:128)
at com.lyh.ejb3.clients.NativeQueries.nativeWithMultipleEntities(NativeQueries.java:74)
at com.lyh.ejb3.clients.NativeQueries.main(NativeQueries.java:36)
Caused by: org.hibernate.MappingException: Unknown SqlResultSetMapping [customerAndCreditCardMapping]
at org.hibernate.impl.SQLQueryImpl.setResultSetMapping(SQLQueryImpl.java:290)
at org.hibernate.ejb.AbstractEntityManagerImpl.createNativeQuery(AbstractEntityManagerImpl.java:124)
... 2 more

加入@Table(name="CREDIT_CARD_TABLE") 并在相应属性加入@Column批注
ERROR - Table 'titan.credit_card_table' doesn't exist

at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:67)
at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:43)
at org.hibernate.loader.Loader.doList(Loader.java:2147)
at org.hibernate.loader.Loader.listIgnoreQueryCache(Loader.java:2028)
at org.hibernate.loader.Loader.list(Loader.java:2023)
at org.hibernate.loader.custom.CustomLoader.list(CustomLoader.java:289)
at org.hibernate.impl.SessionImpl.listCustomQuery(SessionImpl.java:1695)
at org.hibernate.impl.AbstractSessionImpl.list(AbstractSessionImpl.java:142)
at org.hibernate.impl.SQLQueryImpl.list(SQLQueryImpl.java:150)
at org.hibernate.ejb.QueryImpl.getResultList(QueryImpl.java:53)
... 2 more
强制类型转换
Exception in thread "main" java.lang.ClassCastException: java.math.BigInteger
at com.lyh.ejb3.clients.NativeQueries.mixedNative(NativeQueries.java:109)
at com.lyh.ejb3.clients.NativeQueries.main(NativeQueries.java:38)

★ 提示 ★

目前JBoss 4.2集成了的Tomcat版本为5.5，但Tomcat 6.0以后的版本中才支持使用注释，所以如果将本例中Servlet运行在JBoss 4.2中，并不能获得EntityManagerFactory对象；但在符合J2EE 5.0的服务器中，这样运行是可以的。

虽然在目前JBoss 4.2版本中不支持使用注释，但可以通过另一种方式来获得应用托管的EntityManager对象。代码如下所示。

1. public class TestServlet extends HttpServlet { 
2.  
3.     private EntityManagerFactory emf; 
4.  
5.     public TestServlet() { 
6.  
7.         super(); 
8.  
9.     } 
10.  
11.     public void doGet(HttpServletRequest request, HttpServletResponse response) 
12.  
13.             throws ServletException, IOException { 
14.  
15.         doPost(request, response); 
16.  
17.     } 
18.  
19.     public void doPost(HttpServletRequest request, HttpServletResponse response) 
20.  
21.             throws ServletException, IOException { 
22.  
23.         response.setContentType("text/html"); 
24.  
25.         PrintWriter out = response.getWriter(); 
26.  
27.         out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional //EN\">"); 
28.  
29.         out.println("<HTML>"); 
30.  
31.         out.println("  <HEAD><TITLE>A Servlet</TITLE></HEAD>"); 
32.  
33.         out.println("  <BODY>"); 
34.  
35.         if (emf != null) { 
36.  
37.             /**创建EntityManager 对象*/ 
38.  
39.             EntityManager entityManager = emf.createEntityManager(); 
40.  
41.             try { 
42.  
43.                 Query query = entityManager 
44.  
45.                         .createQuery("SELECT c FROM CustomerEO c"); 
46.  
47.                 List<CustomerEO> result = query.getResultList(); 
48.  
49.                 for (CustomerEO c : result) { 
50.  
51.                     System.out.println(c.getId() + "," + c.getName()); 
52.  
53.                 } 
54.  
55.             } finally { 
56.  
57.                 /**关闭EntityManager*/ 
58.  
59.                 entityManager.close(); 
60.  
61.             } 
62.  
63.         } 
64.  
65.         out.println("  </BODY>"); 
66.  
67.         out.println("</HTML>"); 
68.  
69.         out.flush(); 
70.  
71.         out.close(); 
72.  
73.     } 
74.  
75.     /**Servlet初始化时，创建EntityManagerFactory 对象*/ 
76.  
77.     public void init() throws ServletException { 
78.  
79.         if (emf == null) { 
80.  
81.             emf = Persistence.createEntityManagerFactory("jpaUnit"); 
82.  
83.         } 
84.  
85.     } 
86.  
87.     /**Servlet销毁时，关闭EntityManagerFactory对象*/ 
88.  
89.     public void destroy() { 
90.  
91.         if (emf.isOpen()) 
92.  
93.             emf.close(); 
94.  
95.     } 
96.  
97. } 

public class TestServlet extends HttpServlet {

private EntityManagerFactory emf;

public TestServlet() {

super();

}

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

doPost(request, response);

}

public void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

response.setContentType("text/html");

PrintWriter out = response.getWriter();

out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional //EN\">");

out.println("<HTML>");

out.println("  <HEAD><TITLE>A Servlet</TITLE></HEAD>");

out.println("  <BODY>");

if (emf != null) {

/**创建EntityManager 对象*/

EntityManager entityManager = emf.createEntityManager();

try {

Query query = entityManager

.createQuery("SELECT c FROM CustomerEO c");

List<CustomerEO> result = query.getResultList();

for (CustomerEO c : result) {

System.out.println(c.getId() + "," + c.getName());

}

} finally {

/**关闭EntityManager*/

entityManager.close();

}

}

out.println("  </BODY>");

out.println("</HTML>");

out.flush();

out.close();

}

/**Servlet初始化时，创建EntityManagerFactory 对象*/

public void init() throws ServletException {

if (emf == null) {

emf = Persistence.createEntityManagerFactory("jpaUnit");

}

}

/**Servlet销毁时，关闭EntityManagerFactory对象*/

public void destroy() {

if (emf.isOpen())

emf.close();

}

}



使用这种方式创建EntityManagerFactory对象需要注意以下几个问题。

可以看到，这里的EntityManagerFactory对象不是通过注入获得的，而是通过Persistence类中的静态方法createEntityManagerFactory来创建的。

— 正因为EntityManagerFactory对象是手动创建的，所以在不再使用时，一定要调用close()方法手动关闭。

11.1.4.3  J2SE环境中获得

在J2SE环境中，获得应用托管的EntityManager对象只能通过手动创建的方式，而不能使用注释的方式，与Web容器中不使用注释的方法相同，都是通过Persistence类中createEntityManagerFactory来创建的。

例如，下面代码为J2SE环境中获得应用托管EntityManager对象的方法。

1. public class CustomerClient { 
2.  
3.     public static void main(String[] args) { 
4.  
5.         /** 创建EntityManagerFactory对象 */ 
6.  
7.         EntityManagerFactory emf = Persistence 
8.  
9.                 .createEntityManagerFactory("jpaUnit"); 
10.  
11.         /** 创建entityManager对象 */ 
12.  
13.         EntityManager entityManager = emf.createEntityManager(); 
14.  
15.         Query query = entityManager.createQuery("SELECT c FROM CustomerEO c"); 
16.  
17.         List<CustomerEO> result = query.getResultList(); 
18.  
19.         for (CustomerEO c : result) { 
20.  
21.             System.out.println(c.getId() + "," + c.getName()); 
22.  
23.         } 
24.  
25.         /** 关闭entityManager对象 */ 
26.  
27.         entityManager.close(); 
28.  
29.         /** 关闭EntityManagerFactory对象 */ 
30.  
31.         emf.close(); 
32.  
33.     } 
34.  
35. } 

public class CustomerClient {

public static void main(String[] args) {

/** 创建EntityManagerFactory对象 */

EntityManagerFactory emf = Persistence

.createEntityManagerFactory("jpaUnit");

/** 创建entityManager对象 */

EntityManager entityManager = emf.createEntityManager();

Query query = entityManager.createQuery("SELECT c FROM CustomerEO c");

List<CustomerEO> result = query.getResultList();

for (CustomerEO c : result) {

System.out.println(c.getId() + "," + c.getName());

}

/** 关闭entityManager对象 */

entityManager.close();

/** 关闭EntityManagerFactory对象 */

emf.close();

}

}


但是，在J2SE环境中使用JPA需要将实现的JPA的第三方类包和数据库的驱动包，设置到当前的运行环境下。

例如，在Eclipse中创建一个Java项目，需要将JPA实现者的类库（这里以Hibernate为例）和MySQL的数据库连接包添加到构建路径中，如图11-2所示。

11.1.5  ThreadLocal的使用

对于在Web容器中使用EntityManager对象，这里需要做一些改进，才能更安全。读者应该了解，Servlet是非线程安全的，所以需要改变获得EntityManager对象的方式，这里笔者建议使用ThreadLocal类。

ThreadLocal就是为每一个使用某变量的线程都提供一个该变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有一个该变量，这就解决了Servlet非线程安全的问题。

首先编写一个EntityManagerHelper类，代码如下所示。

1. public class EntityManagerHelper { 
2.  
3.     
4.  
5.     private static final EntityManagerFactory emf; 
6.  
7.     private static final ThreadLocal<EntityManager> threadLocal; 
8.  
9.     
10.  
11.     /**初始化*/ 
12.  
13.     static { 
14.  
15.         emf = Persistence.createEntityManagerFactory("jpaUnit");        
16.  
17.         threadLocal = new ThreadLocal<EntityManager>(); 
18.  
19.     } 
20.  
21.     
22.  
23.     /**通过threadLocal 获得EntityManager 对象*/ 
24.  
25.     public static EntityManager getEntityManager() { 
26.  
27.         EntityManager manager = threadLocal.get();      
28.  
29.         if (manager == null || !manager.isOpen()) { 
30.  
31.             manager = emf.createEntityManager(); 
32.  
33.             threadLocal.set(manager); 
34.  
35.         } 
36.  
37.         return manager; 
38.  
39.     } 
40.  
41.     
42.  
43.     /**关闭EntityManager 对象*/ 
44.  
45.     public static void closeEntityManager() { 
46.  
47.         EntityManager em = threadLocal.get(); 
48.  
49.         threadLocal.set(null); 
50.  
51.         if (em != null) em.close(); 
52.  
53.     } 
54.  
55.     
56.  
57.     public static void beginTransaction() { 
58.  
59.     getEntityManager().getTransaction().begin(); 
60.  
61.     } 
62.  
63.     
64.  
65.     public static void commit() { 
66.  
67.     getEntityManager().getTransaction().commit(); 
68.  
69.     }  
70.  
71.     
72.  
73.     public static Query createQuery(String query) { 
74.  
75.         return getEntityManager().createQuery(query); 
76.  
77.     } 
78.  
79.     
80.  
81. } 

public class EntityManagerHelper {



private static final EntityManagerFactory emf;

private static final ThreadLocal<EntityManager> threadLocal;



/**初始化*/

static {

emf = Persistence.createEntityManagerFactory("jpaUnit");      

threadLocal = new ThreadLocal<EntityManager>();

}



/**通过threadLocal 获得EntityManager 对象*/

public static EntityManager getEntityManager() {

EntityManager manager = threadLocal.get();    

if (manager == null || !manager.isOpen()) {

manager = emf.createEntityManager();

threadLocal.set(manager);

}

return manager;

}



/**关闭EntityManager 对象*/

public static void closeEntityManager() {

EntityManager em = threadLocal.get();

threadLocal.set(null);

if (em != null) em.close();

}



public static void beginTransaction() {

getEntityManager().getTransaction().begin();

}



public static void commit() {

getEntityManager().getTransaction().commit();

}



public static Query createQuery(String query) {

return getEntityManager().createQuery(query);

}



}



这样经过改进后，在Servlet中创建EntityManager对象的方法修改为如下所示。

1. public class TestServlet extends HttpServlet { 
2.  
3.     public TestServlet() { 
4.  
5.         super(); 
6.  
7.     } 
8.  
9.     public void doPost(HttpServletRequest request, HttpServletResponse response) 
10.  
11.             throws ServletException, IOException { 
12.  
13.             EntityManager entityManager = EntityManagerHelper.getEntityManager(); 
14.  
15.             try { 
16.  
17.                 Query query = entityManager 
18.  
19.                         .createQuery("SELECT c FROM CustomerEO c"); 
20.  
21.                 List<CustomerEO> result = query.getResultList(); 
22.  
23.                 for (CustomerEO c : result) { 
24.  
25.                     System.out.println(c.getId() + "," + c.getName()); 
26.  
27.                 } 
28.  
29.             } finally { 
30.  
31.                 /**关闭EntityManager*/ 
32.  
33.                 EntityManagerHelper.closeEntityManager(); 
34.  
35.             } 
36.  
37.     } 
38.  
39. } 

持久化上下文（Persistence Contexts）的相关知识，内容包括如何从Java EE容器中创建EntityManager对象、如何从Java SE中创建EntityManager对象、持久化上下文与事务（Transction）的关系，以及实体管理器工厂（Entity Manager Factory）的相关内容。
通过本章的学习，读者将深入掌握JPA中有关持久化上下文、事务处理的相关知识，从而能够更加深入地应用JPA。


11.1 获得EntityManager对象

那么如何获得EntityManager对象呢？这又是JPA中另外一个很重要的问题。


11.1.1  Java EE环境与J2SE环境

在详细讲述EntityManager对象之前，读者首先要分清楚两个概念，即Java EE环境与J2SE环境。因为在本章后面的学习中要经常提到这两个概念，所以读者一定要先理解它们，为以后的学习打好基础。


— Java EE环境，包括EJB容器和Web容器。

（1）Web容器：只运行Web应用的容器，例如Tomcat就是开源的Web容器，它可以运行JSP、Servlet等。

（2）EJB容器：运行在EJB组件的容器，提供EJB组件的状态管理、事务管理、线程管理、远程数据资源访问、连接管理和安全性管理等系统级服务。例如JBoss为EJB容器和Web容器（Web容器是集成了Tomcat）结合。

部署在EJB容器中的JAR包都可以认为是运行在EJB容器中。但JBoss中的Web应用，比如war包中的类就不是运行在EJB容器中，而是运行在Web容器中。

— J2SE环境

最普通Java运行环境，例如一个HelloWorld的Java程序就是运行在J2SE的环境中，通常使用main入口方法作为程序启动的触发。

如图11-1所示，它说明了Java EE与J2SE环境的关系。

11.1.2  两种类型的EntityManager对象

根据EntityManager对象的管理方式，可以有以下两种类型。

— 容器托管的（container-managed）EntityManager对象

容器托管的EntityManager对象最简单，程序员不需要考虑EntityManager连接的释放，以及事务等复杂的问题，所有这些都交 给容器去管理。容器托管的EntityManager对象必须在EJB容器中运行，而不能在Web容器和J2SE的环境中运行。本书前面讲述的 EntityManager对象都是通过注入 @PersistenceContext注释来获得的，其实，这种获得EntityManager对象的方式就是容器托管的。

— 应用托管的（application-managed）EntityManager对象

应用托管的EntityManager对象，程序员需要手动地控制它的释放和连接、手动地控制事务等。但这种获得应用托管的 EntityManager对象的方式，不仅可以在EJB容器中应用，也可以使 JPA脱离EJB容器，而与任何的Java环境集成，比如说Web容器、J2SE环境等。所以从某种角度上来说，这种方式是JPA能够独立于EJB环境运 行的基础。

理想状态下，最好是选用容器托管的EntityManager对象的方式，但在特殊的环境下，还是需要使用应用托管的EntityManager对象这种方式。

正是因为应用托管的EntityManager对象的连接释放、事务控制比较复杂，所以在使用时涉及的相关内容比较多，这些内容将在本章后面部分详细讲述，这里读者应对两种方式有一个大致的了解，两种EntityManager对象类型的比较如表11-1所示。

表11-1  容器托管与应用托管的EntityManager对象对比

比较内容

容器托管的（container-managed）EntityManager对象

应用托管的（application-managed）EntityManager对象

获得方式

两种方式：1 @PersistenceContex注入 2 JNDI获得

EntityManagerFactory创建

支持事务

JTA

JTA、RESOURCE_LOCAL

运行环境

EJB容器

EJB容器、Web容器、J2SE环境

11.1.3  容器托管的（container-managed）EntityManager对象

容器托管的EntityManager对象只能运行在EJB容器中。所以可以这样理解，只有在EJB-JAR包中，才可以获得容器托管的EntityManager对象，否则只能获得应用托管的EntityManager对象。

在EJB容器中获得EntityManager对象主要有两种方式，即@PersistenceContext注释注入和JNDI方式获得。

11.1.3.1  通过@PersistenceContext注释注入

这种方式获得EntityManager对象最为常用，例如下面代码所示。

@Stateless  public class CustomerService implements ICustomerService {      @PersistenceContext(unitName = "jpaUnit")      private EntityManager entityManager;      public List<CustomerEO> findAllCustomers() {          Query query = entityManager.createQuery("SELECT c FROM CustomerEO c");          List<CustomerEO> result = query.getResultList();          for (CustomerEO c : result) {              System.out.println(c.getId()+","+c.getName());          }          return result;      }  }

在使用此种方式创建EntityManager对象时，需要注意以下几个问题。

— @PersistenceContext注释中，其中unitName为persistence.xml文件中<persistence-unit>元素中的属性“name”的值，表示要初始化哪个持久化单元，如下所示。

<persistence>      <persistence-unit name="jpaUnit" transaction-type="JTA">      </persistence-unit>  </persistence>

— @PersistenceContext注释中还可以配置其他的设置，它的定义如下所示。

@Target({TYPE, METHOD, FIELD}) @Retention(RUNTIME)  public @interface PersistenceContext{      String name() default "";      String unitName() default "";      PersistenceContextType type default TRANSACTION;      PersistenceProperty[] properties() default {};  }

— 其中PersistenceContextType可以设置创建EntityManager对象时，持久化上下文的作用范围，它的意义在于对有状态的Bean（Stateless Bean）可以跨事务操作实体。它主要有两种方式，定义如下所示。

public enum PersistenceContextType {      TRANSACTION,      EXTENDED  }

默认情况下使用TRANSACTION，有关TRANSACTION方式和EXTENDED方式创建EntityManager对象的异同，将在下文中详细讲述，这里读者简单了解一下即可。

11.1.3.2  通过JNDI的方式获得

如果指定了@PersistenceContext注释中的name值，则设置了持久化上下文的JNDI名称。通过SessionContext可以创建EntityManager对象。

例如，下面代码为通过JNDI方式获得EntityManager对象。

@Stateless  @PersistenceContext(name="jpa")  public class CustomerService implements ICustomerService {      @Resource      SessionContext ctx;      public List<CustomerEO> findAllCustomers() {          EntityManager entityManager = (EntityManager) ctx.lookup("jpa");          Query query = entityManager.createQuery("SELECT c FROM CustomerEO c");          List<CustomerEO> result = query.getResultList();          for (CustomerEO c : result) {              System.out.println(c.getId()+","+c.getName());          }          return result;      }  }

11.1.4  应用托管的（application-managed）EntityManager对象

应用托管的EntityManager对象，不仅可以在Java EE环境中获得，也可以应用在J2SE的环境中。但无论是在什么情况下获得的EntityManager对象，都是通过实体管理器工厂 （EntityManagerFactory）对象创建的。所以如何获得应用托管的EntityManager对象关键是 EntityManagerFactory对象如何获得。

下面就分别讲述在EJB容器、Web容器和J2SE环境中如何获得EntityManagerFactory对象。

11.1.4.1  EJB容器中获得

在EJB容器中，EntityManagerFactory对象可以通过使用注入@PersistenceUnit注释获得，例如下面代码为在EJB容器中，获得应用托管的EntityManager对象的方法。

@Stateless  public class CustomerService implements ICustomerService {      @PersistenceUnit(unitName="jpaUnit")      private EntityManagerFactory emf;      public List<CustomerEO> findAllCustomers() {          /**创建EntityManager对象*/          EntityManager em = emf.createEntityManager();          Query query = em.createQuery("SELECT c FROM CustomerEO c");          List<CustomerEO> result = query.getResultList();          for (CustomerEO c : result) {              System.out.println(c.getId()+","+c.getName());          }          /**关闭EntityManager */          em.close();          return result;      }  }

通过以上的EntityManager对象代码，可以总结出以下几个问题。

— 应用托管的EntityManager对象，要在代码中手动地创建和关闭，例如下面代码所示。

EntityManager em = emf.createEntityManager();

/**其他的业务逻辑*/

em.close();

这点正是与容器托管的EntityManager对象的最大不同之处。事实上，容器托管的EntityManager对象，它的创建和关闭是由容器负责管理的，所以不需要编写代码来控制。

— 应用托管的EntityManager对象，都是通EntityManagerFactory对象来创建的。在容器中可以通过使用注入@PersistenceUnit注释的方法实现，它的定义如下所示。