SpringDataJPA使用Specification动态查询和分页

最新推荐文章于 2024-07-29 11:02:40 发布

程序员DD

最新推荐文章于 2024-07-29 11:02:40 发布

阅读量1k

点赞数

分类专栏： Java 文章标签： java sql

本文链接：https://blog.csdn.net/zgz102928/article/details/124369432

版权

Java 专栏收录该内容

120 篇文章 42 订阅

订阅专栏

本文详细介绍了Java JPA的Specification接口用于动态查询的方法，包括Predicate的构建、组合查询条件以及如何使用Specification进行复杂条件的组合。示例代码展示了如何根据实体属性进行like和equal操作，并通过Specification进行分页和排序。同时，文章还讨论了toArray方法在不同情况下的使用，特别是处理列表转换为数组时的注意事项。

摘要由CSDN通过智能技术生成

之前在进行动态查询，匹配条件的时候一直不清楚对应的Predicate的查询方法和对应的规范信息，现在进行记录着重的讲一下对应的解读的方法

Specification核心方法

Predicate toPredicate(Root var1, CriteriaQuery<?> var2, CriteriaBuilder var3);

Root:代表查询的根对象即实体
CriteriaQuery : 顶层查询对象****,用于自定义查询方式基本不用
CriteriaBuilder:查询构造器,封装了很多的查询条件

 @Test
    public  void testSpecification(){
        //查询菜单名包含 测试 和菜单id=1212的数据


        Specification<SysMenu> specification=(root,query,buidler)->{
            //获取比较对象 从root中获取
            Path<String> menuName = root.get("menuName");
            //比较值
            Predicate pre1 = buidler.like(menuName, "测试%");

            //获取比较对象 从root中获取
            Path<Long> id = root.get("menuId");
            //比较值
            Predicate pre2 = buidler.equal(id, 1212l);


            //组装对象 使用buidler

            Predicate and = buidler.or(pre1,pre2);
            return and;
        };

        //构建排序
        Sort sort=Sort.by("menuId").descending();
        List<SysMenu> menuList=   dao.findAll(specification,sort);
        menuList.forEach(p-> System.out.println(p));
        //分页
        Pageable pageable=PageRequest.of(1,1,sort);
        Page<SysMenu> all = dao.findAll(specification, pageable);
        System.out.println(all.getTotalElements());
        System.out.println(all.getTotalPages());
        System.out.println(all.getContent());


    }

组合多条件复杂查询

public void test(){
       //第一个Specification定义了两个or的equal组合
      Specification<Dept> s1 = (root, criteriaQuery, criteriaBuilder) -> {
            Predicate p1 = criteriaBuilder.equal(root.get("deptno"), "20");
           Predicate p2 = criteriaBuilder.equal(root.get("deptno"), "30");
           return criteriaBuilder.or(p1, p2);
      };
        //第二个Specification定义了两个or的like组合
       Specification<Dept> s2 = (root, criteriaQuery, criteriaBuilder) -> {
          Predicate p1 = criteriaBuilder.like(root.get("dname"), "%S%");
            Predicate p2 = criteriaBuilder.like(root.get("loc"), "AS%");
           return criteriaBuilder.or(p1, p2);
     };
      //通过Specification将两个Specification连接起来，第一个条件加where，第二个是and
      List<Dept> depts = deptDao.findAll(Specification.where(s1).and(s2));
       depts.forEach(System.out::println);

}

这里面做一个小插曲，看了之前的一个list.toArray的方法对一些东西有了新的认识

  private Specification<RecommendRule> buildSpecification(String id, String ruleName, Boolean immediatelyTriggered) {
        return (root, query, cb) -> {
            List<Predicate> predicateList = new ArrayList<>();

            if (StringUtils.hasText(id)) {
                predicateList.add(cb.equal(root.get("id").as(String.class), id));
            }
            if (StringUtils.hasText(ruleName)) {
                predicateList.add(cb.like(root.get("ruleName").as(String.class), "%" + ruleName + "%"));
            }
            if (immediatelyTriggered != null) {
                predicateList.add(cb.equal(root.get("immediatelyTriggered").as(boolean.class), immediatelyTriggered));
            }
            return cb.and(predicateList.toArray(new Predicate[0]));
        };
    }

之前在toArray中对应的new Prediccate[0]中对应的返回的方法不太清楚

做力扣的每日一题时发现可以使用toArray()方法将list转为数组, 之前没怎么用过这个方法

list.toArray()方法不接收参数时, 返回一个Object数组
感觉这个不常用, 毕竟平时用到的list都指定了类型
ArrayList类中的toArray()方法源代码, 作用: 将elementData数组中的元素拷贝到长度为size的Object数组中, 并返回这个Object数组

// transient Object[] elementData; 存放list中的各个元素
// private int size; list中元素的个数
public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

List<Object> list2 = new ArrayList<>();
//添加不同类型的元素, 但一般不会这么使用list...
list2.add(3);
list2.add('q');
list2.add("haha");
list2.add(new Integer(10));
Object[] objs = list2.toArray();
System.out.println(Arrays.toString(objs));
/*
打印结果
[3, q, haha, 10]
*/

toArray(T[] a)方法接收T类型的数组, 返回一个T类型的数组

public <T> T[] toArray(T[] a) {
	//如果传入的数组的长度小于list中的元素个数
    if (a.length < size)
	    //通过Arrays.copyOf()方法进行拷贝, 内部会创建一个T类型的数组, 长度为size, 和a就没有关系了
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    //如果传入的数组的长度大于等于list中的元素个数, 那么直接将elementData中的元素拷贝到a中
    System.arraycopy(elementData, 0, a, 0, size);
    //如果传入的数组的长度大于list中的元素个数, 将a[size]赋值为null, 这里我有疑问, 不显式赋值的话, a[size]也为null吧? 为什么要加上这句呢?
    if (a.length > size)
        a[size] = null;
    return a;
}

主要是对比toArray(T[] a)中a的长度和list中的元素个数size
如果a.length>=size, 那么直接调用System.arraycopy方法将elementData中的元素拷贝到a中即可
如果a.length<size, 那么需要 Arrays.copyOf方法进行拷贝, 创建一个长度为size的新数组接收elementData中的元素, 之前传入的数组a已经没用了 toArray(T[] a)的使用示例

List<String> list = new ArrayList<>();
list.add("flower");
list.add("dance");
list.add("is");
list.add("excellent");
//返回值类型和方法参数类型一致
//换句话说, 本来由list存各个String, 现在由String[]存各个String
//换句话说, 本来由list存各个String, 现在由String[]存各个String
//换句话说, 本来由list存各个String, 现在由String[]存各个String
//数组的长度指定为0或者指定为list.size()都可以. 即使传入的数组长度不够也没关系, 会创建新数组
String[] strs = list.toArray(new String[0]);
System.out.println(Arrays.toString(strs));
/*
打印结果
[flower, dance, is, excellent]
*/

//如果是转成以为整型数组, 得用stream(), 因为int不是引用类型, 例子:list.stream().mapToInt(k -> k).toArray()

List<int[]> list = new ArrayList<>();
list.add(new int[]{1,2});
list.add(new int[]{4,5});
list.add(new int[]{7,9});
list.add(new int[]{11,15});
//返回值类型和方法参数一样
//话句话说, 本来由list存储各个int[], 现在由int[][]存储各个int[]
//话句话说, 本来由list存储各个int[], 现在由int[][]存储各个int[]
//话句话说, 本来由list存储各个int[], 现在由int[][]存储各个int[]
//int[][]的长度指定为0或者指定为list.size()都可以. 
int[][] arr = list.toArray(new int[0][]);
for(int[] t : arr){
    System.out.println(Arrays.toString(t));
}
/*
打印结果
[1, 2]
[4, 5]
[7, 9]
[11, 15]
*/

可以看到对应的toArray()里面添加对应的参数就可以返回指定的返回值类型，如果不添加对应的类型，就是返回的Object方法

public class MapDemo {
    public static void main(String[] args) {
   
        List<Person> list = new ArrayList<>();
        list.add(new Person(22, "xiaohong"));
        list.add(new Person(33, "xiaohong2"));
        list.add(new Person(44, "xiaohong3"));
       Person[] people = list.toArray(new Person[0]);
        Object[] objects = list.toArray();
        Object[] objects6 = list.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }

    }
}

class Person {
    int age;
    String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}