封装JPA动态查询（CriteriaQuery）

向右看齐 2022-10-01 14:57 309阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

# 封装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][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">

<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">

</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"/>

<list>

<value>insert</value>

<value>update</value>

<value>delete</value>

</list>

</property>

</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>

</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);

转载于:https://my.oschina.net/u/2364025/blog/1648263

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220114/2a699369e4314b2d836d8e52ec50cf21.png
[param]: https://my.oschina.net/u/2303379

封装JPA动态查询（CriteriaQuery）

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关基于jpa的specification实现动态查询

相关 springdata jpa使用Example快速实现动态查询

相关 Spring-Data-Jpa动态查询（Specification）

相关 QueryDSL+Spring Data JPA简单动态查询

相关封装JPA动态查询（CriteriaQuery）

相关 jpa Specification动态查询分页-实例

相关 Spring data jpa 复杂动态查询方式总结

相关 spring-data-jpa动态查询

相关 JPA动态分页查询

相关 JPA--SpringDataJpa之Specifications动态查询