SpringDataJPA（12）Specifications动态查询：概述

最新推荐文章于 2023-09-01 17:27:28 发布

?abc!

最新推荐文章于 2023-09-01 17:27:28 发布

阅读量852

点赞数 1

分类专栏： # JPA 文章标签： jpa

本文链接：https://blog.csdn.net/yyuggjggg/article/details/121729807

版权

JPA 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

1. 概述

当给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。
相比JPQL,其优势是类型安全,更加的面向对象。

在其源码里面，定义了许多方法，与JpaRepository接口里面的方法差不多

JpaSpecificationExecutor里面的查询方法的参数是Specification< T> spec；由此可以动态去拼接不同的查询条件以调用方法的显示去完成需求

2. JpaSpecificationExecutor方法介绍

T findOne(Specification<T> spec);  //查询单个对象

List<T> findAll(Specification<T> spec);  //查询列表

//查询全部，分页
//pageable：分页参数
//返回值：分页pageBean（page：是springdatajpa提供的）
Page<T> findAll(Specification<T> spec, Pageable pageable);

//查询列表
//Sort：排序参数
List<T> findAll(Specification<T> spec, Sort sort);

long count(Specification<T> spec);//统计查询

Specification ：查询条件，这是一个接口

需要自定义我们自己的Specification实现类
实现方法：
- Predicate toPredicate(Root root, CriteriaQuery<?> query, CriteriaBuilder cb); //用于封装查询条件
- root：查询的根对象（查询的任何属性都可以从根对象中获取）
- CriteriaQuery：顶层查询对象，自定义查询方式（作为一个了解，一般不用）
- CriteriaBuilder：查询的构造器，封装了很多的查询条件

3. 测试动态查询

3.1 测试环境搭建

该项目的测试环境与之前（SpringDataJPA（6）SpringDataJPA概述与使用SpringDataJPA进行CRUD操作）的一样，在这里便不再继续叙述了
在这里的dao层的内容如下：

package cn.yy.dao;

import cn.yy.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;

import java.util.List;

/**
 * @author Marston
 * @date 2021/12/5
 *
 *      符合SpringDataJpa的dao层接口规范
 *              JpaRepository<操作的实体类类型，实体类中主键属性的类型>
 *                  封装了基本CRUD操作”
 *              JpaSpecificationExecutor<操作的实体类类型>
 *                  封装了复杂查询(分页)
 */
public interface SpecCustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    
}

3.2 查询单个对象

测试类中的代码：

package cn.yy.test;

import cn.yy.dao.CustomerDao;
import cn.yy.dao.SpecCustomerDao;
import cn.yy.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.criteria.*;
import java.util.Arrays;
import java.util.List;

/**
 * @author Marston
 * @date 2021/12/5
 */
@RunWith(SpringJUnit4ClassRunner.class)//声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class SpecTest {
    @Autowired
    private SpecCustomerDao specCustomerDao;

    /**
     * 根据条件查询单个对象：
     *      根据客户名查询：
     *          查询条件：
     *              1.查询方式
     *                  cb对象
     *              2.比较的属性名称
     *                  root对象
     */
    @Test
    public void testSpec(){
        /*匿名内部类，自定义查询条件
            1.实现Specification接口(提供泛型:查询的对象类型)
            2.实现toPredicate方法(构造查询条件)
            3.需要借助方法参数中的两个参数(
                    root:获取需要查询的对象属性
                    CriteriaBuilder:构造查询条件的，内部封装了很多的查询条件(模糊匹配，精准匹配。)
               )
         */
        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //1.获取比较的属性：参数是属性名
                Path<Object> custName = root.get("custName");
                //2.构造查询条件：select * from cst_customer where cust_name = '更新后的结果'
                /*
                        第一个参数:需要比较的属性(path对象)
                        第二个参数:当前需要比较的取值
                 */
                Predicate predicate = criteriaBuilder.equal(custName, "更新后的结果");//进行精准的匹配（比较的属性，比较的是属性的取值）
                return predicate;
            }
        };
        Customer one = specCustomerDao.findOne(spec);
        System.out.println(one);
    }

}

运行结果：

3.3 完成多条件拼接

测试类中的代码，该测试是在3.2中的测试类中运行的：

/**
     * 多条件查询：
     *      根据客户名和客户所属行业进行查询
     */
    @Test
    public void testSpec1(){
        /*
        root：获取属性
            客户名
            所属行业
         cb：构造查询
            1.构造客户名的精准匹配查询
            2.构造所属行业的精准匹配查询
            3.将以上两个查询联系起来
         */
        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Path<Object> custName = root.get("custName");//客户名
                Path<Object> custIndustry = root.get("custIndustry");//所属行业
                //构造查询
                //1.构造客户名的精准匹配查询
                Predicate p1 = criteriaBuilder.equal(custName, "延迟");
                //2.构造所属行业的精准匹配查询
                Predicate p2 = criteriaBuilder.equal(custIndustry, "学习");
                //3.将以上两个查询联系起来(组合在一起):and、or
                Predicate and = criteriaBuilder.and(p1, p2);//and():以与的形式拼接多个查询条件;cb.or():以或的形式拼接多个查询条件

                return and;
            }
        };
        //是使用findOne还是findAll是要根据数据库中数据的内容而定
        Customer one = specCustomerDao.findOne(spec);
        System.out.println(one);
    }

运行结果：

3.4 模糊匹配查询列表

测试类中的代码，该测试是在3.2中的测试类中运行的：

/**
     * 根据客户名称的模糊匹配
     *      equal():直接的到path对象(属性)，然后进行比较即可
     *      gt、lt、ge、le、like：这些方法不能直接去比较，
     *                          需要先得到path对象，根据path指定比较的参数类型，再去进行比较
     *                          指定参数类型：path.as(类型的字节码对象)
     */
    @Test
    public void testSpec3(){
        //构造查询条件
        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //查询属性：客户名
                Path<Object> custName = root.get("custName");
                //查询方式：模糊查询
                Predicate predicate = criteriaBuilder.like(custName.as(String.class), "延%");
                return predicate;
            }
        };
        List<Customer> all = specCustomerDao.findAll(spec);
        for (Customer customer :all){
            System.out.println(customer);
        }
    }

运行结果：

3.5 排序

测试类中的代码，该测试是在3.2中的测试类中运行的：

/**
     * 根据客户名称的模糊匹配
     *      equal():直接的到path对象(属性)，然后进行比较即可
     *      gt、lt、ge、le、like：这些方法不能直接去比较，
     *                          需要先得到path对象，根据path指定比较的参数类型，再去进行比较
     *                          指定参数类型：path.as(类型的字节码对象)
     */
    @Test
    public void testSpec3(){
        //构造查询条件
        Specification<Customer> spec = new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //查询属性：客户名
                Path<Object> custName = root.get("custName");
                //查询方式：模糊查询
                Predicate predicate = criteriaBuilder.like(custName.as(String.class), "延%");
                return predicate;
            }
        };
        /*创建排序对象，需要调用构造方法实例化Sort对象
                第一个参数:排序的顺序(倒序，正序)
                    Sort.Direction.DESC:倒序
                    Sort.Direction.ASC：升序
                第二个参数:排序的属性名称
         */
        Sort sort = new Sort(Sort.Direction.DESC,"custId");
        List<Customer> all = specCustomerDao.findAll(spec,sort);
        for (Customer customer :all){
            System.out.println(customer);
        }
    }

运行结果：

3.6 分页

测试类中的代码，该测试是在3.2中的测试类中运行的：

/**
     * 分页查询：
     *      findAll(Specification, Pageable):带有条件的分页
     *          Specification:查询条件
     *          Pageable:分页参数
     *              分页参数: 查询的页码，每页查询的条数
     *      findAll(Pageable):没有条件的分页
     *
     *      返回: Page对象： (这个对象是springDataJpa为我们封装好的pageBean对象，包括：数据列表、共条数)
     */
    @Test
    public void testSpec4(){
        Specification<Customer> spec = null;
        /*
        创建PageRequest的过程中，需要调用他的构造方法传入两个参数
                第一个参数:当前查询的页数(从0开始)
                第二个参数:每页查询的数量
         */
        Pageable pageable = new PageRequest(0,2);
        Page<Customer> all = specCustomerDao.findAll(spec, pageable);
        System.out.println("数据列表集合："+all.getContent());
        System.out.println("得到总条数："+all.getTotalElements());
        System.out.println("得到总页数："+all.getTotalPages());
    }

运行结果：

?abc!

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringDataJPA（12）Specifications动态查询：概述

1. 概述当给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。相比JPQL,其优势是类型安全,更加的面向对象。在其源码里面，定义了许多方法，与JpaRepository接口里面的方法差不多JpaSpecificationExecutor里面的查询方法的参数是Specification< T> spec；由此可以动态去拼接不同的查询条件以调用方法的显示去完成需求2. JpaS
复制链接

扫一扫