Jpa动态查询

最新推荐文章于 2024-08-14 10:09:44 发布
最新推荐文章于 2024-08-14 10:09:44 发布
阅读量430 收藏 1
点赞数
分类专栏： jpa 文章标签： jpa

Spring Data JPA中的动态查询 

            <div class="category clearfix">
        <div class="category_l">
            <img src="http://csdnimg.cn/release/phoenix/images/category_icon.jpg">
            <span>分类：</span>
        </div>
        <div class="category_r">
                                        <label onclick="GetCategoryArticles('5863765','anxpp','top','51996472');">
                <span onclick="_gaq.push(['_trackEvent','function', 'onclick', 'blog_articles_fenlei']);">
                   编程语言—————Java———<em>（43）</em>
                </span>
                <img class="arrow-down" src="http://csdnimg.cn/release/phoenix/images/arrow_triangle%20_down.jpg" style="display:inline;">
                <img class="arrow-up" src="http://csdnimg.cn/release/phoenix/images/arrow_triangle_up.jpg" style="display:none;">
                <div class="subItem">
                    <div class="subItem_t">
                        <a href="http://blog.csdn.net/anxpp/article/category/5863765" target="_blank">作者同类文章</a>
                        <i class="J_close">X</i>
                    </div>
                    <ul class="subItem_l" id="top_5863765"></ul>
                </div>
            </label>
                                    </div>
    </div>
            <div class="bog_copyright">
                    <p class="copyright_p">版权声明：http://blog.csdn.net/anxpp</p>
                </div>
    <div id="article_content" class="article_content csdn-tracking-statistics" data-pid="blog" data-mod="popu_307" data-dsm="post" style="overflow: hidden;">


        <link rel="stylesheet" href="http://csdnimg.cn/release/phoenix/production/htmledit_views-31d576ad74.css">
        <div class="htmledit_views">

原文出自：http://blog.csdn.net/anxpp/article/details/51996472，转载标明出处，谢谢！

    Spring Data JPA大大的简化了我们持久层的开发，但是实际应用中，我们还是需要动态查询的。

    比如，前端有多个条件，这些条件很多都是可选的，那么后端的SQL，就应该是可以定制的，在使用Hibernate的时候，可以通过判断条件来拼接SQL(HQL)，当然，Spring Data JPA在简化我们开发的同时，也是提供了支持的。

    通过实现Criteria二实现的动态查询，需要我们的Repo接口继承JpaSpecificationExecutor接口，这是个泛型接口。

    然后查询的时候，传入动态查询参数，分页参数等即可。

    使用起来很简单，不过为了知其所以然，先介绍一下Criteria API。

    Criteria API

    如果编译器能够对查询执行语法正确性检查，那么对于 Java 对象而言该查询就是类型安全的。Java™Persistence API (JPA) 的 2.0 版本引入了 Criteria API，这个 API 首次将类型安全查询引入到 Java 应用程序中，并为在运行时动态地构造查询提供一种机制。本文介绍如何使用 Criteria API 和与之密切相关的 Metamodel API 编写动态的类型安全查询。

    在使用Spring Data JPA的时候，只要我们的Repo层继承JpaSpecificationExecutor接口就可以使用Specification进行动态查询了，我们先看下JpaSpecificationExecutor接口：

[java] view plain copy
print ?
  1. public interface JpaSpecificationExecutor<T> {  
  2.     T findOne(Specification<T> spec);  
  3.     List<T> findAll(Specification<T> spec);  
  4.     Page<T> findAll(Specification<T> spec, Pageable pageable);  
  5.     List<T> findAll(Specification<T> spec, Sort sort);  
  6.     long count(Specification<T> spec);  
  7. }  
public interface JpaSpecificationExecutor<T> {
    T findOne(Specification<T> spec);
    List<T> findAll(Specification<T> spec);
    Page<T> findAll(Specification<T> spec, Pageable pageable);
    List<T> findAll(Specification<T> spec, Sort sort);
    long count(Specification<T> spec);
}
    可以看到提供了5个方法，方法的参数和返回值已经很明显的表达了其意图。其中的参数，Pageable和Sort应该是比较简单的，分别是分页参数和排序参数，而重点就是Specification参数，先看下这个接口的定义：
[java] view plain copy
print ?
  1. public interface Specification<T> {  
  2.     Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);  
  3. }  
public interface Specification<T> {
    Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);
}
    其中就一个方法，返回的是动态查询的数据结构。

    javax.persistence.criteria.Predicate toPredicate(javax.persistence.criteria.Root<T> root,
    javax.persistence.criteria.CriteriaQuery<?> query,
    javax.persistence.criteria.CriteriaBuilder cb);

    这里使用的都是Java EE中的规范，具体实现本人采用的是Hibernate，当然也可以选择其他实现了JPA规范的数据持久层框架。

    这里需要再次回过头看看Criteria API中的一些东西：

    Criteria 查询是以元模型的概念为基础的，元模型是为具体持久化单元的受管实体定义的，这些实体可以是实体类，嵌入类或者映射的父类。 

    CriteriaQuery接口：代表一个specific的顶层查询对象，它包含着查询的各个部分，比如：select 、from、where、group by、order by等注意：CriteriaQuery对象只对实体类型或嵌入式类型的Criteria查询起作用

    Root接口：代表Criteria查询的根对象，Criteria查询的查询根定义了实体类型，能为将来导航获得想要的结果，它与SQL查询中的FROM子句类似

    1：Root实例是类型化的，且定义了查询的FROM子句中能够出现的类型。

    2：查询根实例能通过传入一个实体类型给 AbstractQuery.from方法获得。

    3：Criteria查询，可以有多个查询根。

    4：AbstractQuery是CriteriaQuery 接口的父类，它提供得到查询根的方法。CriteriaBuilder接口：用来构建CritiaQuery的构建器对象Predicate：一个简单或复杂的谓词类型，其实就相当于条件或者是条件组合
    其中支持的方法非常之强大，下面给出一个示例，大家可以参考一下，同样的，可以根据示例，自己可以写出更为复杂的查询：
    Repo接口：

[java] view plain copy
print ?
  1. public interface DevHREmpConstrastDao  
  2.         extends JpaRepository<DevHREmpConstrast, Long>,JpaSpecificationExecutor<DevHREmpConstrast>  
public interface DevHREmpConstrastDao
        extends JpaRepository<DevHREmpConstrast, Long>,JpaSpecificationExecutor<DevHREmpConstrast>
    查询实例1：
[java] view plain copy
print ?
  1. /** 
  2.  * 条件查询时动态组装条件 
  3.  */  
  4. private Specification<DevHREmpConstrast> where(  
  5.         final String corg,final String name,final String type,final String date,final String checker){  
  6.     return new Specification<DevHREmpConstrast>() {  
  7.         @Override  
  8.         public Predicate toPredicate(Root<DevHREmpConstrast> root, CriteriaQuery<?> query, CriteriaBuilder cb) {  
  9.             List<Predicate> predicates = new ArrayList<Predicate>();  
  10.             //机构  
  11.             if(corg!=null&&!corg.equals(“”)){  
  12.                 List<String> orgIds = organizationDao.findByName(”%”+corg+“%”);  
  13.                 if(orgIds.size()>0&&orgIds.size()<1000)  
  14.                     predicates.add(root.<String>get(”confirmOrgNo”).in(orgIds));//confirmOrgNo  
  15.             }  
  16.             //名字  
  17.             if(name!=null&&!name.equals(“”)){  
  18.                 List<String> userIds = userDao.findByName(name);  
  19.                 if(userIds.size()>0&&userIds.size()<1000)//如果太多就不管了这个条件了  
  20.                     predicates.add(root.<String>get(”hrUserName”).in(userIds));  
  21.             }  
  22.             //类型  
  23.             if(type!=null&&!type.equals(“”))  
  24.                 predicates.add(cb.equal(root.<String>get(”hrUpdateType”),type));  
  25.             //日期  
  26.             if(date!=null&&!date.equals(“”)){  
  27.                 //处理时间  
  28.                 SimpleDateFormat format = new SimpleDateFormat(“yyyy-MM-dd”);  
  29.                 Date startDate;  
  30.                 Date endDate;  
  31.                 try {  
  32.                     startDate = format.parse(date);  
  33.                 } catch (ParseException e) {  
  34.                     startDate = new Date(946656000000L);//2000 01 01  
  35.                 }  
  36.                 endDate = startDate;  
  37.                 Calendar calendar = Calendar.getInstance() ;  
  38.                 calendar.setTime(endDate);  
  39.                 calendar.add(Calendar.DATE, 1);  
  40.                 endDate = calendar.getTime();  
  41.                 calendar = null;  
  42.                 predicates.add(cb.between(root.<Date>get(”insDate”),startDate,endDate));  
  43.             }  
  44.             //审核人  
  45.             if(checker!=null&&!checker.equals(“”)){  
  46.                 List<String> userIds = userDao.findByName(checker);  
  47.                 if(userIds.size()>0&&userIds.size()<1000)//如果太多就不管了这个条件了  
  48.                     predicates.add(root.<String>get(”confirmUserId”).in(userIds));  
  49.             }  
  50.             return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();  
  51.         }  
  52.     };  
  53. }  
/**
 * 条件查询时动态组装条件
 */
private Specification<DevHREmpConstrast> where(
        final String corg,final String name,final String type,final String date,final String checker){
    return new Specification<DevHREmpConstrast>() {
        @Override
        public Predicate toPredicate(Root<DevHREmpConstrast> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
            List<Predicate> predicates = new ArrayList<Predicate>();
            //机构
            if(corg!=null&&!corg.equals("")){
                List<String> orgIds = organizationDao.findByName("%"+corg+"%");
                if(orgIds.size()>0&&orgIds.size()<1000)
                    predicates.add(root.<String>get("confirmOrgNo").in(orgIds));//confirmOrgNo
            }
            //名字
            if(name!=null&&!name.equals("")){
                List<String> userIds = userDao.findByName(name);
                if(userIds.size()>0&&userIds.size()<1000)//如果太多就不管了这个条件了
                    predicates.add(root.<String>get("hrUserName").in(userIds));
            }
            //类型
            if(type!=null&&!type.equals(""))
                predicates.add(cb.equal(root.<String>get("hrUpdateType"),type));
            //日期
            if(date!=null&&!date.equals("")){
                //处理时间
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
                Date startDate;
                Date endDate;
                try {
                    startDate = format.parse(date);
                } catch (ParseException e) {
                    startDate = new Date(946656000000L);//2000 01 01
                }
                endDate = startDate;
                Calendar calendar = Calendar.getInstance() ;
                calendar.setTime(endDate);
                calendar.add(Calendar.DATE, 1);
                endDate = calendar.getTime();
                calendar = null;
                predicates.add(cb.between(root.<Date>get("insDate"),startDate,endDate));
            }
            //审核人
            if(checker!=null&&!checker.equals("")){
                List<String> userIds = userDao.findByName(checker);
                if(userIds.size()>0&&userIds.size()<1000)//如果太多就不管了这个条件了
                    predicates.add(root.<String>get("confirmUserId").in(userIds));
            }
            return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
        }
    };
}
    查询实例2：

[java] view plain copy
print ?
  1. /** 
  2.    * 条件查询时动态组装条件 
  3.    */  
  4.   private Specification<DevHREmpConstrast> where(  
  5.           final String corg,final String name,final String type,final String date,final String checker){  
  6.       return new Specification<DevHREmpConstrast>() {  
  7.           @Override  
  8.           public Predicate toPredicate(Root<DevHREmpConstrast> root, CriteriaQuery<?> query, CriteriaBuilder cb) {  
  9.               List<Predicate> predicates = new ArrayList<Predicate>();  
  10.               //机构  
  11.               if(corg!=null&&!corg.equals(“”)){  
  12.                   List<String> orgIds = organizationDao.findByName(”%”+corg+“%”);  
  13.                   if(orgIds.size()>0&&orgIds.size()<1000)  
  14.                       predicates.add(root.<String>get(”confirmOrgNo”).in(orgIds));//confirmOrgNo  
  15.               }  
  16.               //名字  
  17.               if(name!=null&&!name.equals(“”)){  
  18.                   List<String> userIds = userDao.findByName(name);  
  19.                   if(userIds.size()>0&&userIds.size()<1000)//如果太多就不管了这个条件了  
  20.                       predicates.add(root.<String>get(”hrUserName”).in(userIds));  
  21.               }  
  22.               //类型  
  23.               if(type!=null&&!type.equals(“”))  
  24.                   predicates.add(cb.equal(root.<String>get(”hrUpdateType”),type));  
  25.               //日期  
  26.               if(date!=null&&!date.equals(“”)){  
  27.                   //处理时间  
  28.                   SimpleDateFormat format = new SimpleDateFormat(“yyyy-MM-dd”);  
  29.                   Date startDate;  
  30.                   Date endDate;  
  31.                   try {  
  32.                       startDate = format.parse(date);  
  33.                   } catch (ParseException e) {  
  34.                       startDate = new Date(946656000000L);//2000 01 01  
  35.                   }  
  36.                   endDate = startDate;  
  37.                   Calendar calendar = Calendar.getInstance() ;  
  38.                   calendar.setTime(endDate);  
  39.                   calendar.add(Calendar.DATE, 1);  
  40.                   endDate = calendar.getTime();  
  41.                   calendar = null;  
  42.                   predicates.add(cb.between(root.<Date>get(”insDate”),startDate,endDate));  
  43.               }  
  44.               //审核人  
  45.               if(checker!=null&&!checker.equals(“”)){  
  46.                   List<String> userIds = userDao.findByName(checker);  
  47.                   if(userIds.size()>0&&userIds.size()<1000)//如果太多就不管了这个条件了  
  48.                       predicates.add(root.<String>get(”confirmUserId”).in(userIds));  
  49.               }  
  50.               return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();  
  51.           }  
  52.       };  
  53.   }  
  /**
     * 条件查询时动态组装条件
     */
    private Specification<DevHREmpConstrast> where(
            final String corg,final String name,final String type,final String date,final String checker){
        return new Specification<DevHREmpConstrast>() {
            @Override
            public Predicate toPredicate(Root<DevHREmpConstrast> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                List<Predicate> predicates = new ArrayList<Predicate>();
                //机构
                if(corg!=null&&!corg.equals("")){
                    List<String> orgIds = organizationDao.findByName("%"+corg+"%");
                    if(orgIds.size()>0&&orgIds.size()<1000)
                        predicates.add(root.<String>get("confirmOrgNo").in(orgIds));//confirmOrgNo
                }
                //名字
                if(name!=null&&!name.equals("")){
                    List<String> userIds = userDao.findByName(name);
                    if(userIds.size()>0&&userIds.size()<1000)//如果太多就不管了这个条件了
                        predicates.add(root.<String>get("hrUserName").in(userIds));
                }
                //类型
                if(type!=null&&!type.equals(""))
                    predicates.add(cb.equal(root.<String>get("hrUpdateType"),type));
                //日期
                if(date!=null&&!date.equals("")){
                    //处理时间
                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
                    Date startDate;
                    Date endDate;
                    try {
                        startDate = format.parse(date);
                    } catch (ParseException e) {
                        startDate = new Date(946656000000L);//2000 01 01
                    }
                    endDate = startDate;
                    Calendar calendar = Calendar.getInstance() ;
                    calendar.setTime(endDate);
                    calendar.add(Calendar.DATE, 1);
                    endDate = calendar.getTime();
                    calendar = null;
                    predicates.add(cb.between(root.<Date>get("insDate"),startDate,endDate));
                }
                //审核人
                if(checker!=null&&!checker.equals("")){
                    List<String> userIds = userDao.findByName(checker);
                    if(userIds.size()>0&&userIds.size()<1000)//如果太多就不管了这个条件了
                        predicates.add(root.<String>get("confirmUserId").in(userIds));
                }
                return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
            }
        };
    }
    然后调用dao层方法传入where()方法返回的参数即可。

转载请注明原创出处

原创出自：

http://blog.csdn.net/anxpp/article/details/51996472
Kukie-YiQing
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Data JPA中的动态查询
anxpp的博客
09-06 3万+
Spring Data JPA大大的简化了我们持久层的开发，但是实际应用中，我们还是需要动态查询的。 比如，前端有多个条件，这些条件很多都是可选的，那么后端的SQL，就应该是可以定制的，在使用Hibernate的时候，可以通过判断条件来拼接SQL(HQL)，当然，Spring Data JPA在简化我们开发的同时，也是提供了支持的。 通过实现Criteria二实现的动态查询，需要我们的Repo接口继承JpaSpecificationExecutor接口，这是个泛型接口。 然后查询的时
jpa 动态查询
MerryZPZ的博客
12-23 738
上一篇我们说到了spring-data-rest 和spring-data-jpa 使用的主要意义。主要目的就是为了减少模板化的代码，那么针对某个特定的repository的查询，我们是不是也可以将查询简化呢？答案当然是肯定的。 我们先来看一下jpa有哪些查询方法： 1.Query methods The JPA module supports defining a query manual
JPA中的动态查询与指定查询(转载)
Reasonsoft的专栏
01-13 404
可以使用动态查询或指定查询(named query)。指定查询随实体存储，可从应用程序重用。 　　要创建动态查询，请使用实体管理器接口的createQuery方法，如下所示： Query query = em.createQuery( "select e from Employee e where e.empNo > 1"); query.setParameter(1,...
JPA的动态查询
newbrid007的博客
01-11 2377
前几天 使用 jpa 连接 pg 库来开发一个模块 发现这个玩意 平时挺好用 但是涉及到一些复杂一点的动态查询 咱也不多说直接上 代码 然后一点点 解释 首先 使用jpa 的dao层都需要 去继承一个接口来实现curd 第一步 省略。。 创建一个 model 第二步 dao层 public interface OperatorDao extends JpaRepository<OperatorPO, String>, JpaSpecificationExecutor<OperatorP
SpringDataJpa动态查询
weixin_52533798的博客
08-22 2007
SpringDataJpa动态查询
jpa 动态查询条件 数组_Spring data jpa 复杂动态查询方式总结
weixin_39716044的博客
12-22 1637
一.Spring data jpa 简介首先JPA是Java持久层API,由Sun公司开发,希望整合ORM技术，实现天下归一.诞生的缘由是为了整合第三方ORM框架，建立一种标准的方式，目前也是在按照这个方向发展，但是还没能完全实现。在ORM框架中，Hibernate是一支很大的部队，使用很广泛，也很方便，能力也很强，同时Hibernate也是和JPA整合的比较良好，我们可以认为JPA是标准，...
jpa 动态查询条件 数组_利用JPA+querydsl实现多条件动态查询
weixin_39718006的博客
12-22 909
相信很多人在做订单管理的时候会用到多条件的检索，比如说查询订单状态是已支付的，金额在100-200之间的商铺a的已完结的订单，这样的多条件。实现方式有多种，核心就一个if和判空。今天学习了querydsl，来具体回顾一下。首先是我做的效果图，我们主要看查询怎么实现的。 介绍一下querydsl首先QueryDSL仅仅是一个通用的查询框架，专注于通过Java API构建类型安全的SQL查询。其次Q...
jpa 动态查询条件 数组_JPA使用Specification构建动态查询
weixin_28771631的博客
01-13 708
封装Specification查询条件，在Spring Data JPA 2.0以前使用 Specifications 这个辅助类来操作where、not、and和or连接，在2.0版本以后这个类会被剔除，可以直接使用 Specification 自身对象来操作where多条件连接。(以下展示单表多条件查询)import org.springframework.data.jpa.domain.Sp...
JPA动态参数查询
ghx__ch的博客
03-23 2013
JPA动态参数查询
JPA实现动态查询
就很有趣的博客
06-21 3487
前言 之前使用jpa的时候一直感慨它的一些原来就有的方法很好用，一边不是很习惯这种不是xml写sql的方式，尤其在用习惯了mybatis之后，在使用jpa写动态查询的时候真的一头雾水，直到发现了Specification 这个神奇的东西，使用下来觉得他和mybatis plus的条件构造器很像，而且可以实现动态查询，特意记录一下 代码 JPA List<Apply> findAll(Specification<Apply> specification); service pub
springboot+jpa+swagger 动态查询
03-15
关于springboot+jpa+swagger （动态查询）简单demo案例
Spring-Data-Jpa动态查询（Specification）
热门推荐
小马同学
12-01 1万+
JPA允许基于Criteria对象进行按条件查询，而SpringDataJpa提供了一个Specification接口，Specification接口封装了JPA的Criteria查询条件，从而可以通过此接口更加方便地使用Criteria查询，Specification接口的源代码如下。 import static org.springframework.data.jpa.domain.Spe...
jpa多表联查动态_JPA查询的动态参数数量
weixin_39796839的博客
12-21 288
How can I have dynamic number of parameters for a JPA query at runtime?For example,I am having a JPA query set asString queryString="Select x from Item x WHERE x.itemName=:name AND x.itemLocatio=:loca...
jpa动态条件查询
li5672的专栏
06-26 1416
jpa动态条件查询
JPA使用Specification动态where条件查询
胃病的不良少彦
09-18 4133
1. 想要的效果SQL select * from XXX where column_1 ='字段1的值' and column_2 ='字段2的值' and (column_3= '字段3的值' or column_3 ='字段3的第二个值') and LOCATE('字段4的值', column_4)>0 2.Specification 查询 ...
Jpa动态查询新方式，超级简单（附录源码）
qq_44322586的博客
01-26 1434
1：项目结构图 2：TUser.java /** * @Author ZGM * @DateTime 2021/12/31 * @description */ @Data @Entity @Table(name = "t_user") @AllArgsConstructor @NoArgsConstructor @DynamicUpdate @DynamicInsert public class TUser { @Id @JsonSerialize(using = ToString
JPA如何实现参数的动态查询
qq_16313575的博客
05-16 599
上面是我数据表的字段，我想动态查询资产类型、资产类别、资产型号、资产管理人的数据。
72、Spring Data JPA 的 Specification 动态查询
Java 领域技术分享
09-17 587
Spring Data JPA 的 Specification 动态查询
Spring Data JPA 实战 - 动态查询接口JpaSpecificationExecutor
最新发布
qq_33240556的博客
08-14 237
在使用Spring Data JPA进行开发时，动态查询是非常常见且重要的需求。是Spring Data JPA提供的一个扩展接口，它允许你执行更复杂的查询逻辑，特别是基于的动态查询。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值