Java 如何使用一组可变字符串执行like查询？

我正在尝试使用变量字符串集执行一个“类查询”，以便在单个查询中检索，包含一组单词的所有文本，即：

 public long countByTextLike(Set<String> strings) {
        CriteriaBuilder builder = manager.getCriteriaBuilder();
        CriteriaQuery<Long> query = builder.createQuery(Long.class);
        Root<Example> root = query.from(Example.class);


        query.select(builder.count(root.get("id"))).where(
                builder.and(
                        builder.equal(root.get("lang"), "EN")
                )
        );

        //this does not work
        for (String word : strings) {
            query.where(builder.or(builder.like(root.get("text"), word)));
        }

        return manager.createQuery(query).getSingleResult();

    }

public long countByTextLike（设置字符串）{
CriteriaBuilder=manager.getCriteriaBuilder（）；
CriteriaQuery=builder.createQuery（Long.class）；
Root=query.from（Example.class）；
query.select（builder.count（root.get（“id”））。其中(
建筑商和(
builder.equal（root.get（“lang”），“EN”）
)
);
//这行不通
for（字符串字：字符串）{
query.where（builder.or（builder.like（root.get（“text”），word））；
}
return manager.createQuery（query.getSingleResult（）；
}

不幸的是，这不起作用，因为where在每个循环中都被覆盖。只使用循环的最后一个字，并且覆盖“and”restications。 如何使用可变数量的字符串执行类似于的查询？不可能吗

---

我使用的是spring框架，但我认为这个问题可以扩展到hibernate

您可以使用谓词，然后只使用一个where子句添加它们

public long countByTextLike(Set<String> strings) {
    CriteriaBuilder builder = currentSession().getCriteriaBuilder();
    CriteriaQuery<Long> query = builder.createQuery(Long.class);
    Root<Example> root = query.from(Example.class);

    Predicate[] predicates = new Predicate[strings.size()];

    query.select(builder.count(root.get("id")));

    Predicate langPredicate = builder.equal(root.get("lang"), "EN");

    int cont = 0;
    for (String word : strings) {
        Predicate pred = builder.like(root.get("text"), "%" + word + "%");
        predicates[cont++] = pred;
    }

    Predicate orPredicate = builder.or(predicates);

    Predicate finalPredicate = builder.and(orPredicate, langPredicate);

    return manager.createQuery(query).where(finalPredicate).getSingleResult();

}

public long countByTextLike（设置字符串）{
CriteriaBuilder=currentSession（）.getCriteriaBuilder（）；
CriteriaQuery=builder.createQuery（Long.class）；
Root=query.from（Example.class）；
谓词[]谓词=新谓词[strings.size（）]；
query.select（builder.count（root.get（“id”））；
谓词langPredicate=builder.equal（root.get（“lang”），“EN”）；
int cont=0；
for（字符串字：字符串）{
谓词pred=builder.like（root.get（“text”），“%”+word+“%”；
谓词[cont++]=pred；
}
谓词orPredicate=builder.or（谓词）；
谓词finalPredicate=builder.and（或Predicate，langPredicate）；
return manager.createQuery（query）.where（finalPredicate.getSingleResult（）；
}

您可以使用谓词，然后只使用一个where子句添加所有谓词

public long countByTextLike(Set<String> strings) {
    CriteriaBuilder builder = currentSession().getCriteriaBuilder();
    CriteriaQuery<Long> query = builder.createQuery(Long.class);
    Root<Example> root = query.from(Example.class);

    Predicate[] predicates = new Predicate[strings.size()];

    query.select(builder.count(root.get("id")));

    Predicate langPredicate = builder.equal(root.get("lang"), "EN");

    int cont = 0;
    for (String word : strings) {
        Predicate pred = builder.like(root.get("text"), "%" + word + "%");
        predicates[cont++] = pred;
    }

    Predicate orPredicate = builder.or(predicates);

    Predicate finalPredicate = builder.and(orPredicate, langPredicate);

    return manager.createQuery(query).where(finalPredicate).getSingleResult();

}

public long countByTextLike（设置字符串）{
CriteriaBuilder=currentSession（）.getCriteriaBuilder（）；
CriteriaQuery=builder.createQuery（Long.class）；
Root=query.from（Example.class）；
谓词[]谓词=新谓词[strings.size（）]；
query.select（builder.count（root.get（“id”））；
谓词langPredicate=builder.equal（root.get（“lang”），“EN”）；
int cont=0；
for（字符串字：字符串）{
谓词pred=builder.like（root.get（“text”），“%”+word+“%”；
谓词[cont++]=pred；
}
谓词orPredicate=builder.or（谓词）；
谓词finalPredicate=builder.and（或Predicate，langPredicate）；
return manager.createQuery（query）.where（finalPredicate.getSingleResult（）；
}