欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

JPA 使用criteria简单查询工具类方式

程序员文章站 2022-03-03 10:53:59
目录打包jpa动态查询(criteriaquery) eq、ge、gt封装jpa动态查询(criteriaquery)entitymanager管理器,通过spring管理page分页和结果封装类ib...

以前用jpa写了一个条件筛选的查询数据如下,才知道那么渣渣,就是一个表,根据前端来筛选数据,写的如下

JPA 使用criteria简单查询工具类方式

首先就是判断前端传来的参数就写了那么多,现在才发现是渣渣中的渣渣,而且还费时,用criteria很快就搞定

首先创建类并实现specification<t>接口

import java.util.arraylist;
import java.util.list; 
import javax.persistence.criteria.criteriabuilder;
import javax.persistence.criteria.criteriaquery;
import javax.persistence.criteria.predicate;
import javax.persistence.criteria.root; 
import org.springframework.data.jpa.domain.specification;
 
public class expandcriteria<t> implements specification<t>{  
    private list<expandcriterion> criterions = new arraylist<expandcriterion>();    
    public predicate topredicate(root<t> root, criteriaquery<?> query,  
            criteriabuilder builder) {  
        if (!criterions.isempty()) {  
            list<predicate> predicates = new arraylist<predicate>();  
            for(expandcriterion c : criterions){  
                predicates.add(c.topredicate(root, query,builder));  
            }  
            // 将所有条件用 and 联合起来  
            if (predicates.size() > 0) {  
                return builder.and(predicates.toarray(new predicate[predicates.size()]));  
            }  
        }  
        return builder.conjunction();  
    }  
    /** 
     * 增加简单条件表达式 
     * @methods name add 
     * @create in 2012-2-8 by lee 
     * @param expression0 void 
     */  
    public void add(expandcriterion criterion){  
        if(criterion!=null){  
            criterions.add(criterion);  
        }  
    }  
    
    public static void main(string[] args) {
     //使用示例demo
//     criteria<entity> c = new criteria<entity>();
//     c.add(restrictions.like("code", searchparam.getcode(), true));  
//             c.add(restrictions.eq("level", searchparam.getlevel(), false));  
//             c.add(restrictions.eq("mainstatus", searchparam.getmainstatus(), true));  
//             c.add(restrictions.eq("flowstatus", searchparam.getflowstatus(), true));  
//             c.add(restrictions.eq("createuser.username", searchparam.getcreateuser(), true));  
//             c.add(restrictions.lte("submittime", searchparam.getstartsubmittime(), true));  
//             c.add(restrictions.gte("submittime", searchparam.getendsubmittime(), true));  
//             c.add(restrictions.eq("needfollow", searchparam.getisfollow(), true));  
//             c.add(restrictions.ne("flowstatus", searchparam.getmainstatus() true));  
//             c.add(restrictions.in("solveteam.code",teamcodes, true));  
//     repository.findall(c);  
 }
}  

新建expandcriterion接口

import javax.persistence.criteria.criteriabuilder;
import javax.persistence.criteria.criteriaquery;
import javax.persistence.criteria.predicate;
import javax.persistence.criteria.root;
 
public interface expandcriterion {
  public enum operator {  
         eq, ne, like, gt, lt, gte, lte, and, or  
     }  
     public predicate topredicate(root<?> root, criteriaquery<?> query,  
             criteriabuilder builder);  
}

新建restrictions.java

import java.util.collection; 
import org.springframework.util.stringutils; 
import com.sll.iot.dao.base.criteria.expandcriterion.operator; 
public class restrictions {     
    /** 
     * 等于 
     * @param fieldname 
     * @param value 
     * @param ignorenull 
     * @return 
     */  
    public static simpleexpression eq(string fieldname, object value, boolean ignorenull) {  
        if(stringutils.isempty(value))return null;  
        return new simpleexpression (fieldname, value, operator.eq);  
    }  
      
    /** 
     * 不等于 
     * @param fieldname 
     * @param value 
     * @param ignorenull 
     * @return 
     */  
    public static simpleexpression ne(string fieldname, object value, boolean ignorenull) {  
        if(stringutils.isempty(value))return null;  
        return new simpleexpression (fieldname, value, operator.ne);  
    }  
  
    /** 
     * 模糊匹配 
     * @param fieldname 
     * @param value 
     * @param ignorenull 
     * @return 
     */  
    public static simpleexpression like(string fieldname, string value, boolean ignorenull) {  
        if(stringutils.isempty(value))return null;  
        return new simpleexpression (fieldname, value, operator.like);  
    }  
  
  
    /** 
     * 大于 
     * @param fieldname 
     * @param value 
     * @param ignorenull 
     * @return 
     */  
    public static simpleexpression gt(string fieldname, object value, boolean ignorenull) {  
        if(stringutils.isempty(value))return null;  
        return new simpleexpression (fieldname, value, operator.gt);  
    }  
  
    /** 
     * 小于 
     * @param fieldname 
     * @param value 
     * @param ignorenull 
     * @return 
     */  
    public static simpleexpression lt(string fieldname, object value, boolean ignorenull) {  
        if(stringutils.isempty(value))return null;  
        return new simpleexpression (fieldname, value, operator.lt);  
    }  
  
    /** 
     * 大于等于 
     * @param fieldname 
     * @param value 
     * @param ignorenull 
     * @return 
     */  
    public static simpleexpression lte(string fieldname, object value, boolean ignorenull) {  
        if(stringutils.isempty(value))return null;  
        return new simpleexpression (fieldname, value, operator.gte);  
    }  
  
    /** 
     * 小于等于 
     * @param fieldname 
     * @param value 
     * @param ignorenull 
     * @return 
     */  
    public static simpleexpression gte(string fieldname, object value, boolean ignorenull) {  
        if(stringutils.isempty(value))return null;  
        return new simpleexpression (fieldname, value, operator.lte);  
    }  
  
    /** 
     * 并且 
     * @param criterions 
     * @return 
     */  
    public static logicalexpression and(expandcriterion... criterions){  
        return new logicalexpression(criterions, operator.and);  
    }  
    /** 
     * 或者 
     * @param criterions 
     * @return 
     */  
    public static logicalexpression or(expandcriterion... criterions){  
        return new logicalexpression(criterions, operator.or);  
    }  
    /** 
     * 包含于 
     * @param fieldname 
     * @param value 
     * @return 
     */  
    @suppresswarnings("rawtypes")  
    public static logicalexpression in(string fieldname, collection value, boolean ignorenull) {  
        if(ignorenull&&(value==null||value.isempty())){  
            return null;  
        }  
        simpleexpression[] ses = new simpleexpression[value.size()];  
        int i=0;  
        for(object obj : value){  
            ses[i]=new simpleexpression(fieldname,obj,operator.eq);  
            i++;  
        }  
        return new logicalexpression(ses,operator.or);  
    }  

新建simpleexpression.java

import javax.persistence.criteria.criteriabuilder;
import javax.persistence.criteria.criteriaquery;
import javax.persistence.criteria.expression;
import javax.persistence.criteria.path;
import javax.persistence.criteria.predicate;
import javax.persistence.criteria.root;
 
public class simpleexpression implements expandcriterion{      
    private string fieldname;       //属性名  
    private object value;           //对应值  
    private operator operator;      //计算符 
    protected simpleexpression(string fieldname, object value, operator operator) {  
        this.fieldname = fieldname;  
        this.value = value;  
        this.operator = operator;  
    }  
  
    public string getfieldname() {  
        return fieldname;  
    }  
    public object getvalue() {  
        return value;  
    }  
    public operator getoperator() {  
        return operator;  
    }  
    @suppresswarnings({ "rawtypes", "unchecked" })  
    public predicate topredicate(root<?> root, criteriaquery<?> query,  
            criteriabuilder builder) {  
        path expression = null;  
        if(fieldname.contains(".")){  
            string[] names = fieldname.split(".");  
            expression = root.get(names[0]);  
            for (int i = 1; i < names.length; i++) {  
                expression = expression.get(names[i]);  
            }  
        }else{  
            expression = root.get(fieldname);  
        }  
          
        switch (operator) {  
        case eq:  
            return builder.equal(expression, value);  
        case ne:  
            return builder.notequal(expression, value);  
        case like:  
            return builder.like((expression<string>) expression, "%" + value + "%");  
        case lt:  
            return builder.lessthan(expression, (comparable) value);  
        case gt:  
            return builder.greaterthan(expression, (comparable) value);  
        case lte:  
            return builder.lessthanorequalto(expression, (comparable) value);  
        case gte:  
            return builder.greaterthanorequalto(expression, (comparable) value);  
        default:  
            return null;  
        }  
    }
}  

logicalexpression.java

import java.util.arraylist;
import java.util.list; 
import javax.persistence.criteria.criteriabuilder;
import javax.persistence.criteria.criteriaquery;
import javax.persistence.criteria.predicate;
import javax.persistence.criteria.root;
 
public class logicalexpression implements expandcriterion {  
    private expandcriterion[] criterion;  // 逻辑表达式中包含的表达式  
    private operator operator;      //计算符   
    public logicalexpression(expandcriterion[] criterions, operator operator) {  
        this.criterion = criterions;  
        this.operator = operator;  
    }  
  
    public predicate topredicate(root<?> root, criteriaquery<?> query,  
            criteriabuilder builder) {  
        list<predicate> predicates = new arraylist<predicate>();  
        for(int i=0;i<this.criterion.length;i++){  
            predicates.add(this.criterion[i].topredicate(root, query, builder));  
        }  
        switch (operator) {  
        case or:  
            return builder.or(predicates.toarray(new predicate[predicates.size()]));  
        default:  
            return null;  
        }  
    }    
}

使用criteria前提是dao接口必须实现jpaspecificationexecutor<t>接口

改造如下

//条件查询
 @override
 public paging<channel> query(paging<channel> paging,string channelname,string operator) {
  pageable pagereq = new pagerequest(paging.getcurrentpage()-1, paging.getpagesize());
  page<channel> pagechanel=null;
  expandcriteria<channel> criteria = new expandcriteria<channel>();
  if(stringutil.isnotempty(channelname)){
   criteria.add(restrictions.like("name", channelname, false));
  }
  if(stringutil.isnotempty(operator)){
   criteria.add(restrictions.eq("operator",operator.valueof(operator), false));
  }
  pagechanel=channelrepository.findall(criteria, pagereq);
  
  if(pagechanel!=null){
   paging.settotalcount((int)pagechanel.gettotalelements());
   paging.setdata(pagechanel.getcontent());
   paging.settotalpage(pagechanel.gettotalpages());
  }
  return paging;
 }

都不用在dao接口写什么东西

使用方法就是demo

public static void main(string[] args) {
     //使用示例demo
//     criteria<entity> c = new criteria<entity>();
//     c.add(restrictions.like("code", searchparam.getcode(), true));  
//             c.add(restrictions.eq("level", searchparam.getlevel(), false));  
//             c.add(restrictions.eq("mainstatus", searchparam.getmainstatus(), true));  
//             c.add(restrictions.eq("flowstatus", searchparam.getflowstatus(), true));  
//             c.add(restrictions.eq("createuser.username", searchparam.getcreateuser(), true));  
//             c.add(restrictions.lte("submittime", searchparam.getstartsubmittime(), true));  
//             c.add(restrictions.gte("submittime", searchparam.getendsubmittime(), true));  
//             c.add(restrictions.eq("needfollow", searchparam.getisfollow(), true));  
//             c.add(restrictions.ne("flowstatus", searchparam.getmainstatus() true));  
//             c.add(restrictions.in("solveteam.code",teamcodes, true));  
//     repository.findall(c);  
 }

打包jpa动态查询(criteriaquery) eq、ge、gt

封装jpa动态查询(criteriaquery)

jpa动态查询(criteriaquery)封装的一段代码:

package com.platform.framework.dao.jpa;    
import java.io.serializable;  
import java.util.arraylist;  
import java.util.collection;  
import java.util.date;  
import java.util.hashmap;  
import java.util.iterator;  
import java.util.list;  
import java.util.map;  
  
import javax.persistence.entitymanager;  
import javax.persistence.criteria.criteriabuilder;  
import javax.persistence.criteria.criteriabuilder.in;  
import javax.persistence.criteria.criteriaquery;  
import javax.persistence.criteria.order;  
import javax.persistence.criteria.predicate;  
import javax.persistence.criteria.root;   
import org.apache.log4j.logger;  
  
/** 
 * query基类<br> 
 *  
 * @describe:封装jpa criteriabuilder查询条件 
 * @author:lry 
 * @since:2014-05-23 
 */  
@suppresswarnings({ "unused", "unchecked", "rawtypes", "null", "hiding" })  
public class query implements serializable {    
    private static final long serialversionuid = 5064932771068929342l;    
    private static logger log = logger.getlogger(query.class);    
    private entitymanager entitymanager;  
  
    /** 要查询的模型对象 */  
    private class clazz;  
  
    /** 查询条件列表 */  
    private root from;  
  
    private list<predicate> predicates;    
    private criteriaquery criteriaquery;    
    private criteriabuilder criteriabuilder;  
  
    /** 排序方式列表 */  
    private list<order> orders;  
  
    /** 关联模式 */  
    private map<string, query> subquery;    
    private map<string, query> linkquery;    
    private string projection;  
  
    /** 或条件 */  
    private list<query> orquery;    
    private string groupby;    
    private query() {  
    }    
    private query(class clazz, entitymanager entitymanager) {  
        this.clazz = clazz;  
        this.entitymanager = entitymanager;  
        this.criteriabuilder = this.entitymanager.getcriteriabuilder();  
        this.criteriaquery = criteriabuilder.createquery(this.clazz);  
        this.from = criteriaquery.from(this.clazz);  
        this.predicates = new arraylist();  
        this.orders = new arraylist();  
    }  
  
    /** 通过类创建查询条件 */  
    public static query forclass(class clazz, entitymanager entitymanager) {  
        return new query(clazz, entitymanager);  
    }  
  
    /** 增加子查询 */  
    private void addsubquery(string propertyname, query query) {  
        if (this.subquery == null)  
            this.subquery = new hashmap();  
  
        if (query.projection == null)  
            throw new runtimeexception("子查询字段未设置");  
  
        this.subquery.put(propertyname, query);  
    }  
  
    private void addsubquery(query query) {  
        addsubquery(query.projection, query);  
    }  
  
    /** 增关联查询 */  
    public void addlinkquery(string propertyname, query query) {  
        if (this.linkquery == null)  
            this.linkquery = new hashmap();  
  
        this.linkquery.put(propertyname, query);  
    }  
  
    /** 相等 */  
    public void eq(string propertyname, object value) {  
        if (isnullorempty(value))  
            return;  
        this.predicates.add(criteriabuilder.equal(from.get(propertyname), value));  
    }  
  
    private boolean isnullorempty(object value) {  
        if (value instanceof string) {  
            return value == null || "".equals(value);  
        }  
        return value == null;  
    }  
  
    public void or(list<string> propertyname, object value) {  
        if (isnullorempty(value))  
            return;  
        if ((propertyname == null) || (propertyname.size() == 0))  
            return;  
        predicate predicate = criteriabuilder.or(criteriabuilder.equal(from.get(propertyname.get(0)), value));  
        for (int i = 1; i < propertyname.size(); ++i)  
            predicate = criteriabuilder.or(predicate, criteriabuilder.equal(from.get(propertyname.get(i)), value));  
        this.predicates.add(predicate);  
    }  
  
    public void orlike(list<string> propertyname, string value) {  
        if (isnullorempty(value) || (propertyname.size() == 0))  
            return;  
        if (value.indexof("%") < 0)  
            value = "%" + value + "%";  
        predicate predicate = criteriabuilder.or(criteriabuilder.like(from.get(propertyname.get(0)), value.tostring()));  
        for (int i = 1; i < propertyname.size(); ++i)  
            predicate = criteriabuilder.or(predicate, criteriabuilder.like(from.get(propertyname.get(i)), value));  
        this.predicates.add(predicate);  
    }  
  
    /** 空 */  
    public void isnull(string propertyname) {  
        this.predicates.add(criteriabuilder.isnull(from.get(propertyname)));  
    }  
  
    /** 非空 */  
    public void isnotnull(string propertyname) {  
        this.predicates.add(criteriabuilder.isnotnull(from.get(propertyname)));  
    }  
  
    /** 不相等 */  
    public void noteq(string propertyname, object value) {  
        if (isnullorempty(value)) {  
            return;  
        }  
        this.predicates.add(criteriabuilder.notequal(from.get(propertyname), value));  
    }  
  
    /** 
     * not in 
     *  
     * @param propertyname 
     *            属性名称 
     * @param value 
     *            值集合 
     */  
    public void notin(string propertyname, collection value) {  
        if ((value == null) || (value.size() == 0)) {  
            return;  
        }  
        iterator iterator = value.iterator();  
        in in = criteriabuilder.in(from.get(propertyname));  
        while (iterator.hasnext()) {  
            in.value(iterator.next());  
        }  
        this.predicates.add(criteriabuilder.not(in));  
    }  
  
    /** 
     * 模糊匹配 
     *  
     * @param propertyname 
     *            属性名称 
     * @param value 
     *            属性值 
     */  
    public void like(string propertyname, string value) {  
        if (isnullorempty(value))  
            return;  
        if (value.indexof("%") < 0)  
            value = "%" + value + "%";  
        this.predicates.add(criteriabuilder.like(from.get(propertyname), value));  
    }  
  
    /** 
     * 时间区间查询 
     *  
     * @param propertyname 
     *            属性名称 
     * @param lo 
     *            属性起始值 
     * @param go 
     *            属性结束值 
     */  
    public void between(string propertyname, date lo, date go) {  
        if (!isnullorempty(lo) && !isnullorempty(go)) {  
            this.predicates.add(criteriabuilder.between(from.get(propertyname), lo, go));  
        }  
  
        // if (!isnullorempty(lo) && !isnullorempty(go)) {  
        // this.predicates.add(criteriabuilder.lessthan(from.get(propertyname),  
        // new datetime(lo).tostring()));  
        // }  
        // if (!isnullorempty(go)) {  
        // this.predicates.add(criteriabuilder.greaterthan(from.get(propertyname),  
        // new datetime(go).tostring()));  
        // }    
    }  
  
    public void between(string propertyname, number lo, number go) {  
        if (!(isnullorempty(lo)))  
            ge(propertyname, lo);  
  
        if (!(isnullorempty(go)))  
            le(propertyname, go);  
    }  
  
    /** 
     * 小于等于 
     *  
     * @param propertyname 
     *            属性名称 
     * @param value 
     *            属性值 
     */  
    public void le(string propertyname, number value) {  
        if (isnullorempty(value)) {  
            return;  
        }  
        this.predicates.add(criteriabuilder.le(from.get(propertyname), value));  
    }  
  
    /** 
     * 小于 
     *  
     * @param propertyname 
     *            属性名称 
     * @param value 
     *            属性值 
     */  
    public void lt(string propertyname, number value) {  
        if (isnullorempty(value)) {  
            return;  
        }  
        this.predicates.add(criteriabuilder.lt(from.get(propertyname), value));  
    }  
  
    /** 
     * 大于等于 
     *  
     * @param propertyname 
     *            属性名称 
     * @param value 
     *            属性值 
     */  
    public void ge(string propertyname, number value) {  
        if (isnullorempty(value)) {  
            return;  
        }  
        this.predicates.add(criteriabuilder.ge(from.get(propertyname), value));  
    }  
  
    /** 
     * 大于 
     *  
     * @param propertyname 
     *            属性名称 
     * @param value 
     *            属性值 
     */  
    public void gt(string propertyname, number value) {  
        if (isnullorempty(value)) {  
            return;  
        }  
        this.predicates.add(criteriabuilder.gt(from.get(propertyname), value));  
    }  
  
    /** 
     * in 
     *  
     * @param propertyname 
     *            属性名称 
     * @param value 
     *            值集合 
     */  
    public void in(string propertyname, collection value) {  
        if ((value == null) || (value.size() == 0)) {  
            return;  
        }  
        iterator iterator = value.iterator();  
        in in = criteriabuilder.in(from.get(propertyname));  
        while (iterator.hasnext()) {  
            in.value(iterator.next());  
        }  
        this.predicates.add(in);  
    }  
  
    /** 直接添加jpa内部的查询条件,用于应付一些复杂查询的情况,例如或 */  
    public void addcriterions(predicate predicate) {  
        this.predicates.add(predicate);  
    }  
  
    /** 
     * 创建查询条件 
     *  
     * @return jpa离线查询 
     */  
    public criteriaquery newcriteriaquery() {  
        criteriaquery.where(predicates.toarray(new predicate[0]));  
        if (!isnullorempty(groupby)) {  
            criteriaquery.groupby(from.get(groupby));  
        }  
        if (this.orders != null) {  
            criteriaquery.orderby(orders);  
        }  
        addlinkcondition(this);  
        return criteriaquery;  
    }  
  
    private void addlinkcondition(query query) {  
  
        map subquery = query.linkquery;  
        if (subquery == null)  
            return;  
  
        for (iterator queryiterator = subquery.keyset().iterator(); queryiterator.hasnext();) {  
            string key = (string) queryiterator.next();  
            query sub = (query) subquery.get(key);  
            from.join(key);  
            criteriaquery.where(sub.predicates.toarray(new predicate[0]));  
            addlinkcondition(sub);  
        }  
    }  
  
    public void addorder(string propertyname, string order) {  
        if (order == null || propertyname == null)  
            return;  
  
        if (this.orders == null)  
            this.orders = new arraylist();  
  
        if (order.equalsignorecase("asc"))  
            this.orders.add(criteriabuilder.asc(from.get(propertyname)));  
        else if (order.equalsignorecase("desc"))  
            this.orders.add(criteriabuilder.desc(from.get(propertyname)));  
    }  
  
    public void setorder(string propertyname, string order) {  
        this.orders = null;  
        addorder(propertyname, order);  
    }  
  
    public class getmodleclass() {  
        return this.clazz;  
    }  
  
    public string getprojection() {  
        return this.projection;  
    }  
  
    public void setprojection(string projection) {  
        this.projection = projection;  
    }  
  
    public class getclazz() {  
        return this.clazz;  
    }  
  
    public list<order> getorders() {  
        return orders;  
    }  
  
    public void setorders(list<order> orders) {  
        this.orders = orders;  
    }  
  
    public entitymanager getentitymanager() {  
        return this.entitymanager;  
    }  
  
    public void setentitymanager(entitymanager em) {  
        this.entitymanager = em;  
    }  
  
    public root getfrom() {  
        return from;  
    }  
  
    public list<predicate> getpredicates() {  
        return predicates;  
    }  
  
    public void setpredicates(list<predicate> predicates) {  
        this.predicates = predicates;  
    }  
  
    public criteriaquery getcriteriaquery() {  
        return criteriaquery;  
    }  
  
    public criteriabuilder getcriteriabuilder() {  
        return criteriabuilder;  
    }  
  
    public void setfetchmodes(list<string> fetchfield, list<string> fetchmode) {  
  
    }  
  
    public string getgroupby() {  
        return groupby;  
    }  
  
    public void setgroupby(string groupby) {  
        this.groupby = groupby;  
    }    
}  
<?xml version="1.0" encoding="utf-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:util="http://www.springframework.org/schema/util"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemalocation="  
            http://www.springframework.org/schema/beans   
            http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
            http://www.springframework.org/schema/tx   
            http://www.springframework.org/schema/tx/spring-tx-3.1.xsd  
            http://www.springframework.org/schema/context  
            http://www.springframework.org/schema/context/spring-context-3.1.xsd  
            http://www.springframework.org/schema/aop   
            http://www.springframework.org/schema/aop/spring-aop.xsd  
            http://www.springframework.org/schema/util   
            http://www.springframework.org/schema/util/spring-util-3.1.xsd">   
  
    <!-- jpa entity manager factory -->  
    <bean id="entitymanagerfactory"  
        class="org.springframework.orm.jpa.localcontainerentitymanagerfactorybean"  
        p:packagestoscan="com.**.model" p:datasource-ref="datasource"  
        p:jpavendoradapter-ref="hibernatevendor" p:jpapropertymap-ref="jpapropertymap"/>  
  
    <util:map id="jpapropertymap">  
        <entry key="hibernate.hbm2ddl.auto" value="update" /><!-- create,update,none -->  
        <entry key="hibernate.format_sql" value="false" />  
        <entry key="hibernate.show_sql" value="false" />  
        <entry key="hibernate.current_session_context_class" value="org.hibernate.context.internal.threadlocalsessioncontext"/>  
        <entry key="hibernate.dialect" value="org.hibernate.dialect.mysqldialect" />  
  
        <!-- to enable hibernate's second level cache and query cache settings -->  
        <entry key="hibernate.max_fetch_depth" value="4" />  
        <entry key="hibernate.cache.use_second_level_cache" value="true" />  
        <entry key="hibernate.cache.use_query_cache" value="true" />  
        <!-- <entry key="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.ehcacheregionfactory" /> -->  
        <entry key="hibernate.cache.region.factory_class" value="org.hibernate.cache.singletonehcacheregionfactory" />  
    </util:map>  
  
    <bean id="hibernatevendor"  
        class="org.springframework.orm.jpa.vendor.hibernatejpavendoradapter"  
        p:database="mysql" p:showsql="true" p:generateddl="true"  
        p:databaseplatform="org.hibernate.dialect.mysqldialect" />  
          
    <bean id="transactionhandler" class="com.platform.framework.dao.jpa.transactionhandler" >  
        <property name="txmethod">  
            <list>  
                <value>insert</value>  
                <value>update</value>  
                <value>delete</value>  
            </list>  
        </property>  
        <property name="entitymanagerfactory" ref="entitymanagerfactory"/>  
    </bean>  
    <aop:config>  
        <aop:aspect id="tran" ref="transactionhandler">  
            <aop:pointcut  id="tranmethod"  
                expression="  
                    execution(* com.*.dao.*.*(..))||  
                    execution(* com.*.service.impl.*.*(..))||  
                      
                    execution(* com.*.*.dao.*.*(..))||  
                    execution(* com.*.*.service.impl.*.*(..))||  
                      
                    execution(* com.*.*.*.dao.*.*(..))||  
                    execution(* com.*.*.*.service.impl.*.*(..))||  
                      
                    execution(* com.*.*.*.*.dao.*.*(..))||  
                    execution(* com.*.*.*.*.service.impl.*.*(..))||  
                      
                    execution(* com.*.*.*.*.*.dao.*.*(..))||  
                    execution(* com.*.*.*.*.*.service.impl.*.*(..))||  
                      
                    execution(* com.*.*.*.*.*.*.dao.*.*(..))||  
                    execution(* com.*.*.*.*.*.*.service.impl.*.*(..))||  
                      
                    execution(* com.platform.framework.dao.jpa.basedaoimpl.*(..))"/>  
            <aop:around method="exec"  pointcut-ref="tranmethod" />  
        </aop:aspect>  
    </aop:config>  
      
    <bean id="basedao" class="com.platform.framework.dao.jpa.basedaoimpl">  
        <property name="emf" ref="entitymanagerfactory"/>  
    </bean>  
</beans>  
package com.platform.framework.dao.jpa;    
import javax.persistence.entitymanager;  
import javax.persistence.entitymanagerfactory;  
import javax.persistence.entitytransaction;    
import org.apache.log4j.logger;  
import org.aspectj.lang.proceedingjoinpoint;  
import org.aspectj.lang.signature;  
  
/** 
 * @describe jpa事务管理 
 * @author lry 
 * @since:2014-05-23 
 *  
 */  
public class transactionhandler {  
  
    private static final logger log = logger  
            .getlogger(transactionhandler.class);    
    private string[] txmethod;// 配置事务的传播特性方法    
    private entitymanagerfactory entitymanagerfactory;// jpa工厂    
    public object exec(proceedingjoinpoint point) throws throwable {  
  
        signature signature = point.getsignature();  
         log.debug(point.gettarget().getclass().getname() + "."  
         + signature.getname() + "()");  
        boolean istransaction = false;  
        for (string method : txmethod) {  
            if (signature.getname().startswith(method)) {// 以method开头的方法打开事务  
                istransaction = true;  
                break;  
            }  
        }  
  
        // jpa->hibernate  
        if (point.gettarget() instanceof entitymanagerfactoryproxy) {  
  
            // 获得被代理对象  
            entitymanagerfactoryproxy emfp = (entitymanagerfactoryproxy) point  
                    .gettarget();  
            entitymanager em = emfp.getentitymanager();  
            if (em != null) {// 如果对象已经有em了就不管  
                return point.proceed();  
            } else {  
                em = entitymanagerfactory.createentitymanager();  
            }  
             log.debug("jpa->hibernate open connection...");  
            if (istransaction) {  
                entitytransaction t = null;  
                try {  
  
                    // 打开连接并开启事务  
                     log.debug("jpa->hibernate begin transaction...");  
                    t = em.gettransaction();  
                    if (!t.isactive())  
                        t.begin();  
                    emfp.setentitymanager(em);  
                    object obj = point.proceed();  
  
                    // 提交事务  
                    log.debug("jpa->hibernate commit...");  
                    t.commit();  
                    return obj;  
                } catch (exception e) {  
                    if (t != null) {  
                        log.debug("jpa->hibernate error...,rollback..."  
                                + e.getmessage());  
                        t.rollback();  
                    }  
                    e.printstacktrace();  
                    throw e;  
                } finally {  
                    if (em != null && em.isopen()) {// 关闭连接  
                        em.close();  
                        log.debug("jpa->hibernate close connection...");  
                    }  
                    emfp.setentitymanager(null);  
                }  
            } else {  
                try {  
                    emfp.setentitymanager(em);  
                    return point.proceed();  
                } catch (exception e) {  
                    log.debug("jpa->hibernate error..." + e.getmessage());  
                    e.printstacktrace();  
                    throw e;  
                } finally {  
                    if (em != null && em.isopen()) {// 关闭连接  
                        em.close();  
                        log.debug("jpa->hibernate close connection...");  
                    }  
                    emfp.setentitymanager(null);  
                }  
            }  
        } else {  
            return point.proceed();  
        }  
    }  
  
    public string[] gettxmethod() {  
        return txmethod;  
    }  
  
    public void settxmethod(string[] txmethod) {  
        this.txmethod = txmethod;  
    }  
  
    public void setentitymanagerfactory(  
            entitymanagerfactory entitymanagerfactory) {  
        this.entitymanagerfactory = entitymanagerfactory;  
    }    
}  

entitymanager管理器,通过spring管理

package com.platform.framework.dao.jpa;   
import java.util.collection;    
import javax.persistence.entitymanager;  
import javax.persistence.entitymanagerfactory;  
  
/** 
 * entitymanager管理器 
 *  
 * @author:yangjian1004 
 * @since:2011-11-30 16:14:24 am 
 */  
public class entitymanagerfactoryproxy {    
    private static threadlocal<entitymanager> emthreadlocal = new threadlocal<entitymanager>();  
    private static entitymanagerfactory emf;  
  
    public void setemf(entitymanagerfactory emf) {  
        entitymanagerfactoryproxy.emf = emf;  
    }  
  
    public static entitymanagerfactory getemf() {  
        return emf;  
    }  
  
    public entitymanager getentitymanager() {  
        return emthreadlocal.get();  
    }  
  
    public void setentitymanager(entitymanager em) {  
        emthreadlocal.set(em);  
    }  
  
    /** 
     * 创建查询条件 
     *  
     * @param name 
     *            字段名称 
     * @param values 
     *            字段值 
     */  
    public string createincondition(string name, collection<string> values) {  
        if (values == null || values.size() == 0) {  
            return "1<>1";  
        }  
        stringbuffer sb = new stringbuffer();  
        sb.append(name + " in(");  
        for (string id : values) {  
            sb.append("'" + id + "',");  
        }  
        string hsqlcondition = sb.substring(0, sb.length() - 1) + ")";  
        return hsqlcondition;  
    }  
}  

page分页和结果封装类

package com.platform.framework.dao.jpa;   
import java.io.serializable;  
import java.util.arraylist;  
import java.util.list;  
  
/** 
 * page基类<br> 
 *  
 * @describe:分页 
 */  
public class page<t> implements serializable {  
  
    private static final long serialversionuid = 665620345605746930l;  
    /** 总条数 */  
    private int count;  
    /** 页码 */  
    private int pageno;  
    /** 每页显示多少条 */  
    private int rowsperpage;  
    /** 总页数 */  
    private int totalpagecount;  
    /** 起始条数 */  
    private int firstrow;  
    /** 结束条数 */  
    private int lastrow;  
    /** 查询结果集合形式的结果 */  
    private list<t> result;  
    /** 查询结果对象形式的结果 */  
    public object obj;  
  
    public integer code; // 返回码  
    private boolean success = true;  
    private string message;   
    public page() {  
    }  
  
    public page(list<t> list) {  
        this(list.size(), 1, list.size(), list);  
    }  
  
    public page(int count, int pageno, int rowsperpage, list<t> result) {  
        if (rowsperpage < 1) {  
            rowsperpage = 1;  
        }  
        this.count = count;  
        this.pageno = pageno;  
        this.result = result;  
        this.rowsperpage = rowsperpage;  
        if (this.result == null)  
            this.result = new arraylist<t>();  
        totalpagecount = count / rowsperpage;  
        if (count - (count / rowsperpage) * rowsperpage > 0)  
            totalpagecount++;  
        if (count == 0) {  
            totalpagecount = 0;  
            pageno = 0;  
        }  
  
        firstrow = (pageno - 1) * rowsperpage + 1;  
        if (count == 0) {  
            firstrow = 0;  
        }  
        lastrow = (pageno) * rowsperpage;  
        if (lastrow > count) {  
            lastrow = count;  
        }  
    }  
  
    /** 返回每页的条数 */  
    public int getcount() {  
        return count;  
    }  
  
    public list<t> getresult() {  
        return result;  
    }  
  
    public int getpageno() {  
        return pageno;  
    }  
  
    /** 返回每页的条数 */  
    public int getrowsperpage() {  
        return rowsperpage;  
    }  
  
    /** 返回总的页数 */  
    public int gettotalpagecount() {  
        return totalpagecount;  
    }  
  
    public void setpageno(int pageno) {  
        this.pageno = pageno;  
    }  
  
    public void setrowsperpage(int rowsperpage) {  
        this.rowsperpage = rowsperpage;  
    }  
  
    public int getfirstrow() {  
        return firstrow;  
    }  
  
    public int getlastrow() {  
        return lastrow;  
    }  
  
    public void setfirstrow(int firstrow) {  
        this.firstrow = firstrow;  
    }  
  
    public void setlastrow(int lastrow) {  
        this.lastrow = lastrow;  
    }  
  
    public void setcount(int count) {  
        this.count = count;  
    }  
  
    public void settotalpagecount(int totalpagecount) {  
        this.totalpagecount = totalpagecount;  
    }  
  
    public void setresult(list<t> result) {  
        this.result = result;  
    }  
  
    public object getobj() {  
        return obj;  
    }  
  
    public void setobj(object obj) {  
        this.obj = obj;  
    }  
  
    public boolean issuccess() {  
        return success;  
    }  
  
    public void setsuccess(boolean success) {  
        this.success = success;  
    }  
  
    public string getmessage() {  
        return message;  
    }  
  
    public void setmessage(string message) {  
        this.message = message;  
    }  
  
    /** 
     * 计算起始条数 
     */  
    public static int calc(int pageno, int rowsperpage, int count) {  
        if (pageno <= 0)  
            pageno = 1;  
        if (rowsperpage <= 0)  
            rowsperpage = 10;  
  
        // 当把最后一页数据删除以后,页码会停留在最后一个上必须减一  
        int totalpagecount = count / rowsperpage;  
        if (pageno > totalpagecount && (count % rowsperpage == 0)) {  
            pageno = totalpagecount;  
        }  
        if (pageno - totalpagecount > 2) {  
            pageno = totalpagecount + 1;  
        }  
        int firstrow = (pageno - 1) * rowsperpage;  
        if (firstrow < 0) {  
            firstrow = 0;  
        }  
        return firstrow;  
    }    
}  
 

ibasedao接口实现了basedaoimpl

package com.platform.framework.dao.jpa;    
import java.io.serializable;  
import java.util.list;    
import javax.persistence.entitymanager;  
import javax.persistence.criteria.criteriaquery;  
import javax.persistence.criteria.predicate;  
import javax.persistence.criteria.selection;  
import javax.persistence.metamodel.entitytype;    
import org.apache.log4j.logger;    
import com.google.common.base.strings;  
/** 
 * ibasedao接口实现了basedaoimpl类<br> 
 */  
@suppresswarnings({ "unchecked", "rawtypes" })  
public class basedaoimpl<t> extends entitymanagerfactoryproxy implements ibasedao {  
  
    private static logger log = logger.getlogger(basedaoimpl.class);  
  
    /** 每次批量操作数 */  
    private int batchsize = 50;  
  
    /** 设置每次操作数 */  
    public void setbatchsize(int batchsize) {  
        this.batchsize = batchsize;  
    }  
  
    public <e> e get(class clazz, serializable id) {  
        return (e) getentitymanager().find(clazz, id);  
    }  
  
    /** 
     * 插入记录 
     *  
     * @param entity 
     *            要插入的记录 
     */  
    public void insert(object entity) {  
        if (entity instanceof list) {  
            insertlist((list) entity);  
            return;  
        } else if (entity instanceof object[]) {  
            return;  
        }  
        try {  
            getentitymanager().persist(entity);  
        } catch (exception e) {  
            e.printstacktrace();  
        }  
    }  
  
    /** 
     * 批量增加 
     *  
     * @param list 
     *            要新增的数据 
     */  
    public void insertlist(list list) {  
        entitymanager entitymanager = getentitymanager();  
        if (list == null || list.size() == 0) {  
            return;  
        }  
        int i = 0;  
        for (object o : list) {  
            insert(o);  
            if (i % batchsize == 0) {  
                entitymanager.flush();  
            }  
            i++;  
        }  
        log.debug(list.get(0).getclass() + "批量增加数据" + i + "条");  
    }  
  
    /** 
     * 更新记录 
     *  
     * @param entity 
     *            要更新的记录 
     */  
    public void update(object entity) {  
        if (entity instanceof list) {  
            this.updatelist((list) entity);  
            return;  
        }  
        getentitymanager().merge(entity);  
    }  
  
    /** 更新list */  
    public void updatelist(list list) {  
        for (object entity : list) {  
            this.update(entity);  
        }  
    }  
  
    /** 
     * 删除记录 
     *  
     * @param entity 
     *            要删除的记录 
     */  
    public void delete(object entity) {  
        if (entity instanceof list) {  
            list list = (list) entity;  
            for (object o : list) {  
                getentitymanager().remove(o);  
            }  
        } else {  
            getentitymanager().remove(entity);  
        }  
    }  
  
    public <e extends serializable> list<e> query(string jpql) {  
        return getentitymanager().createquery(jpql).getresultlist();  
    }  
  
    public integer updatejpql(string jpql) {  
        return getentitymanager().createquery(jpql).executeupdate();  
    }  
  
    public integer updatesql(string sql) {  
        return getentitymanager().createnativequery(sql).executeupdate();  
    }  
  
    public <e extends serializable> list<e> querybysql(string sql) {  
        return getentitymanager().createnativequery(sql).getresultlist();  
    }  
  
    /** 
     * 查询记录 
     *  
     * @param clazz 
     *            要查询的实体类 
     * @param hqlcondition 
     *            查询条件 
     */  
    public <e extends serializable> list<e> query(class clazz, string hqlcondition) {  
        return getentitymanager().createquery("select t from " + clazz.getname() + " as t where " + hqlcondition)  
                .getresultlist();  
    }  
  
    public void delete(class entity, string jpqlcondition) {  
        if (strings.isnullorempty(jpqlcondition)) {  
            jpqlcondition = "1=1";  
        }  
        int no = updatejpql("delete " + entity.getname() + " where " + jpqlcondition);  
        log.debug(entity.getname() + "删除" + no + "条数据");  
    }  
  
    /** 
     * 根据ids删除数据 
     *  
     * @param entity 
     *            删除实体类 
     * @param ids 
     *            删除条件 
     */  
    public void delete(class entity, list ids) {  
        string idname = getidname(entity, getentitymanager());  
        stringbuffer sb = new stringbuffer();  
        sb.append(idname + " in(");  
        for (int i = 0; i < ids.size(); i++) {  
            sb.append("'" + ids.get(i) + "',");  
        }  
        string jpqlcondition = sb.substring(0, sb.length() - 1) + ")";  
        delete(entity, jpqlcondition);  
    }  
  
    public <e extends serializable> list<e> query(string jpql, int firstresult, int maxresults) {  
        list result = getentitymanager().createquery(jpql).setfirstresult(firstresult).setmaxresults(maxresults)  
                .getresultlist();  
        return result;  
    }  
  
    public <e extends serializable> list<e> querybysql(string sql, int firstresult, int maxresults) {  
        return getentitymanager().createnativequery(sql).setfirstresult(firstresult).setmaxresults(maxresults)  
                .getresultlist();  
    }  
  
    public <e extends serializable> list<e> queryall(class clazz) {  
        criteriaquery criteriaquery = getentitymanager().getcriteriabuilder().createquery(clazz);  
        criteriaquery.from(clazz);  
        return getentitymanager().createquery(criteriaquery).getresultlist();  
    }  
  
    public page querypagebyjpql(string jpql, int pageno, int rowsperpage) {  
        if (pageno <= 0)  
            pageno = 1;  
        if (rowsperpage <= 0)  
            rowsperpage = 7;  
        log.debug("-----开始查询,页码:" + pageno + ",每页显示:" + rowsperpage + "----");  
  
        string countjpql = "select count(*) from (" + jpql + ")";  
        int count = getcount(countjpql).intvalue();  
  
        // 当把最后一页数据删除以后,页码会停留在最后一个上必须减一  
        int totalpagecount = count / rowsperpage;  
        if (pageno > totalpagecount && (count % rowsperpage == 0)) {  
            pageno = totalpagecount;  
        }  
        if (pageno - totalpagecount > 2) {  
            pageno = totalpagecount + 1;  
        }  
        int firstresult = (pageno - 1) * rowsperpage;  
        if (firstresult < 0) {  
            firstresult = 0;  
        }  
        list result = getentitymanager().createquery(jpql).setfirstresult(firstresult).setmaxresults(rowsperpage)  
                .getresultlist();  
        return new page(count, pageno, rowsperpage, result);  
    }  
  
    public long getcount(string jpql) {  
        return (long) getentitymanager().createquery(jpql).getresultlist().get(0);  
    }  
  
    /*** 
     *  
     * @method updatejpql 
     * @description 根据传入的带有占位符的sql语句, 做增删改操作 例如 
     *              updatejpql("update user t set t.name=? where t.id=?" 
     *              ,{[zhongxiang],[23]}) 
     * @author 钟翔/zhongxiang 
     * @date 2012-8-9 下午3:38:35 
     * @param jpql 
     *            占位符式的sql 
     * @param paramlist 
     *            list里面装有[zhongxiang , 23] 
     */  
    public void updatejpql(string jpql, list paramlist) {  
        javax.persistence.query query = getentitymanager().createquery(jpql);  
        for (int i = 0; i < paramlist.size(); i++) {  
            query.setparameter(i + 1, paramlist.get(i));  
        }  
        query.executeupdate();  
    }  
  
    /** 
     * 统计记录 
     *  
     * @param query 
     *            统计条件 
     */  
    public long getcount(query query) {  
        selection selection = query.getcriteriaquery().getselection();  
        query.getcriteriaquery().select(query.getcriteriabuilder().count(query.getfrom()));  
        long count = (long) getentitymanager().createquery(query.newcriteriaquery()).getresultlist().get(0);  
        query.getcriteriaquery().select(selection);  
        return count;  
    }  
  
    /** 
     * 分页查询 
     *  
     * @param query 
     *            查询条件 
     * @param pageno 
     *            页号 
     * @param rowsperpage 
     *            每页显示条数 
     */  
    public page querypage(query query, int pageno, int rowsperpage) {  
        if (pageno <= 0)  
            pageno = 1;  
        if (rowsperpage <= 0)  
            rowsperpage = 7;  
        log.debug(query.getclazz() + "-----开始查询,页码:" + pageno + ",每页显示:" + rowsperpage + "----");  
        log.debug("查询条件:");  
        for (predicate cri : query.getpredicates())  
            log.debug(cri);  
  
        int count = getcount(query).intvalue();  
  
        // 当把最后一页数据删除以后,页码会停留在最后一个上必须减一  
        int totalpagecount = count / rowsperpage;  
        if (pageno > totalpagecount && (count % rowsperpage == 0)) {  
            pageno = totalpagecount;  
        }  
        if (pageno - totalpagecount > 2) {  
            pageno = totalpagecount + 1;  
        }  
        int firstresult = (pageno - 1) * rowsperpage;  
        if (firstresult < 0) {  
            firstresult = 0;  
        }  
        list result = getentitymanager().createquery(query.newcriteriaquery()).setfirstresult(firstresult)  
                .setmaxresults(rowsperpage).getresultlist();  
        return new page(count, pageno, rowsperpage, result);  
    }  
  
    /** 
     * 根据query查找记录 
     *  
     * @param query 
     *            查询条件 
     * @param firstresult 
     *            起始行 
     * @param maxresults 
     *            结束行 
     */  
    public <e extends serializable> list<e> query(query query, int firstresult, int maxresults) {  
        list result = getentitymanager().createquery(query.newcriteriaquery()).setfirstresult(firstresult)  
                .setmaxresults(maxresults).getresultlist();  
        return result;  
    }  
  
    /** 
     * 根据query查找记录 
     *  
     * @param query 
     *            查询条件 
     */  
    public <e extends serializable> list<e> query(query query) {  
        return getentitymanager().createquery(query.newcriteriaquery()).getresultlist();  
    }  
      
    /** 
     * 获得主键名称 
     *  
     * @param clazz 
     *            操作是实体对象 
     * @param entitymanager 
     *            jpa的entitymanager工厂 
     * @return 初建名称 
     * */  
    public static string getidname(class clazz, entitymanager entitymanager) {  
        entitytype entitytype = entitymanager.getmetamodel().entity(clazz);  
        return entitytype.getid(entitytype.getidtype().getjavatype()).getname();  
    }  
}  

ibasedao接口

package com.platform.framework.dao.jpa;    
import java.io.serializable;  
import java.util.list;    
import javax.persistence.entitymanager;  
  
/** 
 * ibasedao基类<br> 
 *  
 * @describe:系统基础jpa dao接口 
 */  
@suppresswarnings({ "rawtypes" })  
public interface ibasedao {        
    public entitymanager getentitymanager();    
    public <e> e get(class clazz, serializable id);  
  
    /** 
     * 插入记录 
     *  
     * @param entity 
     *            要插入的记录 
     */  
    public void insert(object entity);  
  
    /** 
     * 更新记录 
     *  
     * @param entity 
     *            要更新的记录 
     */  
    public void update(object entity);  
  
    /** 更新list */  
    public void updatelist(list list);  
  
    /** 
     * 删除记录 
     *  
     * @param entity 
     *            要删除的记录 
     */  
    public void delete(object entity);  
  
    /** 
     * 删除记录 
     *  
     * @param entity 
     *            要删除的记录 
     */  
    public void delete(class entity, list ids);  
  
    /** 
     * 删除记录 
     *  
     * @param entity 
     *            要删除的记录 
     */  
    public void delete(class entity, string jpqlcondition);  
  
    /** 
     * 统计记录 
     *  
     * @param query 
     *            统计条件 
     */  
    public long getcount(query query);    
    public long getcount(string jpql);  
  
    /** 
     * 分页查询 
     *  
     * @param query 
     *            查询条件 
     * @param pageno 
     *            页号 
     * @param rowsperpage 
     *            每页显示条数 
     */  
    public page querypage(query query, int pageno, int rowsperpage);  
  
    /** 
     * 根据query查找记录 
     *  
     * @param query 
     *            查询条件 
     * @param firstresult 
     *            起始行 
     * @param maxresults 
     *            结束行 
     */  
    public <e extends serializable> list<e> query(query query, int firstresult, int maxresults);  
  
    /** 
     * 根据query查找记录 
     *  
     * @param query 
     *            查询条件 
     */  
    public <e extends serializable> list<e> query(query query);  
  
    /** 
     * 执行更新操作的jpql语句 
     *  
     * @param jpql 
     *            要执行的jpql语句 
     */  
    public <e extends serializable> list<e> query(string jpql);    
    public <e extends serializable> list<e> queryall(class clazz);    
    public <e extends serializable> list<e> query(string jpql, int firstresult, int maxresults);  
  
    /** 
     * 执行查询操作的sql语句 
     *  
     * @param sql 
     *            要执行的sql语句 
     */  
    public <e extends serializable> list<e> querybysql(string sql);    
    public <e extends serializable> list<e> querybysql(string sql, int firstresult, int maxresults);  
  
    /** 
     * 查询记录 
     *  
     * @param clazz 
     *            要查询的实体类 
     * @param hqlcondition 
     *            查询条件 
     */  
    public <e extends serializable> list<e> query(class clazz, string hqlcondition);  
  
    /** 
     * 执行更新操作的sql语句 
     *  
     * @param sql 
     *            要执行的sql语句 
     */  
    public integer updatesql(string sql);    
    public integer updatejpql(string jpql);    
    public page querypagebyjpql(string hql, int pageno, int rowsperpage);   
    public void updatejpql(string jpql, list paramlist);    
} 

以上为个人经验,希望能给大家一个参考,也希望大家多多支持。