SpringBoot JPA动态查询与Specification详解：从基础到高级实战-CSDN博客

本文链接：https://blog.csdn.net/qq_27756951/article/details/147963661

一、JPA动态查询概述

1.1 什么是动态查询

动态查询是指根据运行时条件构建的查询，与静态查询（如@Query注解或命名查询）相对。在业务系统中，80%的查询需求都是动态的，例如电商系统中的商品筛选、订单查询等。

1.2 为什么需要动态查询

静态查询缺点	动态查询优势
条件固定不变	条件可灵活组合
需要预定义所有可能	运行时决定查询条件
代码冗余	代码复用性高
维护困难	易于维护扩展

1.3 JPA动态查询的几种方式

方法名派生查询：简单但条件组合有限
@Query注解：灵活但仍是静态
Criteria API：类型安全但复杂
QueryDSL：强大但需要额外依赖
Specification：JPA提供的优雅解决方案

二、基础查询方式

2.1 方法名派生查询

public interface UserRepository extends JpaRepository<User, Long> {
    // 根据姓名查询
    List<User> findByName(String name);
    
    // 根据年龄范围查询
    List<User> findByAgeBetween(int min, int max);
    
    // 多条件组合
    List<User> findByNameAndAgeGreaterThan(String name, int age);
}

优点：简单直观
缺点：条件组合有限，方法名可能变得很长

2.2 @Query注解

@Query("SELECT u FROM User u WHERE u.name = :name AND u.age > :age")
List<User> findUsersByNameAndAge(@Param("name") String name, 
                               @Param("age") int age);

优点：灵活性较高
缺点：仍是静态SQL，条件变化需要写多个方法

三、Specification核心概念

3.1 什么是Specification

Specification是JPA提供的动态查询接口，基于Criteria API封装，使用谓词(Predicate)组合查询条件。

public interface Specification<T> {
    Predicate toPredicate(Root<T> root, 
                         CriteriaQuery<?> query, 
                         CriteriaBuilder cb);
}

3.2 核心组件解析

组件	作用	类比SQL
`Root<T>`	查询的根对象（实体）	FROM 子句
`CriteriaQuery<?>`	构建查询的容器	SELECT/FROM/WHERE 等
`CriteriaBuilder`	构建查询条件的工厂	各种运算符(=, >, like等)
`Predicate`	具体的查询条件	WHERE 后的条件表达式

3.3 基础使用步骤

继承JpaSpecificationExecutor接口

public interface UserRepository extends JpaRepository<User, Long>, 
                                      JpaSpecificationExecutor<User> {}

创建Specification实现

Specification<User> spec = new Specification<User>() {
    @Override
    public Predicate toPredicate(Root<User> root, 
                                 CriteriaQuery<?> query, 
                                 CriteriaBuilder cb) {
        return cb.equal(root.get("name"), "张三");
    }
};

执行查询

List<User> users = userRepository.findAll(spec);

3.4 常用CriteriaBuilder方法

方法	说明	对应SQL
`equal()`	等于	name = ‘张三’
`notEqual()`	不等于	name != ‘张三’
`gt()`, `ge()`	大于, 大于等于	age > 18
`lt()`, `le()`	小于, 小于等于	age < 30
`like()`	模糊匹配	name like ‘%张%’
`between()`	范围	age between 20 and 30
`isNull()`, `isNotNull()`	空值检查	name is null
`and()`, `or()`, `not()`	逻辑运算	and, or, not

3.5 日常案例：用户筛选

// 构建动态查询条件
Specification<User> spec = (root, query, cb) -> {
    List<Predicate> predicates = new ArrayList<>();
    
    // 如果传入了姓名，添加姓名条件
    if (StringUtils.isNotBlank(name)) {
        predicates.add(cb.like(root.get("name"), "%" + name + "%"));
    }
    
    // 如果传入了最小年龄，添加年龄条件
    if (minAge != null) {
        predicates.add(cb.ge(root.get("age"), minAge));
    }
    
    // 如果传入了最大年龄，添加年龄条件
    if (maxAge != null) {
        predicates.add(cb.le(root.get("age"), maxAge));
    }
    
    // 组合所有条件
    return cb.and(predicates.toArray(new Predicate[0]));
};

// 执行查询
List<User> users = userRepository.findAll(spec);

四、Specification高级用法

4.1 组合多个Specification

JPA提供了Specification.where()、and()、or()、not()等组合方法：

// 定义单个条件的Specification
Specification<User> hasName = (root, query, cb) -> 
    cb.equal(root.get("name"), "张三");
    
Specification<User> isAdult = (root, query, cb) -> 
    cb.ge(root.get("age"), 18);

// 组合条件：姓名是张三的成年人
Specification<User> spec = Specification.where(hasName).and(isAdult);

4.2 动态排序

// 创建排序条件
Sort sort = Sort.by(Sort.Direction.DESC, "createTime")
    .and(Sort.by(Sort.Direction.ASC, "age"));

// 带排序的查询
List<User> users = userRepository.findAll(spec, sort);

4.3 分页查询

// 创建分页请求（第2页，每页10条，按年龄降序）
Pageable pageable = PageRequest.of(1, 10, Sort.by("age").descending());

// 执行分页查询
Page<User> userPage = userRepository.findAll(spec, pageable);

// 获取结果
List<User> users = userPage.getContent();
long total = userPage.getTotalElements();
int totalPages = userPage.getTotalPages();

4.4 关联查询

Specification<User> spec = (root, query, cb) -> {
    // 关联到部门表
    Join<User, Department> deptJoin = root.join("department", JoinType.LEFT);
    
    // 部门名称条件
    Predicate deptPredicate = cb.equal(deptJoin.get("name"), "技术部");
    
    // 用户年龄条件
    Predicate agePredicate = cb.ge(root.get("age"), 25);
    
    return cb.and(deptPredicate, agePredicate);
};

4.5 子查询

Specification<User> spec = (root, query, cb) -> {
    // 创建子查询
    Subquery<Long> subquery = query.subquery(Long.class);
    Root<Department> deptRoot = subquery.from(Department.class);
    subquery.select(deptRoot.get("id"))
            .where(cb.equal(deptRoot.get("name"), "技术部"));
    
    // 主查询关联子查询
    return cb.in(root.get("department").get("id")).value(subquery);
};

4.6 动态选择字段

List<Tuple> results = userRepository.findAll(
    (root, query, cb) -> {
        // 只选择name和age字段
        query.multiselect(root.get("name"), root.get("age"));
        return cb.gt(root.get("age"), 20);
    },
    Tuple.class
);

// 处理结果
results.forEach(tuple -> {
    String name = tuple.get(0, String.class);
    Integer age = tuple.get(1, Integer.class);
});

五、动态查询性能优化

5.1 N+1问题解决方案

问题描述：查询主实体后，关联实体延迟加载导致的多次查询

解决方案：

使用JOIN FETCH

Specification<User> spec = (root, query, cb) -> {
    // 立即加载department关联
    root.fetch("department", JoinType.LEFT);
    return cb.isNotNull(root.get("name"));
};

使用@EntityGraph

@EntityGraph(attributePaths = {"department"})
List<User> findAll(Specification<User> spec);

5.2 缓存常用查询

@Cacheable("users")
List<User> findAll(Specification<User> spec);

5.3 批量处理优化

// 使用流式处理大数据集
try (Stream<User> userStream = userRepository.findAll(spec).stream()) {
    userStream.forEach(user -> {
        // 处理每个用户
    });
}

六、综合实战案例

6.1 电商商品动态筛选

需求：根据多种条件动态筛选商品

public static Specification<Product> buildProductSpec(
    String keyword, 
    BigDecimal minPrice, 
    BigDecimal maxPrice, 
    List<Long> categoryIds,
    ProductStatus status) {
    
    return (root, query, cb) -> {
        List<Predicate> predicates = new ArrayList<>();
        
        // 关键词搜索（名称或描述）
        if (StringUtils.isNotBlank(keyword)) {
            Predicate namePred = cb.like(root.get("name"), "%" + keyword + "%");
            Predicate descPred = cb.like(root.get("description"), "%" + keyword + "%");
            predicates.add(cb.or(namePred, descPred));
        }
        
        // 价格区间
        if (minPrice != null) {
            predicates.add(cb.ge(root.get("price"), minPrice));
        }
        if (maxPrice != null) {
            predicates.add(cb.le(root.get("price"), maxPrice));
        }
        
        // 分类筛选
        if (categoryIds != null && !categoryIds.isEmpty()) {
            predicates.add(root.get("category").get("id").in(categoryIds));
        }
        
        // 状态筛选
        if (status != null) {
            predicates.add(cb.equal(root.get("status"), status));
        }
        
        // 默认按上架时间倒序
        query.orderBy(cb.desc(root.get("createTime")));
        
        return cb.and(predicates.toArray(new Predicate[0]));
    };
}

6.2 使用示例

// 构建查询条件：价格100-500元，手机分类，上架状态的商品
Specification<Product> spec = ProductSpecifications.buildProductSpec(
    null, 
    new BigDecimal("100"), 
    new BigDecimal("500"), 
    Arrays.asList(1L, 2L), // 手机分类ID
    ProductStatus.ON_SALE
);

// 执行分页查询
Page<Product> page = productRepository.findAll(
    spec, 
    PageRequest.of(0, 10, Sort.by("sales").descending())
);

七、总结与最佳实践

7.1 Specification优缺点对比

优点	缺点
类型安全，编译时检查	学习曲线较陡
代码可读性好	复杂查询代码可能冗长
高度灵活的动态查询	性能优化需要额外注意
良好的代码复用性
与Spring Data JPA完美集成

7.2 最佳实践

封装常用条件：将重复使用的条件封装为静态方法

public class UserSpecs {
    public static Specification<User> hasName(String name) {
        return (root, query, cb) -> cb.equal(root.get("name"), name);
    }
    
    public static Specification<User> ageBetween(int min, int max) {
        return (root, query, cb) -> cb.between(root.get("age"), min, max);
    }
}