Java Spring数据规范API-单向连接OneToMany

我有两个实体，一个

Dokument

：

@Entity
@Table(name = "DOKUMENT")
public class Dokument {
    @Id
    private Long id;
    ...
}

和

业务列表

：

@Entity
@Table(name = "BUSINESS_LIST")
public class BusinessList{

    @Id
    private Long id;

    @Column(name = "BUSINESS_LIST_NUMBER", unique = true)
    @NotNull
    private String businessListNumber;

    @OneToMany
    @JoinColumn(name = "BUSINESS_LIST_ID")
    private List<Dokument> dokuments = new ArrayList<>();
    ...
}

然而，对于API规范，这并不是那么简单。如果这两者之间存在双向关系，那么方法将非常简单：

    public static Specification<Dokument> businessListNumberEqual(String businessListNumber) {
        return (Root<Dokument> root, CriteriaQuery<?> query, CriteriaBuilder builder) -> {
            if (businessListNumber == null) {
                return null;
            }
            Join<Dokument, BusinessList> businessListJoin = root.join("businessList", JoinType.INNER);
            return builder.equal(businessListJoin .get("businessListNumber"), businessListNumber);
        };
    }

公共静态规范BusinessListNumberQual（字符串businessListNumber）{
返回（根目录、CriteriaQuery查询、CriteriaBuilder）->{
if（businessListNumber==null）{
返回null；
}
Join businessListJoin=root.Join（“businessList”，JoinType.INNER）；
return builder.equal（businessListJoin.get（“businessListNumber”）、businessListNumber）；
};
}

不幸的是，我不允许在这里使用双向关系，我也没有尝试建立这个关系

---

你能帮我吗？：）

尝试创建两个不同的规范，一个用于join，另一个用于where子句，而不是创建一个规范

使用BusinessList存储库，您应该可以获得预期的查询

public static Specification<BusinessList> joinDocument() {
    return (root, query, builder) -> {           
        root.join("dokuments", JoinType.INNER);
        return null;
    };
}
    
public static Specification<BusinessList> businessListNumberEqual(String businessListNumber) {
    return (root, query, builder) -> {
        if (businessListNumber == null) {
            return null;
        }            
        return builder.equal(root.get("businessListNumber"), businessListNumber);
    };
}

 Specification.where(joinDocument()).and(businessListNumberEqual("businessListNumber"));

公共静态规范joinDocument（）{
返回（根、查询、生成器）->{
join（“dokuments”，JoinType.INNER）；
返回null；
};
}
公共静态规范BusinessListNumberQual（字符串businessListNumber）{
返回（根、查询、生成器）->{
if（businessListNumber==null）{
返回null；
}            
返回builder.equal（root.get（“businessListNumber”）、businessListNumber）；
};
}
规范，其中（joinDocument（））和（BusinessListNumberQual（“businessListNumber”））；

---

查看git上的代码

嘿，Chetan，非常感谢你的回答！不幸的是，我认为它不能解决这个难题，因为我需要返回规范。这样做的背景是，我对我的GUI搜索掩码有大量的规范查询。之后，在构建规范时，我将使用dokumentDao.findAll（规范）。因此，我无法通过那里的规范：(

public static Specification<BusinessList> joinDocument() {
    return (root, query, builder) -> {           
        root.join("dokuments", JoinType.INNER);
        return null;
    };
}
    
public static Specification<BusinessList> businessListNumberEqual(String businessListNumber) {
    return (root, query, builder) -> {
        if (businessListNumber == null) {
            return null;
        }            
        return builder.equal(root.get("businessListNumber"), businessListNumber);
    };
}

 Specification.where(joinDocument()).and(businessListNumberEqual("businessListNumber"));