JPA使用criteria簡單查詢工具類的方式是什么

這篇文章將為大家詳細講解有關JPA使用criteria簡單查詢工具類的方式是什么，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。

以前用jpa寫了一個條件篩選的查詢數據如下，才知道那么渣渣，就是一個表，根據前端來篩選數據，寫的如下

首先就是判斷前端傳來的參數就寫了那么多，現在才發現是渣渣中的渣渣，而且還費時，用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);    
}

關于JPA使用criteria簡單查詢工具類的方式是什么就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。