JPA EntityManager高级

原文链接：http://blog.csdn.net/han_yankun2009/article/details/45401935

 

面向对象的使用，抽象封装是家常必备，前两篇博客说道了基本的操作分别是：

  JPA EntitManager初体验

  JPA EntitManager进阶

这次咱们就对前两次的方法进行一个基本的抽象封装

一个方法为了应对不同类型的使用，同时为了类型安全，我们引入了泛型。泛型的加入，使方法更具有灵活性，同时也保证类型的安全，下面咱们就对基本的增，该查进行基本封装。

 

定义泛型类  

1 抽象类BaseEaoImpl<T>

Public abstract class BaseEaoImpl<T>

{
//实体管理器引用
protected abstract EntityManager getEntityManager();
//反射对象
private Class<T> clazz;

}

先来看我们的最基本的几个方法吧

 

persist(Object)

find(Class<T>,object)

createQuery(String)

merge(TEntity)

 

要达到的要求是这四种方法适应所有的实体类型，所以抽象出来的Eao至少是子类的抽象，达到一个公用的效果

 

其次对于使用泛型的类型，对其操作还是要知道真实的类型，这里就用到了反射获取泛型真是类型

 1.1 构造函数反射获取泛型真是类型

        

   /**
 * 构造函数反射泛型对象真实类型
 */
public BaseEaoImpl() {
 ParameterizedType pType = (ParameterizedType) this.getClass().getGenericSuperclass();// 获取当前new的对象的泛型父类
 this.clazz = (Class<T>)pType.getActualTypeArguments()[0];// 获取类型参数的真是值，就是泛型参数的个数；
 className=  clazz.getSimpleName();
 System.out.println(clazz+"\n"+className);
}

 

 1.2Save方法

  保存实体

public void save(T t) {

getEntityManager().persist(t);

}

 

//批量保存实体

 

Publci booleansaveEntitys(List<T) entitys){

//为了提升性能，我们对数据进行分批次的保存，手动控制更新到数据库
    boolean flag = false;
        try {
            // 每100条往数据库里写入一次,相对提升性能，此值可改变
            int batchSize = 100;
            int i = 0;
            for (T entity : entitys) {
                getEntityManager().persist(entity);
                i++;
                if (i % batchSize == 0) {
                    getEntityManager().flush();
                    getEntityManager().clear();
                }
            }
            flag = true;
            if (logger.isDebugEnabled()) {
                logger.debug("Eao批量保存实体成功，"
                        + getEntityManager().getClass().getName());
            }
        } catch (Exception e) {
            flag = false;
            logger.error("Eao批量保存实体失败", e);
        }
        return flag;

}

 

 1.3 find方法

find方法，根据id或实体的某个属性查询等，这个时候就需要使用泛型具体类型了

 

//根据主键id查询
 public T findEntityById(Serializable id){

   return getEntityManager().find(clazz, id);
}

当然了还可以传入集合Id

//根据id集合查询实体集合
public List<T> getByIds(List<String> ids) {
        return getEntityManager().createQuery(//
                "FROM " + className + "WHERE id in (:ids)")//
                .setParameter("ids", ids)//
                .list();
    }

 

1.4 更新merge

//更新实体 ---留意级联更新的效果

public boolean updateEntity(T entity) {
    boolean flag = false;
    try {
        getEntityManager().merge(entity);
        flag = true;
    } catch (Exception e) {
        flag = false;
        logger.error("Eao更新实体失败", e);
    }
    return flag;
}

 

1.5 createQuery

createQuery的用法博大精深，以上的任何一个用户几乎都可以用creaQuery替代

 

如： queryByHql

参数hql为hql语句，

Map为hql中的参数与值

 

public List queryByHql(final String hql,
            final Map<Serializable, Serializable> map) {
        if (null == hql || "".equals(hql)) {
            return null;
        }
        try {
            Query query = getEntityManager().createQuery(hql);
            for (Serializable key : map.keySet()) {
                query.setParameter((String) key, map.get(key));
            }
            List list = query.getResultList();
            if (logger.isDebugEnabled()) {
                logger.debug("Eao根据hql语句查询实体集合成功，"
                        + getEntityManager().getClass().getName());
            }

            return list;

        } catch (Exception e) {
            logger.error("Eao根据hql语句查询实体集合失败", e);
            return null;
        }
    }

实例：

public List findSmallQuesID(String paperID,String questionTypeId){
    //参数hql语句
    String hql = "From PaperSecond where paperID =:paperID AND questionTypeID=:questionTypeId";
    //参数hal参数与值
    Map<Serializable, Serializable> map = new HashMap<Serializable, Serializable>();
    map.put("paperID", paperID);
    map.put("questionTypeId", questionTypeId);
    List<PaperDetail> paperSecondList = paperSecondEao.queryByHql(hql, map);
    return paperSecondList;
}

//根据条件更新 

//根据条件更新
//String variable（要更新的字段）, String condition（更新的条件）,Object... args
public boolean updateByCondition(String variable, String condition,
            Object... args) {
        boolean flag = false;
        qltry {
            Query query = getEntityManager().createQuery(
                    "update " + clazz.getSimpleName() + " as o set " + variable
                            + " " + condition);
            for (int i = 0; i < args.length; i++) {
                query.setParameter(i + 1, args[i]);
            }
            query.executeUpdate();
            flag = true;
            if (logger.isDebugEnabled()) {
                logger.debug("Eao根据条件更新实体成功，"
                        + getEntityManager().getClass().getName());
            }
        } catch (Exception e) {
            flag = false;
            logger.error("Eao根据条件更新实体失败", e);
        }
        return flag;
    }

实例：    

 

  String variable="studentName=?,sex=?";//要修改的字段，参数用？
String condition="wherestudentCode=?";//条件
flag= studentBean.updateByCondition(variable, condition, "参数1","参数2","参数3");

 

总结： 

通过以上几个小的实例我们认识到，几个小小的方法，可以引伸出不少的变化，但是重点还是在于不断的总结，不断的抽象，尤其在于对hql语句上。