Java 如何在JPA中使用复数属性进行条件查询？

这是我要从中生成查询的根实体

ArticleType

。我想获取一个集合

articleTypeVarianteOptionCollection

，并为该集合添加一些条件

public class ArticleType extends BaseEntity implements Serializable
{
    private static final long                   serialVersionUID    = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "art_typ_index")
    private Integer                             artTypIndex;
    @Column(name = "art_typ_code", nullable = false)
    private String                              artTypCode;
    @OneToMany(mappedBy = "atvoIndexArticleType", fetch = FetchType.LAZY)
    private Set<ArticleTypeVarianteOption>      articleTypeVarianteOptionCollection;

    public Integer getArtTypIndex()
    {
        return artTypIndex;
    }

    public void setArtTypIndex(Integer artTypIndex)
    {
        this.artTypIndex = artTypIndex;
    }


    public String getArtTypCode()
    {
        return artTypCode;
    }

    public void setArtTypCode(String artTypCode)
    {
        this.artTypCode = artTypCode;
    }


    @XmlTransient
    public Set<ArticleTypeVarianteOption> getArticleTypeVarianteOptionCollection()
    {
        return articleTypeVarianteOptionCollection;
    }

    public void setArticleTypeVarianteOptionCollection(Set<ArticleTypeVarianteOption> articleTypeVarianteOptionCollection)
    {
        this.articleTypeVarianteOptionCollection = articleTypeVarianteOptionCollection;
    }


}

我的问题是：

SELECT 
articleType
FROM ArticleType articleType 
LEFT JOIN articleType.articleTypeVarianteOptionCollection atOption
where atOption.atoIsremoved = 0;

我试过jpa中的where条款：-

CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<T> criteriaQry = criteriaBuilder.createQuery(entityClass);
Root<T> root = criteriaQry.from(entityClass);
criteriaQry.select(root).distinct(true);

for (PluralAttribute<? super T, ?, ?> pa : root.getModel().getPluralAttributes())
{
    System.out.println(pa.getName());
    System.out.println(pa.getCollectionType());
}

CriteriaBuilder-CriteriaBuilder=entityManager.getCriteriaBuilder（）；
CriteriaQuery criteriaQry=criteriaBuilder.createQuery（entityClass）；
根=标准源（entityClass）；
criteriaQry.select（root）.distinct（true）；
for（PluralAttribute pa:root.getModel（）.getPluralAttributes（））
{
System.out.println（pa.getName（））；
System.out.println（pa.getCollectionType（））；
}

现在如何使用这个PluralAttribute添加where子句？

---

提前感谢。

首先，让我们从SQL查询开始：

SELECT 
articleType
FROM ArticleType articleType 
LEFT JOIN articleType.articleTypeVarianteOptionCollection atOption
where atOption.atoIsremoved = 0;

无论何时使用

WHERE

条件中的

LEFT JOIN

表，该JOIN的行为都类似于

内部JOIN

下面是将SQL查询转换为条件的方法：

Integer atoIsremoved = ...;

CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<ArticleType> criteria = criteriaBuilder.createQuery(ArticleType.class);

Root<ArticleType> root = criteria.from(ArticleType.class);
criteria.select(root).distinct(true);

Join<ArticleType, ArticleTypeVarianteOption> joinOptions = root.join(
    "articleTypeVarianteOptionCollection", 
    JoinType.LEFT
);

criteria.where(
    criteriaBuilder.or(
        criteriaBuilder.isNull(
           joinOptions.get("id")
        ), 
        criteriaBuilder.equal(
            joinOptions.get("atoIsremoved"), atoIsremoved
        )
    )
);

TypedQuery<ArticleType> query = entityManager.createQuery(criteria);
List<ArticleType> resultList = query.getResultList();

整数atoIsremoved=。。。；
CriteriaBuilder CriteriaBuilder=entityManager.getCriteriaBuilder（）；
CriteriaQuery条件=criteriaBuilder.createQuery（ArticleType.class）；
Root=criteria.from（ArticleType.class）；
条件.select（root）.distinct（true）；
Join joinOptions=root.Join(
“ArticleTypeVariateOptionCollection”，
左
);
标准。在哪里(
标准构建器(
criteriaBuilder.isNull(
joinOptions.get（“id”）
), 
标准构建器(
获取（“atoIsremoved”），atoIsremoved
)
)
);
TypedQuery查询=entityManager.createQuery（条件）；
List resultList=query.getResultList（）；

要添加

where

子句（条件），我必须使用下面指定的连接作为

joinOptions

为了检索数据，我必须将这些数据作为获取关系来获取

    CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
    CriteriaQuery<ArticleType> criteria = criteriaBuilder.createQuery(ArticleType.class);
    Root<ArticleType> root = criteria.from(ArticleType.class);
    criteria.select(root).distinct(true);

    Join<ArticleType, ArticleTypeVarianteOption> joinOptions = root.join("articleTypeVarianteOptionCollection");

    if (fetchRelations != null)
    {
        for (String fetchReln : fetchRelations)
        {
            FetchParent<ArticleType, ArticleType> fetch = root;

            for (String reln : fetchReln.split("\\."))
            {
                FetchParent<ArticleType, ArticleType> originalFetch = fetch;
                for (String childReln : reln.split(":"))
                {
                    fetch = originalFetch.fetch(childReln, JoinType.LEFT);
                }
                originalFetch = fetch;
            }
        }
    }

    Predicate[] predArray = new Predicate[2];
    predArray[0] = criteriaBuilder.equal(joinOptions.get("atvoIndexConfig"), configId);
    predArray[1] = criteriaBuilder.equal(joinOptions.get("atvoIndexArticleType"), articleTypeId);

    criteria.where(predArray);

    TypedQuery<ArticleType> typedQry = entityManager.createQuery(criteria);
    ArticleType articleTypeResult;

    try
    {
        articleTypeResult = typedQry.getSingleResult();
    }
    catch (NoResultException ex)
    {
        articleTypeResult = null;
    }
    return articleTypeResult;

CriteriaBuilder-CriteriaBuilder=entityManager.getCriteriaBuilder（）；
CriteriaQuery条件=criteriaBuilder.createQuery（ArticleType.class）；
Root=criteria.from（ArticleType.class）；
条件.select（root）.distinct（true）；
Join joinOptions=root.Join（“articleTypeVarianteOptionCollection”）；
if（fetchRelations！=null）
{
for（字符串fetchReln:fetchRelations）
{
FetchParent fetch=root；
for（字符串reln:fetchReln.split（“\\”））
{
FetchParent originalFetch=获取；
对于（字符串childReln:reln.split（“：”））
{
fetch=originalFetch.fetch（childReln，JoinType.LEFT）；
}
originalFetch=fetch；
}
}
}
谓词[]predArray=新谓词[2]；
predArray[0]=criteriaBuilder.equal（joinOptions.get（“atvoIndexConfig”），configId）；
predArray[1]=criteriaBuilder.equal（joinOptions.get（“atvoIndexArticleType”），articleTypeId）；
标准。其中（数组）；
TypedQuery typedQry=entityManager.createQuery（条件）；
ArticleType ArticleType结果；
尝试
{
articleTypeResult=typedQry.getSingleResult（）；
}
捕获（noresultex异常）
{
articleTypeResult=null；
}
返回articleTypeResult；

使用JPQL可以实现您需要的功能。查询与条件解决方案类似，但对我来说更具可读性：

SELECT distinct a FROM ArticleType a 
LEFT JOIN FETCH a.articleTypeViarianteOptionCollection atOption   
WHERE atOption is null OR atOption.atoIsremoved=0

---

您可以使用类似以下内容：

Fetch artTypeFetch = root.fetch("atoIndexArtType", JoinType.LEFT);
artTypeFetch.fetch("articleTypeVarianteOptionCollection", JoinType.LEFT);

---

joinOptions.get（“id”）

条件代表什么？当您有一个左连接时，请检查连接端是否有id，以避免使用第二个条件筛选FROM子句。实际上，我还想获取数据。所以我把答案贴在这里。过来看。谢谢..实际上我正在动态生成此查询。为此，我正在使用条件查询。所以我不能在这里使用JPQL。这正是我四个小时以来一直在寻找的

Fetch artTypeFetch = root.fetch("atoIndexArtType", JoinType.LEFT);
artTypeFetch.fetch("articleTypeVarianteOptionCollection", JoinType.LEFT);