JPA动态查询代码封装

最新推荐文章于 2024-08-14 10:09:44 发布
最新推荐文章于 2024-08-14 10:09:44 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： SpringBoot JPA 文章标签： jpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amberwangfeng/article/details/72820344
版权 
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查询条件
 */
@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;
    }

}
import com.google.common.collect.Lists;
import com.platform.framework.dao.jpa.EntityManagerFactoryProxy;
import com.platform.framework.dao.jpa.IBaseDao;
import com.platform.framework.dao.jpa.Query;
/**
 * @describe 查询实例
 */
public class DemoServiceImpl extends EntityManagerFactoryProxy implements IDemoService {        
    private IBaseDao baseDao;

    public void setBaseDao(IBaseDao baseDao) {
        this.baseDao = baseDao;
    }
    /**
     * 城市列表
     * @param pid    String  城市父id
     * @param search String  检索（拼音、名称）
     * @param px     int     排序（3酒店数量4城市名称5拼音）
     * @return
     */
    public List<ZnCity> getCity(String pid,String search,Integer px) {
        String propertyName = "pinyin";
        String order = "asc";
        Query query = Query.forClass(ZnCity.class, getEntityManager());
        if (!StringUtil.isBlank(pid) && "0".equals(pid)) {
            query.setGroupBy("pid");
        }else {
            query.eq("pid", pid);
        }
        List<String> propertyNames = 
        Lists.newArrayList("CName","pinyin","suoxie");
        query.orLike(propertyNames, search);
        query.setOrder(propertyName, order);
        List<ZnCity> znCitys = baseDao.query(query);
        return znCitys;
    }

}
新丨客
关注
专栏目录
jpa 封装
qq_27988103的博客
10-15 593
package com.chehaha.common.data.service; import java.io.Serializable; import java.util.List; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import org....
通用JPA查询
11-28
封装hibernate查询方式（JPA）
JPA动态查询封装
weixin_30834783的博客
03-10 156
一、定义一个查询条件容器 /** * 定义一个查询条件容器 * * @param <T> */ public class Criteria<T> implements Specification<T> { private List<Criterion> criterions = new ArrayList...
Spring Data JPA 实战 - 动态查询接口JpaSpecificationExecutor
最新发布
qq_33240556的博客
08-14 247
在使用Spring Data JPA进行开发时，动态查询是非常常见且重要的需求。是Spring Data JPA提供的一个扩展接口，它允许你执行更复杂的查询逻辑，特别是基于的动态查询。
Srping Data Jpa条件查询封装
Jmark
09-08 2507
Java代码   /**   * 定义一个查询条件容器   * @author lee   *   * @param    */   public class Criteria implements Specification{       private List criterions = new ArrayList();          public Pred
将JPA查询结果封装成Map返回以及Map排序
一位不想写代码偏偏还在挣扎的万年小白
10-18 2435
jpa中将查询的字段返回为Map键值对类型 Java8 对 Map 排序
JPA分页查询与条件分页查询
04-27
总的来说，JPA分页查询和条件分页查询为开发者带来了极大的便利，它减少了对SQL的直接操作，提高了代码的可读性和可维护性。通过合理地运用Spring Data JPA的特性，可以构建出高效、灵活的数据库访问层。在设计和...
Spring Data JPA 实现多表关联查询的示例代码
08-27
同时，你需要创建一个`ResultClass`来接收并封装查询结果： ```java public class ResultClass { private UserInfo user; private Address address; public ResultClass(UserInfo user, Address address) { ...
spring data jpa 的Specifications动态查询
02-07
总结来说，Spring Data JPA的`Specifications`接口为开发者提供了强大的动态查询能力，能够灵活地应对各种复杂的查询场景，同时保持代码的整洁和可维护性。通过熟练掌握`Specifications`，可以极大地提升开发效率，...
JPA.rar_JPA 封装DAO
09-24
在实际应用中，Spring Data JPA是一个基于JPA的流行框架，它扩展了JPA的功能，提供了更多的便利，如自动生成查询方法，只需定义接口，无需编写实现。Spring Data JPA的Repository接口使得开发者可以更快速地构建数据...
SpringDataJPA 查询封装
stupid_qb的博客
04-12 1368
Git 地址：https://github.com/344399160/JPAManager用过JPA查询应该都知道，实现下面接口去做查询是很痛苦的，简单的业务逻辑却要写几十行的代码，因此开始查阅各种资料，最终看了一位博主的文章后开始在他的基础上继续完善@Override ublic Predicate toPredicate(Root&lt;User&gt; root, CriteriaQu...
springboot+jpa+swagger 动态查询
03-15
关于springboot+jpa+swagger （动态查询）简单demo案例
java服务端后台常用模板（Spring Data JPA、Hibernate、 Spring MVC、Layer）
02-08
一个用java相关技术搭建的后台服务端模板，目前仅仅包括基础模块和权限模块，用户可以结合自身业务进行相应扩展。 技术选型：Spring Data JPA、Hibernate、 Spring MVC、Layer等。 项目结构： tianti-common：系统基础服务抽象，包括entity、dao和service的基础抽象； tianti-org：用户权限模块服务实现； tianti-module-admin：后台web项目实现；
封装JPA的数据操作公共DAO基类
06-05
通过将公共通用操作写进父类简化代码，提高代码的复用。 面向接口 使用继承 泛型 引入JPA API查询 以及 元数据 提高代码的安全性.
spring data jpa的动态查询封装
tang_zongyun的博客
08-28 191
[url]http://lee1177.iteye.com/blog/1994295[/url]
Jpa自定义查询结果封装到实体
LKFMYQQ的博客
05-08 264
Jpa自定义查询结果封装到实体
spring-data-jpa封装 Specification 动态条件查询
qq_41959009的博客
08-22 2028
使用演示 动态条件查询 + or 嵌套条件+ 排序+ 分页 public Page<User> list(ReqUserListDTO params) { Specification<User> spec = SpecificationUtils.where(e -> { if (!params.getUserType().name().equal...
学习记录690@spring data jpa原生查询结果封装工具类
教练我想学编程
01-29 298
这样的结果需要我们进行封装为实体类，以下给出一个工具类解决。另外如果你是在代码中使用以下原生查询也可以将结果转换。
spring data jpa 动态查询（工具类封装）
weixin_30823833的博客
08-14 510
　　利用JPA的Specification<T>接口和元模型就实现动态查询了。但是这样每一个需要动态查询的地方都需要写一个这样类似的findByConditions方法，小型项目还好，大型项目中其实会造成人力资源的浪费，进行了大量的重复工作，所以想着对动态查询进行封装，使其使用起来更加方便。 　　在开发中,用到动态查询的地方,所有的查询条件包括分页参数,都会被封装成一个查询类XxxQ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值