JPA简单DAO基础类实现

最近研究jpa，写了个简单的DAO基础类，对简单的CRUD进行操作

package com.dyqsoft.base.dao.imp;

import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.apache.log4j.Logger;

import com.dyqsoft.base.dao.BaseDAO;
import com.dyqsoft.core.util.Utils;
import com.dyqsoft.entity.vo.PageResult;

public class JPABaseDAOImpl<T> implements BaseDAO<T> {
 @PersistenceContext
 protected EntityManager em;
 private Class<T> entityClass;

 private Logger log = null;

 public JPABaseDAOImpl() {
  try {
   Type type = getClass().getGenericSuperclass();
   Type[] types = ((ParameterizedType) type).getActualTypeArguments();
   entityClass = (Class<T>) types[0];
   log = Logger.getLogger(entityClass.getName());
  } catch (Exception ex) {
  }
 }

 public T get(Object id) {
  return em.find(entityClass, id);
 }

 public List<T> queryAllForList() {
  List<T> tlist = null;
  Query q = em.createQuery("select entity from " + entityClass.getName()+" entity");
  log.info("<<<-----queryAllForList for sql List---------------->>>");
  List list = q.getResultList();
  if (list != null && list.size() > 0) {
   tlist = list;
   log.info("<<<-----queryAllForList for list size:" + tlist.size()+ "---------------->>>");
  }
  
  return tlist;
 }

 public List<T> queryObjectForListByNamedQuery(String nameQuery,
   List<Object> param) {
  List<T> tlist = null;
  Query q = em.createNamedQuery(nameQuery);
  log.info("<<<-----queryObjectForListByNamedQuery for sql List---------------->>>");
  setParameter(q, param);
  List list = q.getResultList();
  if (list != null && list.size() > 0) {
   tlist = list;
   log.info("<<<-----queryObjectForListByNamedQuery for list size:"+ tlist.size() + "---------------->>>");
  }
  return tlist;
 }

 public List<T> queryObjectForListByNativedQuery(String nativeQuery,
   List<Object> param) {
  List<T> tlist = null;
  Query q = em.createNativeQuery(nativeQuery);
  log.info("<<<-----queryObjectForListByNativedQuery for sql List---------------->>>");
  setParameter(q, param);
  List list = q.getResultList();
  if (list != null && list.size() > 0) {
   try {
    tlist = castEntity(list);
    log.info("<<<-----queryObjectForListByNativedQuery for list size:"
      + tlist.size() + "---------------->>>");
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
  return tlist;
 }

 @SuppressWarnings("unchecked")
 public List<HashMap<String, Object>> queryObjectForMapByNamedQuery(
   String nameQuery, List<Object> param, String[] mapParam) {
  List<HashMap<String, Object>> maplist = null;
  Query q = em.createNamedQuery(nameQuery);
  log
    .info("<<<-----queryObjectForMapByNamedQuery for sql List<HashMap<String, Object>>---------------->>>");
  setParameter(q, param);
  List list = q.getResultList();
  if (list != null && list.size() > 0) {
   maplist = Utils.setHashMap(list, mapParam, mapParam.length);
   log.info("<<<-----queryObjectForMapByNamedQuery for List<HashMap<String, Object>> size:"+ maplist.size() + "---------------->>>");
  }
  
  return maplist;
 }

 public List<HashMap<String, Object>> queryObjectForMapByNativedQuery(
   String nativeQuery, List<Object> param, String[] mapParam) {
  List<HashMap<String, Object>> maplist=null;
  Query q=em.createNativeQuery(nativeQuery);
  setParameter(q, param);
  List list=q.getResultList();
  if(list!=null && list.size()>0){
   maplist=Utils.setHashMap(list, mapParam, mapParam.length);
  }
  return maplist;
 }

 public void save(T t) {
      em.persist(t);
 }

 public void saveorUpdateorDeleteForSql(String sql, List<Object> param) {
       Query q=em.createNativeQuery(sql);
       setParameter(q, param);
       q.executeUpdate();
 }

 public void update(T t) {
  em.merge(t);
 }

 private void setParameter(Query q, List<Object> parameter) {
  if (parameter != null && parameter.size() > 0) {
   int index = 1;
   for (Object _obj : parameter) {
    q.setParameter(index, _obj);
    index++;
   }
  }
 }

 @SuppressWarnings("unchecked")
 private List<T> castEntity(List<Object[]> list) throws Exception {
  List<T> returnList = new ArrayList<T>();
  Object[] co = list.get(0);
  Class[] c2 = new Class[co.length];
  // 确定构造方法
  for (int i = 0; i < co.length; i++) {
   c2[i] = co[i].getClass();
  }

  for (Object[] o : list) {
   Constructor<T> constructor = entityClass.getConstructor(c2);
   returnList.add(constructor.newInstance(o));
  }
  return returnList;
 }

 public void delete(T t) {
    
 }

 /**
  *
  */
 public List<T> queryObjectForLIstByIdefinedOfJpaSql(
   HashMap<String, Object> param, String queryType) {
  StringBuffer sql = new StringBuffer();
  List<T> tlist = null;
  log
    .info("<<<-----queryObjectForLIstByIdefinedOfJpaSql for sql List---------------->>>");
  sql.append("select entity from ").append(entityClass.getName()).append(
    " entity ");
  if (param != null && param.size() > 0) {
   sql.append(" where 1=1 ");
   Object[] _paramKeys = param.keySet().toArray();
   StringBuffer where = new StringBuffer();
   for (Object _key : _paramKeys) {
    Object paramValue = param.get(_key);
    where.append(" and entity.").append(_key).append(queryType)
      .append(paramValue).append(" and ");
   }
   if (where.length() > 0) {
    where = where.delete(where.length() - 4, where.length());
    sql.append(where);
   }
   log.info("<<<-----queryObjectForLIstByIdefinedOfJpaSql for "+ sql.toString() + " List---------------->>>");

  }
  Query q = em.createQuery(sql.toString());
  List list = q.getResultList();
  if (list != null && list.size() > 0) {
   tlist = list;
  }

  return tlist;
 }

 /**
  * 用户自定义sql查询
  *
  * @param param
  * @param mapKeys
  * @param queryType
  * @param tablename
  * @return
  */
 public List<HashMap<String, Object>> queryObjectForLIstByIdefinedOfNativeSql(
   HashMap<String, Object> param, String[] mapKeys, String queryType,
   String tableName) {
  List<HashMap<String, Object>> maplist = null;
  StringBuffer sql = new StringBuffer();
  sql.append(" select ");
  StringBuffer columns = new StringBuffer();
  for (String _column : mapKeys) {
   columns.append(" alias.").append(_column).append(",");
  }
  columns = columns.delete(columns.length() - 1, columns.length());
  sql.append(columns.toString());
  sql.append("  from ").append(tableName).append(" alias ");
  if (param != null && param.size() > 0) {
   sql.append(" where 1=1 ");
   StringBuffer where = new StringBuffer();
   Object[] _keys = param.keySet().toArray();
   for (Object _key : _keys) {
    where.append(" and alias.").append(_key).append(queryType)
      .append(param.get(_key)).append(" and ");
   }
   where = where.delete(where.length() - 4, where.length());
   sql.append(where);
  }
  log.info("<<<<----------------:"+sql.toString());
  Query q = em.createNativeQuery(sql.toString());
  List list = q.getResultList();
  if (list != null && list.size() > 0) {
   maplist = Utils.setHashMap(list, mapKeys, mapKeys.length);
  }
  return maplist;
 }

 public List<T> queryObjectForListByJql(String jql,List<Object> param) {
  List<T> tlist=null;
  Query q=em.createQuery(jql);
  setParameter(q, param);
  List list=q.getResultList();
  if(list!=null && list.size()>0){
   tlist=list;
  }
  return tlist;
 }

 public Class<T> getEntityClass() {
  return entityClass;
 }

 public void setEntityClass(Class<T> entityClass) {
  this.entityClass = entityClass;
 }

 public PageResult<T> queryObjectForPageResult(String sql,
    int cuuentPage, int showResult) {
   PageResult<T> page=null;
  int totalResult=queryObjectForPageResultCount(sql);
  if(totalResult!=0){
   page=new PageResult<T>();
   page.setCuuentPage(cuuentPage);
   page.setShowResult(showResult);
   page.setTotalResult(totalResult);
   Query q=em.createQuery(sql);
   q.setFirstResult(cuuentPage*showResult);
   q.setMaxResults(showResult);
   List<T> resultList=q.getResultList();
   if(resultList!=null && resultList.size()>0){
    page.setResultList(resultList);
   }
   
  }
  return page;
 }

 public int queryObjectForPageResultCount(String sql) {
  StringBuffer count=new StringBuffer();
  int count_par=0;
  String countSql=sql;
  countSql=countSql.substring(countSql.indexOf("FROM"),countSql.length());
  count.append("SELECT COUNT(entity)").append(countSql);
  Query q=em.createQuery(count.toString());
  Object _count=q.getSingleResult();
  if(_count!=null){
   count_par=Integer.parseInt(_count.toString());
  }
  return count_par;
 }

 public PageResult<HashMap<String, Object>> queryObjectForPageResultByNative(
   String jql,String[]marKyes, int cuuentPage, int showResult) {
  int count=queryObjectForPageResultByNativeCount(jql);
   PageResult<HashMap<String, Object>> page=null;
  if(count!=0){
   page=new PageResult<HashMap<String, Object>>();
   Query q=em.createNativeQuery(jql);
   q.setFirstResult(cuuentPage*showResult);
   page.setCuuentPage(cuuentPage);
   page.setShowResult(showResult);
   page.setTotalResult(count);
   q.setMaxResults(showResult);
   List list=q.getResultList();
   if(list!=null && list.size()>0){
    List<HashMap<String,Object>>maplist=Utils.setHashMap(list, marKyes, marKyes.length);
    page.setResultList(maplist);
   }
  }
  return page;
 }

 public int queryObjectForPageResultByNativeCount(String jql) {
  StringBuffer count=new StringBuffer();
  int count_par=0;
  String countSql=jql.toUpperCase();
  countSql=countSql.substring(countSql.indexOf("FROM"),countSql.length());
  count.append("SELECT COUNT(1)").append(countSql);
  Query q=em.createNativeQuery(countSql);
  Object _count=q.getSingleResult();
  if(_count!=null){
   count_par=Integer.parseInt(_count.toString());
  }
  return count_par;
 }

}