AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

JPA自定义查询

2023-08-02 76
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： JPA自定义查询

在使用JPA过程中，写nativeQuery无法满足所有需求，只能寻求其他的途径，下面是一种方法

/**
* 增加过滤条件
*
* @return
*/
private Specification<User> listUserSpec(BizUserQueryCriteria criteria) {
   
   return (Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) -> {
   
       List<Predicate> list = new ArrayList<>();
       //常规查询条件
       list = QueryHelp.getList(list, root, criteria, cb);
       // order by id desc
       query.orderBy(cb.desc(root.get("id")));
       //子查询开始

       Subquery<User> subquery = query.subquery(User.class);
       Root<User> root1 = subquery.from(User.class);
       //select id from
       subquery = subquery.select(root1.get("id"));

       List<Predicate> sub = new ArrayList();
       if (criteria.getGradeFlag()) {
     // 年级不在指定值范围内
           String[] grades = new String[]{
   "六年级","初三"};
           sub.add(cb.not(root1.get("grade").in(Arrays.asList(grades))));
           //or grade not in ('六年级','初三')
       }
       if (criteria.getSchoolTypeFlag()) {
    // 学校类型不在指定值范围内
           String[] schoolTypes = new String[]{
   "小学","初中"};
           sub.add(cb.not(root1.get("schoolType").in(Arrays.asList(schoolTypes))));
           //or school_type not in ('小学','初中')
       }
       if (criteria.getCardNumFlag()) {
    // 身份证号码不符合规范
           sub.add(cb.and(cb.equal(root1.get("cardType"), "身份证"), cb.and(cb.notEqual(cb.length(cb.trim(root1.get("cardNum"))), 18), cb.notEqual(cb.length(cb.trim(root1.get("cardNum"))), 15))));
           //or (card_type` = '身份证' and length(`card_num`) <> 18 and length(`card_num`) <> 15)
       }
       if (criteria.getGenderFlag()) {
    // 性别为空
           sub.add(cb.or(cb.isNull(root1.get("gender")), cb.equal(cb.trim(root1.get("gender")), "")));
           //or gender is null
       }
       if (criteria.getSchoolYearFlag()) {
    // 学年不符合规范
           sub.add(cb.notEqual(cb.length(cb.trim(root1.get("schoolYear"))),15));
           //or (length(`school_year`) <> 15)
       }
       if (criteria.getSchoolYearNullFlag()) {
    //学年为空
           sub.add(cb.isNull(root1.get("schoolYear")));
           //or school_year is null
       }
       if (criteria.getHouseholdTypeFlag()) {
    // 户籍类型为空
           sub.add(cb.isNull(root1.get("householdType")));
           //or household_type is null
       }
       if (criteria.getRegionFlag()) {
    //区域或城市为空
           sub.add(cb.and(cb.isNull(root1.get("region")), cb.isNull(root1.get("outsideCity"))));
           //or (region is null and outside_city is null)
       }
       if (criteria.getCurrentAddressFlag()) {
    // 住址为空
           sub.add(cb.isNull(root1.get("currentAddress")));
           //or current_address is null
       }
       if (criteria.getAvatarPathFlag()) {
    // 头像为空
           sub.add(cb.isNull(root1.get("avatarPath")));
           //or avatar_path is null
       }
       int subSize = sub.size();
       if (subSize > 0) {
   
           Predicate predicate = cb.or(sub.toArray(new Predicate[subSize]));
           subquery = subquery.where(predicate);
           list.add(cb.and(root.get("id").in(subquery)));
       }
       int size = list.size();
       return cb.and(list.toArray(new Predicate[size]));
   };
}

// 调用
public List<User> queryAll(BizUserQueryCriteria criteria) {
   
    List<User> users = userRepository.findAll(listUserSpec(criteria));
}

可以研究一下 CriteriaBuilder ，有很多可能用得到的方法

package javax.persistence.criteria;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import javax.persistence.Tuple;

public interface CriteriaBuilder {
   
    CriteriaQuery<Object> createQuery();

    <T> CriteriaQuery<T> createQuery(Class<T> var1);

    CriteriaQuery<Tuple> createTupleQuery();

    <T> CriteriaUpdate<T> createCriteriaUpdate(Class<T> var1);

    <T> CriteriaDelete<T> createCriteriaDelete(Class<T> var1);

    <Y> CompoundSelection<Y> construct(Class<Y> var1, Selection<?>... var2);

    CompoundSelection<Tuple> tuple(Selection<?>... var1);

    CompoundSelection<Object[]> array(Selection<?>... var1);

    Order asc(Expression<?> var1);

    Order desc(Expression<?> var1);

    <N extends Number> Expression<Double> avg(Expression<N> var1);

    <N extends Number> Expression<N> sum(Expression<N> var1);

    Expression<Long> sumAsLong(Expression<Integer> var1);

    Expression<Double> sumAsDouble(Expression<Float> var1);

    <N extends Number> Expression<N> max(Expression<N> var1);

    <N extends Number> Expression<N> min(Expression<N> var1);

    <X extends Comparable<? super X>> Expression<X> greatest(Expression<X> var1);

    <X extends Comparable<? super X>> Expression<X> least(Expression<X> var1);

    Expression<Long> count(Expression<?> var1);

    Expression<Long> countDistinct(Expression<?> var1);

    Predicate exists(Subquery<?> var1);

    <Y> Expression<Y> all(Subquery<Y> var1);

    <Y> Expression<Y> some(Subquery<Y> var1);

    <Y> Expression<Y> any(Subquery<Y> var1);

    Predicate and(Expression<Boolean> var1, Expression<Boolean> var2);

    Predicate and(Predicate... var1);

    Predicate or(Expression<Boolean> var1, Expression<Boolean> var2);

    Predicate or(Predicate... var1);

    Predicate not(Expression<Boolean> var1);

    Predicate conjunction();

    Predicate disjunction();

    Predicate isTrue(Expression<Boolean> var1);

    Predicate isFalse(Expression<Boolean> var1);

    Predicate isNull(Expression<?> var1);

    Predicate isNotNull(Expression<?> var1);

    Predicate equal(Expression<?> var1, Expression<?> var2);

    Predicate equal(Expression<?> var1, Object var2);

    Predicate notEqual(Expression<?> var1, Expression<?> var2);

    Predicate notEqual(Expression<?> var1, Object var2);

    <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> var1, Expression<? extends Y> var2);

    <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> var1, Y var2);

    <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(Expression<? extends Y> var1, Expression<? extends Y> var2);

    <Y extends Comparable<? super Y>> Predicate greaterThanOrEqualTo(Expression<? extends Y> var1, Y var2);

    <Y extends Comparable<? super Y>> Predicate lessThan(Expression<? extends Y> var1, Expression<? extends Y> var2);

    <Y extends Comparable<? super Y>> Predicate lessThan(Expression<? extends Y> var1, Y var2);

    <Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(Expression<? extends Y> var1, Expression<? extends Y> var2);

    <Y extends Comparable<? super Y>> Predicate lessThanOrEqualTo(Expression<? extends Y> var1, Y var2);

    <Y extends Comparable<? super Y>> Predicate between(Expression<? extends Y> var1, Expression<? extends Y> var2, Expression<? extends Y> var3);

    <Y extends Comparable<? super Y>> Predicate between(Expression<? extends Y> var1, Y var2, Y var3);

    Predicate gt(Expression<? extends Number> var1, Expression<? extends Number> var2);

    Predicate gt(Expression<? extends Number> var1, Number var2);

    Predicate ge(Expression<? extends Number> var1, Expression<? extends Number> var2);

    Predicate ge(Expression<? extends Number> var1, Number var2);

    Predicate lt(Expression<? extends Number> var1, Expression<? extends Number> var2);

    Predicate lt(Expression<? extends Number> var1, Number var2);

    Predicate le(Expression<? extends Number> var1, Expression<? extends Number> var2);

    Predicate le(Expression<? extends Number> var1, Number var2);

    <N extends Number> Expression<N> neg(Expression<N> var1);

    <N extends Number> Expression<N> abs(Expression<N> var1);

    <N extends Number> Expression<N> sum(Expression<? extends N> var1, Expression<? extends N> var2);

    <N extends Number> Expression<N> sum(Expression<? extends N> var1, N var2);

    <N extends Number> Expression<N> sum(N var1, Expression<? extends N> var2);

    <N extends Number> Expression<N> prod(Expression<? extends N> var1, Expression<? extends N> var2);

    <N extends Number> Expression<N> prod(Expression<? extends N> var1, N var2);

    <N extends Number> Expression<N> prod(N var1, Expression<? extends N> var2);

    <N extends Number> Expression<N> diff(Expression<? extends N> var1, Expression<? extends N> var2);

    <N extends Number> Expression<N> diff(Expression<? extends N> var1, N var2);

    <N extends Number> Expression<N> diff(N var1, Expression<? extends N> var2);

    Expression<Number> quot(Expression<? extends Number> var1, Expression<? extends Number> var2);

    Expression<Number> quot(Expression<? extends Number> var1, Number var2);

    Expression<Number> quot(Number var1, Expression<? extends Number> var2);

    Expression<Integer> mod(Expression<Integer> var1, Expression<Integer> var2);

    Expression<Integer> mod(Expression<Integer> var1, Integer var2);

    Expression<Integer> mod(Integer var1, Expression<Integer> var2);

    Expression<Double> sqrt(Expression<? extends Number> var1);

    Expression<Long> toLong(Expression<? extends Number> var1);

    Expression<Integer> toInteger(Expression<? extends Number> var1);

    Expression<Float> toFloat(Expression<? extends Number> var1);

    Expression<Double> toDouble(Expression<? extends Number> var1);

    Expression<BigDecimal> toBigDecimal(Expression<? extends Number> var1);

    Expression<BigInteger> toBigInteger(Expression<? extends Number> var1);

    Expression<String> toString(Expression<Character> var1);

    <T> Expression<T> literal(T var1);

    <T> Expression<T> nullLiteral(Class<T> var1);

    <T> ParameterExpression<T> parameter(Class<T> var1);

    <T> ParameterExpression<T> parameter(Class<T> var1, String var2);

    <C extends Collection<?>> Predicate isEmpty(Expression<C> var1);

    <C extends Collection<?>> Predicate isNotEmpty(Expression<C> var1);

    <C extends Collection<?>> Expression<Integer> size(Expression<C> var1);

    <C extends Collection<?>> Expression<Integer> size(C var1);

    <E, C extends Collection<E>> Predicate isMember(Expression<E> var1, Expression<C> var2);

    <E, C extends Collection<E>> Predicate isMember(E var1, Expression<C> var2);

    <E, C extends Collection<E>> Predicate isNotMember(Expression<E> var1, Expression<C> var2);

    <E, C extends Collection<E>> Predicate isNotMember(E var1, Expression<C> var2);

    <V, M extends Map<?, V>> Expression<Collection<V>> values(M var1);

    <K, M extends Map<K, ?>> Expression<Set<K>> keys(M var1);

    Predicate like(Expression<String> var1, Expression<String> var2);

    Predicate like(Expression<String> var1, String var2);

    Predicate like(Expression<String> var1, Expression<String> var2, Expression<Character> var3);

    Predicate like(Expression<String> var1, Expression<String> var2, char var3);

    Predicate like(Expression<String> var1, String var2, Expression<Character> var3);

    Predicate like(Expression<String> var1, String var2, char var3);

    Predicate notLike(Expression<String> var1, Expression<String> var2);

    Predicate notLike(Expression<String> var1, String var2);

    Predicate notLike(Expression<String> var1, Expression<String> var2, Expression<Character> var3);

    Predicate notLike(Expression<String> var1, Expression<String> var2, char var3);

    Predicate notLike(Expression<String> var1, String var2, Expression<Character> var3);

    Predicate notLike(Expression<String> var1, String var2, char var3);

    Expression<String> concat(Expression<String> var1, Expression<String> var2);

    Expression<String> concat(Expression<String> var1, String var2);

    Expression<String> concat(String var1, Expression<String> var2);

    Expression<String> substring(Expression<String> var1, Expression<Integer> var2);

    Expression<String> substring(Expression<String> var1, int var2);

    Expression<String> substring(Expression<String> var1, Expression<Integer> var2, Expression<Integer> var3);

    Expression<String> substring(Expression<String> var1, int var2, int var3);

    Expression<String> trim(Expression<String> var1);

    Expression<String> trim(CriteriaBuilder.Trimspec var1, Expression<String> var2);

    Expression<String> trim(Expression<Character> var1, Expression<String> var2);

    Expression<String> trim(CriteriaBuilder.Trimspec var1, Expression<Character> var2, Expression<String> var3);

    Expression<String> trim(char var1, Expression<String> var2);

    Expression<String> trim(CriteriaBuilder.Trimspec var1, char var2, Expression<String> var3);

    Expression<String> lower(Expression<String> var1);

    Expression<String> upper(Expression<String> var1);

    Expression<Integer> length(Expression<String> var1);

    Expression<Integer> locate(Expression<String> var1, Expression<String> var2);

    Expression<Integer> locate(Expression<String> var1, String var2);

    Expression<Integer> locate(Expression<String> var1, Expression<String> var2, Expression<Integer> var3);

    Expression<Integer> locate(Expression<String> var1, String var2, int var3);

    Expression<Date> currentDate();

    Expression<Timestamp> currentTimestamp();

    Expression<Time> currentTime();

    <T> CriteriaBuilder.In<T> in(Expression<? extends T> var1);

    <Y> Expression<Y> coalesce(Expression<? extends Y> var1, Expression<? extends Y> var2);

    <Y> Expression<Y> coalesce(Expression<? extends Y> var1, Y var2);

    <Y> Expression<Y> nullif(Expression<Y> var1, Expression<?> var2);

    <Y> Expression<Y> nullif(Expression<Y> var1, Y var2);

    <T> CriteriaBuilder.Coalesce<T> coalesce();

    <C, R> CriteriaBuilder.SimpleCase<C, R> selectCase(Expression<? extends C> var1);

    <R> CriteriaBuilder.Case<R> selectCase();

    <T> Expression<T> function(String var1, Class<T> var2, Expression<?>... var3);

    <X, T, V extends T> Join<X, V> treat(Join<X, T> var1, Class<V> var2);

    <X, T, E extends T> CollectionJoin<X, E> treat(CollectionJoin<X, T> var1, Class<E> var2);

    <X, T, E extends T> SetJoin<X, E> treat(SetJoin<X, T> var1, Class<E> var2);

    <X, T, E extends T> ListJoin<X, E> treat(ListJoin<X, T> var1, Class<E> var2);

    <X, K, T, V extends T> MapJoin<X, K, V> treat(MapJoin<X, K, T> var1, Class<V> var2);

    <X, T extends X> Path<T> treat(Path<X> var1, Class<T> var2);

    <X, T extends X> Root<T> treat(Root<X> var1, Class<T> var2);

    public interface Case<R> extends Expression<R> {
   
        CriteriaBuilder.Case<R> when(Expression<Boolean> var1, R var2);

        CriteriaBuilder.Case<R> when(Expression<Boolean> var1, Expression<? extends R> var2);

        Expression<R> otherwise(R var1);

        Expression<R> otherwise(Expression<? extends R> var1);
    }

    public interface SimpleCase<C, R> extends Expression<R> {
   
        Expression<C> getExpression();

        CriteriaBuilder.SimpleCase<C, R> when(C var1, R var2);

        CriteriaBuilder.SimpleCase<C, R> when(C var1, Expression<? extends R> var2);

        Expression<R> otherwise(R var1);

        Expression<R> otherwise(Expression<? extends R> var1);
    }

    public interface Coalesce<T> extends Expression<T> {
   
        CriteriaBuilder.Coalesce<T> value(T var1);

        CriteriaBuilder.Coalesce<T> value(Expression<? extends T> var1);
    }

    public interface In<T> extends Predicate {
   
        Expression<T> getExpression();

        CriteriaBuilder.In<T> value(T var1);

        CriteriaBuilder.In<T> value(Expression<? extends T> var1);
    }

    public static enum Trimspec {
   
        LEADING,
        TRAILING,
        BOTH;

        private Trimspec() {
   
        }
    }
}
文章标签：
Java
左边的天堂
目录
相关文章
子午s
|
存储 缓存 数据库
提高Djang查询速度的9种方法
在Web应用程序中，数据库查询是一个关键的环节。优化数据库查询可以显著提高应用程序的性能和响应速度。Django作为一个高度可扩展的Web框架，提供了多种方式来优化数据库查询。本文将介绍一些常用的Django数据库查询优化技巧，从入门到精通，帮助您构建高效的应用程序。
子午s
154 1
复活的炎头队长
|
Unix 关系型数据库 程序员
自定义伟大👑
C语言作为一种经典而强大的编程语言，在计算机科学领域有着广泛的应用。它的简洁性、高效性以及跨平台特性使得C语言成为了开发系统级软件、嵌入式系统以及大规模应用程序的首选。本文将介绍C语言的起源和发展，分析其特点和优势，同时讨论一些常见的应用场景和实例
复活的炎头队长
70 0
真题OK撒
|
7月前
|
XML Java 数据库连接
【MyBtis】各种查询功能
【MyBtis】各种查询功能
真题OK撒
109 0
叫我默语
|
SQL Java 数据库
spring boot CRUD(查询全部，查询ID,模糊查询，删除id，全部删除，新增多条/单条 修改)（一）
spring boot CRUD(查询全部，查询ID,模糊查询，删除id，全部删除，新增多条/单条 修改)（一）
叫我默语
229 0
叫我默语
|
Java Spring
spring boot CRUD(查询全部，查询ID,模糊查询，删除id，全部删除，新增多条/单条 修改)（二）
spring boot CRUD(查询全部，查询ID,模糊查询，删除id，全部删除，新增多条/单条 修改)（二）
叫我默语
121 0
huihuizi
list自定义参数分页
list自定义参数分页
huihuizi
88 0
代码的天敌是懒惰
自定义 RecordReader
自定义 RecordReader
代码的天敌是懒惰
120 0
代码的天敌是懒惰
自定义 InputSplit
自定义 InputSplit
代码的天敌是懒惰
107 0
沉默王二
|
SQL 关系型数据库 MySQL
你会不会用mysql查询近7个月的数据？没有记录默认为空
你会不会用mysql查询近7个月的数据？没有记录默认为空
沉默王二
229 0
你会不会用mysql查询近7个月的数据？没有记录默认为空
学堂小助手
|
SQL Java 数据库连接
分页之查询条件保存到 PageBean 的 url 中| 学习笔记
快速学习分页之查询条件保存到 PageBean 的 url 中
学堂小助手
176 0

热门文章

最新文章

  • 1
    四大触点，教你从“用户视角”构建数据分析体系
  • 2
    Spring-boot+Dubbo应用启停源码分析
  • 3
    《Stata统计分析与应用（第2版）》一3.4 图形的保存、合并及修改
  • 4
    RocketMq-Request-Reply消息
  • 5
    Confluence 6 手动添加用户
  • 6
    2013年4月20日 通用权限管理系统组件V3.8功能改进说明
  • 7
    Configuring EIGRP Unequal-Cost Paths
  • 8
    PowerShell 指定关键词遍历文件内容
  • 9
    Windows时间服务出现故障 向用户发送错误的时间
  • 10
    三种dedecms调用相关文章的方法
  • 1
    《鸿蒙HarmonyOS应用开发从入门到精通（第2版）》简介
    51
  • 2
    《Python 助力：人工智能模型的“瘦身”与“加速”之旅》
    110
  • 3
    《非计算机专业者：Python 开启人工智能职业新航道》
    39
  • 4
    《Python赋能：智绘智慧城市新蓝图》
    42
  • 5
    《智育新篇：点亮学生人工智能伦理与社会责任之光》
    47
  • 6
    《数据主权：人工智能时代的核心基石与挑战》
    33
  • 7
    鸿蒙HarmonyOS应用开发 | 探索 HarmonyOS Next-从开发到实战掌握 HarmonyOS Next 的分布式能力
    109
  • 8
    鸿蒙原生开发环境的创新与性能优化：从工具到跨平台支持的全方位提升
    267
  • 9
    鸿蒙HarmonyOS应用开发 | 「鸿蒙技术分享」HarmonyOS NEXT元服务卡片实战体验
    161
  • 10
    Qwen-Coder：通过Qwen 2.5模型实现智能代码生成的技术实践
    38

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册

    • 相关实验场景

    更多
  • 使用Count功能批量创建资源
    • 下一篇
    DataWorks售前咨询