如何用Spring JPA Specification API优化文章标签交集查询性能？

现有文章实体类定义如下：

public class Article {

    @Id
    private Integer id;
    private String title;
    private String content;
    // ...
    // 大量其他文章属性，用于分类和筛选
    // ...
    @ElementCollection
    @CollectionTable(name = "article_tags", joinColumns = @JoinColumn(name = "article_id"))
    @Column(name = "tag")
    private Set<String> tags;
}

当前使用Spring JPA Specification实现的标签查询逻辑：

public static Specification<Article> byTagAnyOf(Set<String> referenceTags) {
    return (root, query, builder) -> {
       if (CollectionUtils.isEmpty(referenceTags)) {
           return builder.conjunction();
       }
        return builder.or(referenceTags.stream()
                .map(tag -> builder.isMember(tag, root.get("tags")))
                .toArray(Predicate[]::new));
    };
}

该实现可正常运行，但会生成包含大量OR子查询的SQL（示例如下），多次查询article_tags表，存在明显性能问题：

Hibernate: 
    select
        article0_.id,
        article0_.title,
        article0_.content
    from
        articles article0_ 
    where
        1=1 
        and 1=1 
        and (
            article0_.author in (
                ? , ? , ?
            )
        ) 
        and (
            ? in (
                select
                    tagart1_.tag 
                from
                    article_tags tagart1_ 
                where
                    article0_.id=tagart1_.article_id
            ) 

            ...
            
            or ? in (
                select
                    tagart6_.tag 
                from
                    article_tags tagart6_ 
                where
                    article0_.id=tagart6_.article_id
            )
        ) 
        and 1=1 
        and 1=1 
        and 1=1 
        and 1=1 
        and 1=1 
        and 1=1 
        and 1=1

需求：通过Spring JPA Specification API，采用JOIN方式实现标签交集检查，优化查询性能。

可以通过直接关联article_tags表的方式，将多标签筛选逻辑合并到主查询中，避免生成大量OR子查询。具体实现如下：

import org.springframework.data.jpa.domain.Specification;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.Predicate;
import java.util.Set;

public static Specification<Article> byTagAnyOf(Set<String> referenceTags) {
    return (root, query, builder) -> {
        if (referenceTags == null || referenceTags.isEmpty()) {
            return builder.conjunction();
        }
        // JOIN关联article_tags表
        Join<Object, Object> tagsJoin = root.join("tags");
        // 筛选标签在目标集合中的记录
        Predicate tagPredicate = tagsJoin.in(referenceTags);
        // JOIN会导致Article记录重复，开启去重
        query.distinct(true);
        return tagPredicate;
    };
}

方案说明 #

1. 表关联优化：通过root.join("tags")直接关联article_tags表，替代原有的子查询逻辑，将多表关联合并到主查询中，减少数据库执行次数。
2. IN条件筛选：用tagsJoin.in(referenceTags)替代多个OR子查询，一次匹配所有目标标签，简化查询逻辑。
3. 去重处理：由于单篇文章对应多个标签，JOIN后会生成重复的Article记录，调用query.distinct(true)可确保结果唯一。

优化后生成的SQL示例 #

优化后的SQL仅需一次JOIN和IN条件，避免了大量子查询：

Hibernate: 
    select distinct
        article0_.id,
        article0_.title,
        article0_.content
    from
        articles article0_ 
    inner join
        article_tags tags1_ 
            on article0_.id=tags1_.article_id 
    where
        1=1 
        and 1=1 
        and (
            article0_.author in (
                ? , ? , ?
            )
        ) 
        and tags1_.tag in (
            ? , ? , ? , ? , ? , ?
        ) 
        and 1=1 
        and 1=1 
        and 1=1 
        and 1=1 
        and 1=1 
        and 1=1 
        and 1=1

注意事项 #

• 若查询包含分组、排序等复杂逻辑，需确认distinct不会影响最终结果正确性。
• 建议为article_tags表的article_id和tag字段建立联合索引，进一步提升JOIN和筛选的性能。

内容的提问来源于stack exchange，提问作者meridbt