struts1+spring+jpa的泛型增删改查和分页

 
//创建保存开始索引和结束索引的实体bean

public class PageIndex {
 private long startindex;
 private long endindex;
 
 public PageIndex(long startindex, long endindex) {
  this.startindex = startindex;
  this.endindex = endindex;
 }
 public long getStartindex() {
  return startindex;
 }
 public void setStartindex(long startindex) {
  this.startindex = startindex;
 }
 public long getEndindex() {
  return endindex;
 }
 public void setEndindex(long endindex) {
  this.endindex = endindex;
 }
 
 public static PageIndex getPageIndex(long viewpagecount, int currentPage, long totalpage){
   long startpage = currentPage-(viewpagecount%2==0? viewpagecount/2-1 : viewpagecount/2);
   long endpage = currentPage+viewpagecount/2;
   if(startpage<1){
    startpage = 1;
    if(totalpage>=viewpagecount) endpage = viewpagecount;
    else endpage = totalpage;
   }
   if(endpage>totalpage){
    endpage = totalpage;
    if((endpage-viewpagecount)>0) startpage = endpage-viewpagecount+1;
    else startpage = 1;
   }
   return new PageIndex(startpage, endpage); 
 }
}

//创建保存前台页码信息的实体bean

public class PageView<T> {
 /** 分页数据 **/
 private List<T> records;
 /** 页码开始索引和结束索引 **/
 private PageIndex pageindex;
 /** 总页数 **/
 private long totalpage = 1;
 /** 每页显示记录数 **/
 private int maxresult = 12;
 /** 当前页 **/
 private int currentpage = 1;
 /** 总记录数 **/
 private long totalrecord;
 /** 页码数量 **/
 private int pagecode = 10;
 /** 要获取记录的开始索引 **/
 public int getFirstResult() {
  return (this.currentpage-1)*this.maxresult;
 }
 public int getPagecode() {
  return pagecode;
 }

 public void setPagecode(int pagecode) {
  this.pagecode = pagecode;
 }

 public PageView(int maxresult, int currentpage) {
  this.maxresult = maxresult;
  this.currentpage = currentpage;
 }
 
 public void setQueryResult(QueryResult<T> qr){
  setTotalrecord(qr.getTotalrecord());
  setRecords(qr.getResultlist());
 }
 
 public long getTotalrecord() {
  return totalrecord;
 }
 public void setTotalrecord(long totalrecord) {
  this.totalrecord = totalrecord;
  setTotalpage(this.totalrecord%this.maxresult==0? this.totalrecord/this.maxresult : this.totalrecord/this.maxresult+1);
 }
 public List<T> getRecords() {
  return records;
 }
 public void setRecords(List<T> records) {
  this.records = records;
 }
 public PageIndex getPageindex() {
  return pageindex;
 }
 public long getTotalpage() {
  return totalpage;
 }
 public void setTotalpage(long totalpage) {
  this.totalpage = totalpage;
  this.pageindex = PageIndex.getPageIndex(pagecode, currentpage, totalpage);
 }
 public int getMaxresult() {
  return maxresult;
 }
 public int getCurrentpage() {
  return currentpage;
 }
}

//创建保存查询结果集的实体bean

public class QueryResult<T> {
 private List<T> resultlist;
 private long totalrecord;
 
 public List<T> getResultlist() {
  return resultlist;
 }
 public void setResultlist(List<T> resultlist) {
  this.resultlist = resultlist;
 }
 public long getTotalrecord() {
  return totalrecord;
 }
 public void setTotalrecord(long totalrecord) {
  this.totalrecord = totalrecord;
 }
}

//创建service层的泛型增删改查及分页

@SuppressWarnings("unchecked")
@Transactional
public abstract class DaoSupport<T> implements DAO<T>{
 protected Class<T> entityClass = GenericsUtils.getSuperClassGenricType(this.getClass());
 @PersistenceContext protected EntityManager em;
 
 public void clear(){
  em.clear();
 }

 public void delete(Serializable ... entityids) {
  for(Serializable id : entityids){
   em.remove(em.getReference(this.entityClass, id));
  }
 }
 
 @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
 public T find(Serializable entityId) {
  if(entityId==null) throw new RuntimeException(this.entityClass.getName()+ ":传入的实体id不能为空");
  return em.find(this.entityClass, entityId);
 }

 public void save(Object entity) {
  em.persist(entity);
 }
 
 @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
 public long getCount() {
  return (Long)em.createQuery("select count("+ getCountField(this.entityClass) +") from "+ getEntityName(this.entityClass)+ " o").getSingleResult();
 }
 
 public void update(Object entity) {
  em.merge(entity);
 }
 
 @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
 public QueryResult<T> getScrollData(int firstindex, int maxresult, LinkedHashMap<String, String> orderby) {
  return getScrollData(firstindex,maxresult,null,null,orderby);
 }
 
 @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
 public QueryResult<T> getScrollData(int firstindex, int maxresult, String wherejpql, Object[] queryParams) {
  return getScrollData(firstindex,maxresult,wherejpql,queryParams,null);
 }
 
 @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
 public QueryResult<T> getScrollData(int firstindex, int maxresult) {
  return getScrollData(firstindex,maxresult,null,null,null);
 }
 
 @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
 public QueryResult<T> getScrollData() {
  return getScrollData(-1, -1);
 }

 @Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
 public QueryResult<T> getScrollData(int firstindex, int maxresult
   , String wherejpql, Object[] queryParams,LinkedHashMap<String, String> orderby) {
  QueryResult qr = new QueryResult<T>();
  String entityname = getEntityName(this.entityClass);
  Query query = em.createQuery("select o from "+ entityname+ " o "+(wherejpql==null || "".equals(wherejpql.trim())? "": "where "+ wherejpql)+ buildOrderby(orderby));
  setQueryParams(query, queryParams);
  if(firstindex!=-1 && maxresult!=-1) query.setFirstResult(firstindex).setMaxResults(maxresult);
  qr.setResultlist(query.getResultList());
  query = em.createQuery("select count("+ getCountField(this.entityClass)+ ") from "+ entityname+ " o "+(wherejpql==null || "".equals(wherejpql.trim())? "": "where "+ wherejpql));
  setQueryParams(query, queryParams);
  qr.setTotalrecord((Long)query.getSingleResult());
  return qr;
 }
 
 protected static void setQueryParams(Query query, Object[] queryParams){
  if(queryParams!=null && queryParams.length>0){
   for(int i=0; i<queryParams.length; i++){
    query.setParameter(i+1, queryParams[i]);
   }
  }
 }
 /**
  * 组装order by语句
  * @param orderby
  * @return
  */
 protected static String buildOrderby(LinkedHashMap<String, String> orderby){
  StringBuffer orderbyql = new StringBuffer("");
  if(orderby!=null && orderby.size()>0){
   orderbyql.append(" order by ");
   for(String key : orderby.keySet()){
    orderbyql.append("o.").append(key).append(" ").append(orderby.get(key)).append(",");
   }
   orderbyql.deleteCharAt(orderbyql.length()-1);
  }
  return orderbyql.toString();
 }
 /**
  * 获取实体的名称
  * @param <E>
  * @param clazz 实体类
  * @return
  */
 protected static <E> String getEntityName(Class<E> clazz){
  String entityname = clazz.getSimpleName();
  Entity entity = clazz.getAnnotation(Entity.class);
  if(entity.name()!=null && !"".equals(entity.name())){
   entityname = entity.name();
  }
  return entityname;
 }
 
 protected static <E> String getCountField(Class<E> clazz){
  String out = "o";
  try {
   PropertyDescriptor[] propertyDescriptors = Introspector.getBeanInfo(clazz).getPropertyDescriptors();
   for(PropertyDescriptor propertydesc : propertyDescriptors){
    Method method = propertydesc.getReadMethod();
    if(method!=null && method.isAnnotationPresent(EmbeddedId.class)){    
     PropertyDescriptor[] ps = Introspector.getBeanInfo(propertydesc.getPropertyType()).getPropertyDescriptors();
     out = "o."+ propertydesc.getName()+ "." + (!ps[1].getName().equals("class")? ps[1].getName(): ps[0].getName());
     break;
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
        return out;
 }
}

//定义泛型工具类

/**
 * 泛型工具类
 * @author lihuoming
 *
 */
public class GenericsUtils {
 /** 
     * 通过反射,获得指定类的父类的泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer> 
     * 
     * @param clazz clazz 需要反射的类,该类必须继承范型父类
     * @param index 泛型参数所在索引,从0开始. 
     * @return 范型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */ 
    @SuppressWarnings("unchecked")
 public static Class getSuperClassGenricType(Class clazz, int index) {   
        Type genType = clazz.getGenericSuperclass();//得到泛型父类 
        //如果没有实现ParameterizedType接口，即不支持泛型，直接返回Object.class  
        if (!(genType instanceof ParameterizedType)) {
            return Object.class;  
        } 
        //返回表示此类型实际类型参数的Type对象的数组,数组里放的都是对应类型的Class, 如BuyerServiceBean extends DaoSupport<Buyer,Contact>就返回Buyer和Contact类型  
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();                  
        if (index >= params.length || index < 0) {
          throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
        }     
        if (!(params[index] instanceof Class)) {
            return Object.class;  
        }  
        return (Class) params[index];
    }
 /** 
     * 通过反射,获得指定类的父类的第一个泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer> 
     * 
     * @param clazz clazz 需要反射的类,该类必须继承泛型父类
     * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */ 
    @SuppressWarnings("unchecked")
 public static Class getSuperClassGenricType(Class clazz) {
     return getSuperClassGenricType(clazz,0);
    }
 /** 
     * 通过反射,获得方法返回值泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){}
     * 
     * @param Method method 方法
     * @param int index 泛型参数所在索引,从0开始.
     * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */
    @SuppressWarnings("unchecked")
 public static Class getMethodGenericReturnType(Method method, int index) {
     Type returnType = method.getGenericReturnType();
     if(returnType instanceof ParameterizedType){
         ParameterizedType type = (ParameterizedType) returnType;
         Type[] typeArguments = type.getActualTypeArguments();
            if (index >= typeArguments.length || index < 0) {
              throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
            }
         return (Class)typeArguments[index];
     }
     return Object.class;
    }
 /** 
     * 通过反射,获得方法返回值第一个泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){}
     * 
     * @param Method method 方法
     * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */
    @SuppressWarnings("unchecked")
 public static Class getMethodGenericReturnType(Method method) {
     return getMethodGenericReturnType(method, 0);
    }
   
 /** 
     * 通过反射,获得方法输入参数第index个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer> maps, List<String> names){}
     * 
     * @param Method method 方法
     * @param int index 第几个输入参数
     * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合
     */
    @SuppressWarnings("unchecked")
 public static List<Class> getMethodGenericParameterTypes(Method method, int index) {
     List<Class> results = new ArrayList<Class>();
     Type[] genericParameterTypes = method.getGenericParameterTypes();
     if (index >= genericParameterTypes.length ||index < 0) {
             throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
        }
     Type genericParameterType = genericParameterTypes[index];
     if(genericParameterType instanceof ParameterizedType){
          ParameterizedType aType = (ParameterizedType) genericParameterType;
          Type[] parameterArgTypes = aType.getActualTypeArguments();
          for(Type parameterArgType : parameterArgTypes){
              Class parameterArgClass = (Class) parameterArgType;
              results.add(parameterArgClass);
          }
          return results;
     }
     return results;
    }
 /** 
     * 通过反射,获得方法输入参数第一个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer> maps, List<String> names){}
     * 
     * @param Method method 方法
     * @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合
     */
    @SuppressWarnings("unchecked")
 public static List<Class> getMethodGenericParameterTypes(Method method) {
     return getMethodGenericParameterTypes(method, 0);
    }
 /** 
     * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names;
     * 
     * @param Field field 字段
     * @param int index 泛型参数所在索引,从0开始.
     * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */
    @SuppressWarnings("unchecked")
 public static Class getFieldGenericType(Field field, int index) {
     Type genericFieldType = field.getGenericType();
    
     if(genericFieldType instanceof ParameterizedType){
         ParameterizedType aType = (ParameterizedType) genericFieldType;
         Type[] fieldArgTypes = aType.getActualTypeArguments();
         if (index >= fieldArgTypes.length || index < 0) {
          throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
            }
         return (Class)fieldArgTypes[index];
     }
     return Object.class;
    }
 /** 
     * 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names;
     * 
     * @param Field field 字段
     * @param int index 泛型参数所在索引,从0开始.
     * @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
     */
    @SuppressWarnings("unchecked")
 public static Class getFieldGenericType(Field field) {
     return getFieldGenericType(field, 0);
    }
}

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/shaxinyu/archive/2009/08/10/4431981.aspx