Java 标准JPA 2和3个表

我正在尝试创建一个条件，从3个表（关联、更新和详细信息）中检索一些对象。详细信息引用关联和更新，更新引用详细信息列表。我的目标是检索一个更新列表，该列表在给定关联id的情况下，在指定字段中至少有一个带有null值的细节。在JPQL中，这很容易做到，但客户说这必须用标准编码

我的JPQL是：

public List<Update> getUpdates(long associateId) {
    TypedQuery<Update> query = em.createQuery("select distinct u from Update u, Detail dt, Associate a "
        + "where dt.update = u and dt.associate = a and a.associateId = :id and "
        + "dt.ack_date is null", Update.class);
    query.setParameter("id", associateId);
    return query.getResultList();
}

public List getUpdates（长关联ID）{
TypedQuery query=em.createQuery（“从更新u、细节dt、关联a中选择不同的u”
+“其中dt.update=u，dt.associate=a，a.associateId=：id和”
+“dt.ack_日期为空”，Update.class）；
setParameter（“id”，associateId）；
返回query.getResultList（）；
}

我尝试了以下操作，但它只是返回了数据库中的所有更新：

public List<Update> getUpdates(long associateId) {
    CriteriaBuilder builder = em.getCriteriaBuilder();
    CriteriaQuery<Update> query = builder.createQuery(Update.class);

    Root<Update> fromUpdates = query.from(Update.class);
    Root<Associate> fromAssociate = query.from(Associate.class);
    Root<Detail> fromDetail = query.from(Detail.class);

    Join<Detail, Associate> associateJoin = fromDetail.join("associate");
    Join<Detail, Update> updateJoin = fromDetail.join("update");

    TypedQuery<Update> typedQuery = em.createQuery(query

            .select(fromUpdates)
            .where(builder.and(
                    builder.equal(fromAssociate.get("associateId"), associateId),
                    builder.equal(fromDetail.get("associate"), associateJoin),
                    builder.equal(fromDetail.get("update"), updateJoin),
                    builder.isNull(fromDetail.get("ack_date"))
            ))

            .orderBy(builder.asc(fromUpdates.get("updateId")))
            .distinct(true)
    );

    return typedQuery.getResultList();
}

public List getUpdates（长关联ID）{
CriteriaBuilder=em.getCriteriaBuilder（）；
CriteriaQuery=builder.createQuery（Update.class）；
Root-fromUpdates=query.from（Update.class）；
Root-fromsociate=query.from（Associate.class）；
Root-fromdail=query.from（Detail.class）；
Join associateJoin=fromDetail.Join（“关联”）；
Join updateJoin=fromDetail.Join（“更新”）；
TypedQuery TypedQuery=em.createQuery（查询
.选择（从更新）
.在哪里（建筑商）和(
builder.equal（来自associate.get（“associateId”）、associateId），
同等建筑商（fromDetail.get（“关联”），associateJoin），
builder.equal（fromDetail.get（“更新”）、updateJoin），
builder.isNull（fromDetail.get（“确认日期”））
))
.orderBy（builder.asc（fromUpdates.get（“updateId”））
.distinct（正确）
);
返回typedQuery.getResultList（）；
}

---

有人能帮我吗？我搜索过，但找不到任何包含3个实体的示例。

每个连接都将从左侧类型参数转换为右侧类型参数。因此，我的代码的

细节

连接（第二行）从

fromUpdates

开始，这是一个

路径

，并且创建了一些在幕后的东西，也是一个

路径

。由此，您可以构建其他联接。尝试以下操作（未测试代码）：

Root-fromUpdates=query.from（Update.class）；
Join details=fromUpdates.Join（“详细信息”）；
加入合伙人=详细信息。加入（“合伙人”）；
列表条件=新建ArrayList（）；
添加（builder.equal（associate.get（“associateId”），associateId））；
添加（builder.isNull（details.get（“确认日期”））；
TypedQuery TypedQuery=em.createQuery（查询
.选择（从更新）
.where（conditions.toArray（新谓词[]{}））
.orderBy（builder.asc（fromUpdates.get（“updateId”））
.distinct（正确）
);

针对三个涉及的表格

CriteriaBuilder=EntityManager.getCriteriaBuilder（）； CriteriaQuery query1=builder.createQuery（BasicMemberInfo.class）

---

}

使用三个以上的表格检查此测试。还可以使用静态元模型，而不是使用直接属性名

    @Test
@Rollback(false)
@Transactional
public void   
fetch() {
    CriteriaBuilder cb = 
entityManager.getCriteriaBuilder();
    CriteriaQuery<Instructor> cq = 
cb.createQuery(Instructor.class);
    Root<Instructor> root = 
cq.from(Instructor.class);
    root.join(Instructor_.idProof);
    root.join(Instructor_.vehicles);
    Join<Instructor, Student> insStuJoin = 
root.join(Instructor_.students);
    insStuJoin.join(Student_.instructors);
    Join<Student, Vehicle> stuVehcileJoin.   
= insStuJoin.join(Student_.vehicles);
    Join<Vehicle, Document> 
vehicleDocumentJoin = 
stuVehcileJoin.join(Vehicle_.documents);

DataPrinters.
listDataPrinter.accept.   
(queryExecutor.fetchListForCriteriaQuery
      (cq.select(root).where
(cb.greaterThan(root.get(Instructor_.id), 2),                        
           cb.in(vehicleDocumentJoin.get
                          (Document_.name)).value("1")
.value("2").value("3")));
}

@测试
@回滚（false）
@交易的
公共空间
fetch（）{
标准生成器cb=
getCriteriaBuilder（）；
标准查询cq=
cb.createQuery（讲师类）；
根根=
cq.from（讲师班）；
root.join（讲师\ idProof）；
root.join（教练车）；
Join instujoin=
root.join（讲师/学生）；
加入（学生导师）；
加入stuVehcileJoin。
=insStuJoin.join（学生车辆）；
参加
vehicleDocumentJoin=
stuVehcileJoin.join（车辆文档）；
数据打印机。
listDataPrinter.accept。
（queryExecutor.fetchListForCriteriaQuery
（cq.选择（根）。其中
（cb.greaterThan（root.get（讲师id））2），
cb.in（车辆文档join.get
（文件名称））.value（“1”）
.价值（“2”）。价值（“3”）；
}

工作起来很有魅力！这些条件连接让我发疯，但这帮了我很大的忙！谢谢你perissf:）是使用多个条件，比如sql语句，其中x=y，a=b，c=d。。。。或者我必须使用“and（Predicate）”方法来建立它吗？这就像一个带有Where子句的SQL语句。

conditions.add（builder.equal（table3.get（“Table1”）.get（“memberId”）、Table1.get（“memberId”）表示Table3类有成员变量
Table1
？如果它有@OneToMany关系呢。还有一个列表，我们如何做到这一点？
    Root<Table1> table1 = query1.from(Table1.class); 
    Root<Table2> table2 = query1.from(Table2.class);
    Root<Table3> table3 = query1.from(Table3.class);

   List<Predicate> conditions = new ArrayList();
    conditions.add(builder.equal(table3.get("Table1").get("memberId"), table1.get("memberId")));
    conditions.add(builder.equal(table2.get("tableid").get("memberId"), table1.get("memberId")));
    conditions.add(builder.equal(table2.get("indicator"), 'Y'));
    conditions.add(builder.equal(table3.get("StatusCd"), "YES"));

    TypedQuery<BasicCustInfo> typedQuery = theEntityManager.createQuery(
            query1.multiselect(table1.get("memberId"), table2.get("AcctId"))
            .where(conditions.toArray(new Predicate[] {}))
    );

    List<BasicMemberInfo> custList = typedQuery.getResultList();

String memberId;
String AcctId;

public BasicCustInfo() {
    // TODO Auto-generated constructor stub
}

public BasicMemberInfo( BigDecimal memberId,String AcctId ) {
    this.memberId = memberId;
    this.AcctId = AcctId;
}

public BigDecimal getmemberId() {
    return memberId;
}
public void setmemberId(BigDecimal memberId) {
    memberId = memberId;
}
public String getAcctId() {
    return AcctId;
}
public void setAcctId(String AcctId) {
    AcctId = AcctId;
}

    @Test
@Rollback(false)
@Transactional
public void   
fetch() {
    CriteriaBuilder cb = 
entityManager.getCriteriaBuilder();
    CriteriaQuery<Instructor> cq = 
cb.createQuery(Instructor.class);
    Root<Instructor> root = 
cq.from(Instructor.class);
    root.join(Instructor_.idProof);
    root.join(Instructor_.vehicles);
    Join<Instructor, Student> insStuJoin = 
root.join(Instructor_.students);
    insStuJoin.join(Student_.instructors);
    Join<Student, Vehicle> stuVehcileJoin.   
= insStuJoin.join(Student_.vehicles);
    Join<Vehicle, Document> 
vehicleDocumentJoin = 
stuVehcileJoin.join(Vehicle_.documents);

DataPrinters.
listDataPrinter.accept.   
(queryExecutor.fetchListForCriteriaQuery
      (cq.select(root).where
(cb.greaterThan(root.get(Instructor_.id), 2),                        
           cb.in(vehicleDocumentJoin.get
                          (Document_.name)).value("1")
.value("2").value("3")));
}