分享一个jpa的where条件生成工具类

最新推荐文章于 2022-07-16 22:34:19 发布
最新推荐文章于 2022-07-16 22:34:19 发布
阅读量648 收藏
点赞数
分类专栏： 后台 文章标签： java 后端 jpa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaoji8151/article/details/106024646
版权

jpa中自己拼接where条件写一大堆Predicate和CriteriaBuilder进行拼接写一大堆if-else 会有大量代码冗余，于是出现了帮助类来解决where条件生成的代码

jpa的where条件生成帮助类为两个：
Query用来指定使用什么方式查询；QueryHelp用来生成条件语句。

Query 类：

package com.starcity.utils;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.starcity.annotation.Query;
import lombok.extern.slf4j.Slf4j;
import org.hibernate.query.criteria.internal.ValueHandlerFactory;

import javax.persistence.criteria.*;
import java.lang.reflect.Field;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.joining;

/**
 * @author WeiMaoMao
 * @date
 */
@Slf4j
@SuppressWarnings({"unchecked", "all"})
public class QueryHelp {

    public static <R, Q> Predicate getPredicate(Root<R> root, Q query, CriteriaBuilder cb) {
        List<Predicate> list = new ArrayList<>();

        if (query == null) {
            return cb.and(list.toArray(new Predicate[0]));
        }
        try {
            List<Field> fields = getAllFields(query.getClass(), new ArrayList<>());
            for (Field field : fields) {
                boolean accessible = field.isAccessible();
                field.setAccessible(true);
                Query q = field.getAnnotation(Query.class);
                if (q != null) {
                    String propName = q.propName();
                    String joinName = q.joinName();
                    String blurry = q.blurry();
                    String attributeName = isBlank(propName) ? field.getName() : propName;
                    Class<?> fieldType = field.getType();
                    Object val = field.get(query);
                    if (ObjectUtil.isNull(val) || "".equals(val)) {
                        continue;
                    }
                    Join join = null;
                    // 模糊多字段
                    if (ObjectUtil.isNotEmpty(blurry)) {
                        String[] blurrys = blurry.split(",");
                        List<Predicate> orPredicate = new ArrayList<>();
                        for (String s : blurrys) {
                            orPredicate.add(cb.like(root.get(s)
                                    .as(String.class), "%" + val.toString() + "%"));
                        }
                        Predicate[] p = new Predicate[orPredicate.size()];
                        list.add(cb.or(orPredicate.toArray(p)));
                        continue;
                    }
                    if (ObjectUtil.isNotEmpty(joinName)) {
                        String[] joinNames = joinName.split(">");
                        for (String name : joinNames) {
                            switch (q.join()) {
                                case LEFT:
                                    if (ObjectUtil.isNotNull(join)) {
                                        join = join.join(name, JoinType.LEFT);
                                    } else {
                                        join = root.join(name, JoinType.LEFT);
                                    }
                                    break;
                                case RIGHT:
                                    if (ObjectUtil.isNotNull(join)) {
                                        join = join.join(name, JoinType.RIGHT);
                                    } else {
                                        join = root.join(name, JoinType.RIGHT);
                                    }
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                    switch (q.type()) {
                        case EQUAL:
                            list.add(cb.equal(getExpression(attributeName, join, root)
                                    .as((Class<? extends Comparable>) fieldType), val));
                            break;
                        case GREATER_THAN:
                            list.add(cb.greaterThanOrEqualTo(getExpression(attributeName, join, root)
                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
                            break;
                        case LESS_THAN:
                            list.add(cb.lessThanOrEqualTo(getExpression(attributeName, join, root)
                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
                            break;
                        case LESS_THAN_NQ:
                            list.add(cb.lessThan(getExpression(attributeName, join, root)
                                    .as((Class<? extends Comparable>) fieldType), (Comparable) val));
                            break;
                        case INNER_LIKE:
                            list.add(cb.like(getExpression(attributeName, join, root)
                                    .as(String.class), "%" + val.toString() + "%"));
                            break;
                        case LEFT_LIKE:
                            list.add(cb.like(getExpression(attributeName, join, root)
                                    .as(String.class), "%" + val.toString()));
                            break;
                        case RIGHT_LIKE:
                            list.add(cb.like(getExpression(attributeName, join, root)
                                    .as(String.class), val.toString() + "%"));
                            break;
                        case IN:
                            if (CollUtil.isNotEmpty((Collection<Long>) val)) {
                                list.add(getExpression(attributeName, join, root).in((Collection<Long>) val));
                            }
                            break;
                        case NOT_EQUAL:
                            list.add(cb.notEqual(getExpression(attributeName, join, root), val));
                            break;
                        case NOT_NULL:
                            list.add(cb.isNotNull(getExpression(attributeName, join, root)));
                            break;
                        case NULL:
                            if((boolean)val){
                                list.add(cb.isNull(getExpression(attributeName, join, root)));
                            }
                            break;
                        case BETWEEN:
                            List<Object> between = new ArrayList<>((List<Object>) val);
                            list.add(cb.between(getExpression(attributeName, join, root).as((Class<? extends Comparable>) between.get(0).getClass()),
                                    (Comparable) between.get(0), (Comparable) between.get(1)));
                            break;
                        default:
                            break;
                    }
                }
                field.setAccessible(accessible);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        int size = list.size();
        return cb.and(list.toArray(new Predicate[size]));
    }

    @SuppressWarnings("unchecked")
    private static <T, R> Expression<T> getExpression(String attributeName, Join join, Root<R> root) {
        if (ObjectUtil.isNotEmpty(join)) {
            return join.get(attributeName);
        } else {
            return root.get(attributeName);
        }
    }

    private static boolean isBlank(final CharSequence cs) {
        int strLen;
        if (cs == null || (strLen = cs.length()) == 0) {
            return true;
        }
        for (int i = 0; i < strLen; i++) {
            if (!Character.isWhitespace(cs.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    private static List<Field> getAllFields(Class clazz, List<Field> fields) {
        if (clazz != null) {
            fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
            getAllFields(clazz.getSuperclass(), fields);
        }
        return fields;
    }


    public static <Q> StringBuffer buildSqlWhere(Q query, StringBuffer sql) {

        if (query == null) {
            return sql;
        }
        try {
            List<Field> fields = getAllFields(query.getClass(), new ArrayList<>());
            for (Field field : fields) {
                boolean accessible = field.isAccessible();
                field.setAccessible(true);
                Query q = field.getAnnotation(Query.class);
                if (q != null) {
                    String propName = q.propName();
                    String joinName = q.joinName();
                    String blurry = q.blurry();
                    String attributeName = isBlank(propName) ? field.getName() : propName;
                    Class<?> fieldType = field.getType();
                    Object val = field.get(query);
                    if (ObjectUtil.isNull(val) || "".equals(val)) {
                        continue;
                    }
                    // 模糊多字段
                    if (ObjectUtil.isNotEmpty(blurry)) {
                        String[] blurrys = blurry.split(",");
                        sql.append(" and (");
                        for (int i = 0; i < blurrys.length; i++) {
                            if (i != 0 && i < blurrys.length) {
                                sql.append(" or ");
                            }
                            sql.append(" " + blurrys[i] + " like '%" + val.toString() + "%'");
                        }
                        sql.append(")");
                        continue;
                    }
                    if (ObjectUtil.isNotEmpty(joinName)) {
                        String[] joinNames = joinName.split(">");
                        for (String name : joinNames) {
                            switch (q.join()) {
                                case LEFT:
                                    sql.append(" left join " + name);
                                    break;
                                case RIGHT:
                                    sql.append(" right join " + name);
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                    switch (q.type()) {
                        case EQUAL:
                            checkStringAndNum(fieldType, sql, "=", attributeName, val);
                            break;
                        case GREATER_THAN:
                            checkStringAndNum(fieldType, sql, ">=", attributeName, val);
                            break;
                        case LESS_THAN:
                            checkStringAndNum(fieldType, sql, "<=", attributeName, val);
                            break;
                        case LESS_THAN_NQ:
                            checkStringAndNum(fieldType, sql, "<", attributeName, val);
                            break;
                        case INNER_LIKE:
                            sql.append(" and " + attributeName + " like '%" + val.toString() + "%' ");
                            break;
                        case LEFT_LIKE:
                            sql.append(" and " + attributeName + " like '%" + val.toString() + "' ");
                            break;
                        case RIGHT_LIKE:
                            sql.append(" and " + attributeName + " like '" + val.toString() + "%' ");
                            break;
                        case IN:
                            if (CollUtil.isNotEmpty((Collection<Object>) val)) {
                                Collection<Object> list = (Collection<Object>) val;
                                Object o = list.stream().findFirst().orElse(null);
                                if (ValueHandlerFactory.isNumeric(o.getClass())) {
                                    Collection<Number> numberList = (Collection<Number>) val;
                                    sql.append(" and " + attributeName + " in (" + list.stream().map(item->item+"").collect(joining(",")) + ")");
                                } else {
                                    Collection<String> strList = (Collection<String>) val;
                                    sql.append(" and " + attributeName + " in ('" + strList.stream().collect(Collectors.joining("','")) + "')");
                                }
                            }
                            break;
                        case NOT_EQUAL:
                            checkStringAndNum(fieldType, sql, "!=", attributeName, val);
                            break;
                        case NOT_NULL:
                            sql.append(" and " + attributeName + " IS NOT NULL ");
                            break;
                        case NULL:
                            if((boolean)val){
                                sql.append(" and " + attributeName + " IS NULL ");
                            }
                            break;
                        case BETWEEN:
                            List<Object> between = new ArrayList<>((List<Object>) val);
                            if (ValueHandlerFactory.isNumeric(fieldType)) {
                                sql.append(" and " + attributeName + " BETWEEN " + between.get(0) + " AND " + between.get(1));
                                break;
                            }
                            sql.append(" and " + attributeName + " BETWEEN '" + between.get(0) + "' AND '" + between.get(1) + "' ");
                            break;
                        default:
                            break;
                    }
                }
                field.setAccessible(accessible);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return sql;
    }


    /**
     * 仅仅构建where的部分
     * @param query
     * @param sql
     * @param <Q>
     * @return
     */
    public static <Q> StringBuffer buildSqlOnlyWhere(Q query) {
        StringBuffer sql=new StringBuffer();

        if (query == null) {
            return sql;
        }
        try {
            List<Field> fields = getAllFields(query.getClass(), new ArrayList<>());
            for (Field field : fields) {
                boolean accessible = field.isAccessible();
                field.setAccessible(true);
                Query q = field.getAnnotation(Query.class);
                if (q != null) {
                    String propName = q.propName();
                    String joinName = q.joinName();
                    String blurry = q.blurry();
                    String attributeName = isBlank(propName) ? field.getName() : propName;
                    Class<?> fieldType = field.getType();
                    Object val = field.get(query);
                    if (ObjectUtil.isNull(val) || "".equals(val)) {
                        continue;
                    }
                    // 模糊多字段
                    if (ObjectUtil.isNotEmpty(blurry)) {
                        String[] blurrys = blurry.split(",");
                        sql.append(" and (");
                        for (int i = 0; i < blurrys.length; i++) {
                            if (i != 0 && i < blurrys.length) {
                                sql.append(" or ");
                            }
                            sql.append(" " + blurrys[i] + " like '%" + val.toString() + "%'");
                        }
                        sql.append(")");
                        continue;
                    }
                    if (ObjectUtil.isNotEmpty(joinName)) {
                        String[] joinNames = joinName.split(">");
                        for (String name : joinNames) {
                            switch (q.join()) {
                                case LEFT:
                                    sql.append(" left join " + name);
                                    break;
                                case RIGHT:
                                    sql.append(" right join " + name);
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                    switch (q.type()) {
                        case EQUAL:
                            checkStringAndNum(fieldType, sql, "=", attributeName, val);
                            break;
                        case GREATER_THAN:
                            checkStringAndNum(fieldType, sql, ">=", attributeName, val);
                            break;
                        case LESS_THAN:
                            checkStringAndNum(fieldType, sql, "<=", attributeName, val);
                            break;
                        case LESS_THAN_NQ:
                            checkStringAndNum(fieldType, sql, "<", attributeName, val);
                            break;
                        case INNER_LIKE:
                            sql.append(" and " + attributeName + " like '%" + val.toString() + "%' ");
                            break;
                        case LEFT_LIKE:
                            sql.append(" and " + attributeName + " like '%" + val.toString() + "' ");
                            break;
                        case RIGHT_LIKE:
                            sql.append(" and " + attributeName + " like '" + val.toString() + "%' ");
                            break;
                        case IN:
                            if (CollUtil.isNotEmpty((Collection<String>) val)) {
                                if (ValueHandlerFactory.isNumeric(fieldType)) {
                                    sql.append(" and " + attributeName + " in (" + ((Collection<String>) val).stream().collect(joining(",")) + ")");
                                } else {
                                    sql.append(" and " + attributeName + " in ('" + ((Collection<String>) val).stream().collect(joining("','")) + "')");
                                }
                            }
                            break;
                        case NOT_EQUAL:
                            checkStringAndNum(fieldType, sql, "!=", attributeName, val);
                            break;
                        case NOT_NULL:
                            sql.append(" and " + attributeName + " IS NOT NULL ");
                            break;
                        case NULL:
                            if((boolean)val){
                                sql.append(" and " + attributeName + " IS NULL ");
                            }
                            break;
                        case BETWEEN:
                            List<Object> between = new ArrayList<>((List<Object>) val);
                            if (ValueHandlerFactory.isNumeric(fieldType)) {
                                sql.append(" and " + attributeName + " BETWEEN " + between.get(0) + " AND " + between.get(1));
                                break;
                            }
                            sql.append(" and " + attributeName + " BETWEEN '" + between.get(0) + "' AND '" + between.get(1) + "' ");
                            break;
                        default:
                            break;
                    }
                }
                field.setAccessible(accessible);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return sql;
    }
    /**
     * 判断字段类型并加入引号
     *
     * @param fieldType     字段类型
     * @param sql           总体sql
     * @param type          = >= <=
     * @param attributeName 字段名称
     * @param val           字段值
     */
    private static void checkStringAndNum(Class<?> fieldType, StringBuffer sql, String type, String attributeName, Object val) {
        if (attributeName.equals("enabled")) {
            System.out.println(ValueHandlerFactory.isBoolean(val));
        }
        //如果是数字类型
        if (ValueHandlerFactory.isNumeric(fieldType)) {
            sql.append(" and " + attributeName + " " + type + " " + val);
        }//如果是boolean
        else if (ValueHandlerFactory.isBoolean(val)) {
            sql.append(" and " + attributeName + " " + type + " " + ((Boolean) val ? 1 : 0) + "");
        }//字符
        else {
            sql.append(" and " + attributeName + " " + type + " '" + val + "' ");
        }
    }

}

QueryHelp上面有三个方法：
第一个方法是jpa自身调用时引用
第二个方法是使用entityManager.createNativeQuery调用
第三个方法是只生成where条件，用于自己拼接

举例说明：
第一种：
在这里插入图片描述在这里插入图片描述
第二种：
在这里插入图片描述
在这里插入图片描述
第三种不出示例喽。

魏卯卯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-boot：使用JPA访问数据源（二）实现where条件，order by查询
zhibin的程序日记
02-13 3817
上一篇文章：spring-boot：使用JPA访问数据源（一） 一、使用where条件 上一篇我们使用JPA进行了数据源的访问，默认JPA已经实现了好几个接口可以调用。但是，在实际的业务中，查询语句不可避免地需要使用where、order by等语句。 我们用商品数据来做例子，添加一个价格字段price，按价格范围查询，看看怎么来实现。 方式一：通过方法名称来实现 public int...
jpa自动代码生成工具
08-16
本工具可以根据数据库表自动生成JPA开发所需的实体JavaBean（带有jpa主注解）、repository及service类，提高开发效率；目前支持数据库：MYSQL；并提供配合演示使用的demo项目。
SpringDataJPA 动态查询，JpaSpecificationExecutor 快速条件构造工具类
qq_41664621的博客
12-06 614
版权声明：本文为博主原创文章转载请附上原文出处链接。
JPA - @Where注解 - 添加条件查询
Maggieq8324的博客
08-17 3996
目录前言具体实现 前言 这里介绍@Where注解给Entity统一添加条件查询。 具体实现 Product.java @Entity @Getter @Setter @Where(clause = "delete_time is null") public class Product { @Id private int id; private String title; private Date createTime; private Date deleteT
JPA动态拼接where条件
热门推荐
心寒的博客
06-28 1万+
在开发中，经常会涉及到动态拼接sql，以下就是JPA使用三元运算符的方式拼接条件案例： @Query(value = "select * from user a where if(?1 !='',id=?1 ,1=1 ) ",nativeQuery = true) public List<User> findPersonById(String id); 写了一个简单的根据id查找用户的案例，首先不输入id，则返回所有数据，如下： 如果输入id则只返回对应的用户：
java sqlcondition,sqlCondition where条件生成器 主要用于表格筛选
weixin_31141099的博客
03-13 825
packagecom.yiyikefu.sqlconditionkit;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;importjava.util.Set;/****Title:SqlCondition.java*Description:sq...
jpa代码自动生成工具-springboot
07-06
jpa代码自动生成工具- 自动生成domain/dao/service/controller
springboot jpa 自动生成实体类的 文件 Generate POJOs.groovy
06-01
springboot jpa 自动生成实体类的 文件 可以拿走直接用 Generate POJOs.groovy
idea hibernate jpa 生成实体类的实现
08-25
主要介绍了idea hibernate jpa 生成实体类的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
SpringData框架中的JPA工具类
10-02
SpringData框架中使用的JPA工具类.模板代码,解决实体管理器工厂的浪费资源和耗时问题.第一次访问getEntityManager方法：经过静态代码块创建一个factory对象，再调用方法创建一个EntityManager对象,第二次方法...
JPA 关联表添加关联条件@Where、@WhereJoinTable()
你当像鸟飞往你的山~~
11-27 5164
JPA 关联表添加关联条件，当我其中一个表的数据状态发送改变，不是业务上所需要的，这时实体查询还是会带出关联数据，所以我们需要处理这部分数据；第一种方式：删除中间表对应数据；第二种添加关联条件，按条件带出有效数据 代码示例 用户实体 @Entity @Table(name = "pmi_t_user") @org.hibernate.annotations.Table(applie...
jpa使用@Where注解来实现统一加条件
enthan809882的博客
10-31 1万+
JpaRepository已经封装好了许多方法，例如：findAll，但是实际中我们往往要加入一些条件，例如del_flag= 0 ，难道要改JpaRepository的源码么，当然不： 在实体类中使用@Where即可。 @Entity @Where(clause="del_Flag = 0 ") public class Category { } 那么打印的sql为： 可以发现自动加上查询条...
JPA使用Specification动态where条件查询
胃病的不良少彦
09-18 3943
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多属性排序以及JPAwhere多条件动态查询
HD243608836的博客
03-02 2394
PageRequest pageable = PageRequest.of(page, limit,new Sort(Direction.DESC,"XXX").and(new Sort(Direction.DESC,"XXX"))); 1. 动态Where条件查询 注意如果有动态where，而且没有一项确定的值，需要加where 1=1 如果不为空查询，为空不查询 @Query(...
JPA使用
爱吃鱼油
07-24 1091
dao Interface继承Repository接口 可以直接继承Repository也可以继承下面的子接口 CrudRepository  (Spring Data提供) 继承Repository，提供增删改查方法，可以直接调用。 PagingAndSortingRepository (Spring Data提供) 继承CrudRepository，增加了分页查询和排序两个方法
Java 多条件查询语句组合工具类
Aicken_mocking的博客
05-25 682
package util; import java.sql.Date; public class Expression { StringBuffer exp = new StringBuffer(); int count = 0; boolean leftbra = false; // 代表左边的括号 boolean orderflag = false; // 排序出现标志 boolean between = false;// 代表between and里between出现的标志 /**
jpa中的帮助方法,一般用在双向关联中
enthan809882的博客
12-14 115
例如一对多双向关联中： @OneToMany(mappedBy = "person", cascade = CascadeType.ALL, orphanRemoval = true) private List<Phone> phones = new ArrayList<>(); //Getters and setters are omitted for brevity ...
springboot jpa实现多条件动态查询
qq_39880995的博客
07-01 602
@Override public Map <String, Object> gwlzList(A07DocumentGwlzQueryCriteria criteria, Pageable pageable) { Page<A07DocumentGwlz> page = a07DocumentgwlzRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(r.
解决mybatis-plus where直接拼接and/or条件连接语句
呆萌小新@渊洁的博客
07-16 6143
反例2and条件不符合相当于没有,不看;剩下wrapper.apply(“1=1”).last(“1=1”).连接句直接不.or()默认and连接,背景用户可以输入以下内容.不输入即为全查询.因此。因此即为’where(1=1and)1=1’(重点将该检索字段的sql拼接)反例1直接拼接了连接语句.......
JPA批量条件操作（where in）
最新发布
06-01
JPA中批量条件操作可以使用WHERE IN子句实现。具体步骤如下： 1. 在Repository或Dao接口中声明一个方法，方法名可以自定义，建议使用语义化的名称。 2. 在方法中使用@Query注解，指定JPQL语句和参数。 3. 在JPQL...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值