对EntityManager进行封装以简化JPA操作
要点：通过反射机制得到父类的泛型参数
如果你用过 Seam，那就一定知道 Seam 又对JPA进行了封装，使得我们只需要让实体bean继承 Home<T>类而不需要编写任何代码就能实现CRUD操作。例如我们想持久化Customer实体bean，则只需要编写如下代码：
public class CustomerHome extends Home<Customer> {
}
就可以直接注入 CustomerHome 对象，然后调用
customer.setInstance(new Customer()); // 让此CustomerHome对象管理一个新的Customer实体 customer.persist(); // 持久化 customer.delete(); // 同 entityManager.remove() customer.save(); // 同 entityManager.merge()
也就是说，只需要把你要进行CRUD操作的 entity bean 继承自Home类，然后就可以无需编写任何代码直接操作 EntityManager 进行持久化操作，从而减少了代码量。现在我们就自己实现一个简化的Home类。
先把最终代码贴出来：
package cn.fh.orm;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
/**
* 对EntityManager操作进行封装.
* <p>只需简单地继承此类，就可以实现CRUD操作
* @author whf
*
* @param <T> 指定此Home类要管理的实体对象
*/
@Repository
public abstract class Home<T> {
/**
* 实体主键
*/
private Integer id;
/**
* 实体对象
*/
private T instance;
/**
* 实体的Class对象
*/
private Class<T> instanceClass;
@PersistenceContext
private EntityManager em;
@Transactional(readOnly = false)
public void persist() {
if (null == instance) {
throw new RuntimeException("未指定实体");
}
em.persist(instance);
}
@Transactional(readOnly = false)
public void update() {
if (null == instance) {
throw new RuntimeException("未指定实体");
}
em.merge(instance);
}
@Transactional(readOnly = false)
public void delete() {
if (null == instance) {
throw new RuntimeException("未指定实体");
}
instance = em.merge(instance);
em.remove(instance);
}
/**
* 清空实体
*/
public void clear() {
instance = null;
instanceClass = null;
id = null;
}
/**
* 根据主键查找指定实体
* @return
*/
@Transactional(readOnly = true)
private T find() {
if (null == id) {
throw new RuntimeException("未指定实体id");
}
return em.find(instanceClass, id);
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
clear();
this.id = id;
}
/**
* 如果有实体，则返回该对象.
* 如果没有,则根据实体id执行查找.
* 如果Class对象为空，则通过反射得到范形参数的Class对象
*
* @return 返回Home所管理的实体对象
* @throws IlligalArgumentException 无法得到范形参数的Class对象
*/
@SuppressWarnings("unchecked")
public T getInstance() {
if (null != instance) {
return instance;
}
// 通过反射得到T的实际Class对象
if (null == instanceClass) {
// 得到父类的范型参数的Class对象
Type type = getClass().getGenericSuperclass();
if (type instanceof ParameterizedType) {
ParameterizedType parmType = (ParameterizedType)type;
instanceClass = (Class<T>)parmType.getActualTypeArguments()[0];
} else {
throw new IllegalArgumentException("Could not guess entity class by reflection");
}
}
instance = find();
return instance;
}
public void setInstance(T instance) {
clear();
this.instance = instance;
}
}
以上代码实现了之前说提到的功能。这个类最核心的部分是 getInstance()方法。我们知道，要想调用 EntityManager 的 find() 方法，则需要提供一个类型为Class的参数。如：
entityManager.find(Customer.class, 1); // 查找主键为1的Customer
所以，要想实现只需让实体继承Home<T>类就能进行CRUD操作，核心的问题就是如何在子类中获取 Home<T> 中的泛型参数<T>的真实类型。如，
public class CustomerHome extends Home<Customer> {
}
Home<T>类必须知道是 T 实际上是Customer，才能给 EntityManager的 find() 方法传递正确的 Class 参数。这里可以通过反射实现：
// 通过反射得到T的实际Class对象
if (null == instanceClass) {
// 得到父类的范型参数的Class对象
Type type = getClass().getGenericSuperclass();
if (type instanceof ParameterizedType) {
ParameterizedType parmType = (ParameterizedType)type;
instanceClass = (Class<T>)parmType.getActualTypeArguments()[0];
} else {
throw new IllegalArgumentException("Could not guess entity class by reflection");
}
}
我们来分析一下，为什么在父类中编写 getClass().getGenericSuperclass() 得到的恰好就是 Home<T> 中T的实际类型呢？因为当我们让 CustomerHome 继承 Home<T> 后，通过 CustomerHome 调用 getInstance() 时，由于子类没有重写该方法，因此会执行父类的 getInstance()代码，而这时的执行环境是子类，因此getClass().getGenericSuperclass() 得到的恰好就是 Home<T> 中T的实际类型。
这一部分参考了 Seam 的源码(https://github.com/VaclavDedik/jboss-seam/blob/Seam_2_3/jboss-seam/src/main/java/org/jboss/seam/framework/Home.java)，这给了我很大启发，反射机制让Java如此优秀，无数的框架都建立在反射之上。
有了我们自己编写的 Home<T> 类之后，我们就可以在 Spring 环境下方便地使用 JPA了。以上代码就是针对 Spring 编写的。如果你用过 Seam 框架，你肯定知道它还有一个 Query<T> 组件，用于执行JPA查询操作。大家可以参考着Seam的源码自己实现一个玩玩。