如何用Spring JPA Criteria API实现关联Event的用户查询

我有三个实体类：

User(id, first_name 等字段)
Message(id, name, user_id) - 用户发送的消息
Event(id, event_name, message_id) - 消息相关事件，比如点击、打开等

我使用Spring JPA Criteria API实现用户对象的动态过滤查询，前端可以选择任意实体的参数（比如first_name）、操作符（比如EQUALS）和值（比如"John"）来指定查询条件，最终返回符合条件的用户。

已经定义了：

Root<User> root = ....

我已经为单个实体实现了ExpressionInterpreter及其equals方法：

public static <T> Predicate equals(Root<T> root,
                                   CriteriaBuilder criteriaBuilder,
                                   CriteriaQuery criteriaQuery,
                                   IExpression expression) {

    if(expression.getKey().getType().equals(USER)) {
        return criteriaQuery
                .select(root)
                .where(
                        criteriaBuilder.equal(
                                root.get(expression.getKey()),
                                expression.getValue()
                        )
                )
                .getRestriction();
    }
    // 其他实体的处理逻辑...
}

现在我需要根据Event实体的特定event_name查询用户，返回存在或不存在对应事件消息的用户。期望生成的SQL如下：

select distinct u
       from user u 
       join message m on m.user_id = u.id
       join event e on e.message_id = m.id
       where (
            exists (
                select 1
                from event e
                where e.event_name = 'event_name_example' and e.message_id = m.id
            )
       )

或许有更简洁的实现方式，请问如何用Spring JPA Criteria API构建这个Predicate？

方式一：使用Exists子查询（匹配你期望的SQL结构） #

通过CriteriaBuilder的exists方法构建子查询，完全匹配目标SQL的逻辑：

public Predicate hasEventWithName(Root<User> root, CriteriaBuilder cb, String targetEventName) {
    // 1. 创建子查询，查询符合条件的Event
    Subquery<Long> subquery = cb.createQuery(Long.class).subquery(Long.class);
    Root<Event> eventSubRoot = subquery.from(Event.class);
    
    // 2. 关联主查询的Message和子查询的Event
    Join<User, Message> messageJoin = root.join("messages"); // 假设User实体有messages集合属性
    subquery.select(cb.literal(1L))
            .where(
                cb.equal(eventSubRoot.get("eventName"), targetEventName),
                cb.equal(eventSubRoot.get("message").get("id"), messageJoin.get("id"))
            );
    
    // 3. 构建exists条件
    return cb.exists(subquery);
}

方式二：更简洁的Join+Distinct方式 #

若不需要严格匹配exists子查询结构，可直接通过多表关联实现，代码更简洁：

public Predicate hasEventWithNameSimple(Root<User> root, CriteriaBuilder cb, String targetEventName) {
    // 链式关联User -> Message -> Event
    Join<User, Message> messageJoin = root.join("messages");
    Join<Message, Event> eventJoin = messageJoin.join("events");
    
    // 添加event_name匹配条件
    return cb.equal(eventJoin.get("eventName"), targetEventName);
}

注意：使用该方式时，主查询必须调用query.distinct(true)，避免多表关联导致返回重复的User对象。

处理“不存在”该事件的情况 #

如果要查询没有指定事件的用户，只需对条件取反：

// 方式一的取反写法
return cb.not(cb.exists(subquery));

// 方式二的取反写法
return cb.not(eventNameMatch);

整合到现有ExpressionInterpreter中 #

在现有逻辑中新增Event条件的处理分支，根据操作符判断是“存在”还是“不存在”：

public static <T> Predicate handleEventCondition(Root<T> root,
                                   CriteriaBuilder criteriaBuilder,
                                   CriteriaQuery criteriaQuery,
                                   IExpression expression) {
    if(expression.getKey().getType().equals(EVENT) && "event_name".equals(expression.getKey().getName())) {
        String targetEventName = (String) expression.getValue();
        if(expression.getOperator().equals(EXISTS)) {
            return hasEventWithName((Root<User>) root, criteriaBuilder, targetEventName);
        } else if(expression.getOperator().equals(NOT_EXISTS)) {
            return criteriaBuilder.not(hasEventWithName((Root<User>) root, criteriaBuilder, targetEventName));
        }
    }
    // 其他实体的处理逻辑...
    return null;
}

关键注意事项 #

1. 确保实体类配置了正确的关联关系：
   • User类需包含@OneToMany(mappedBy = "user") private List<Message> messages;
   • Message类需包含@OneToMany(mappedBy = "message") private List<Event> events;
   • 代码中使用的关联字段名称（如messages、events、eventName）需和实体类中的定义一致

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