java使用Hibernate获取重复条目

Question

我在使用JPA/Hibernate时遇到了一个奇怪的问题。我在测试中看到重复条目

这是我的BaseEntity类：

@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
public abstract class BaseEntity {
    
    @Id
    @Column(name = "ID", updatable = false, nullable = false)
    @GenericGenerator(name = "uniqueIDGenerator", strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator", parameters = {
            @org.hibernate.annotations.Parameter(name = "sequence_name", value = "ID_SEQUENCE"),
            @org.hibernate.annotations.Parameter(name = "increment_size", value = "100"),
            @org.hibernate.annotations.Parameter(name = "optimizer ", value = "pooled") })
    @GeneratedValue(generator = "uniqueIDGenerator")
    @NotNull
    protected int id;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
    
}

以下是我的主要合作伙伴课程：

@Entity
@Table(name = "partner")
public class Partner extends BaseEntity{
    
    @Column(name = "name")
    private String name;
    
    @OneToMany(mappedBy="partner", fetch=FetchType.EAGER)
    @Cascade(CascadeType.DELETE)
    private List<Receipt> receipts;
    
    @OneToMany(mappedBy="partner", fetch=FetchType.EAGER)
    @Cascade(CascadeType.DELETE)
    private List<Delivery> deliveries;
    
    public Partner() {
        setReceipts(new ArrayList<Receipt>());
        setDeliveries(new ArrayList<Delivery>());
    }
    
    public Partner(String name){
        this();
        
        this.setName(name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Receipt> getReceipts() {
        return receipts;
    }

    public void setReceipts(List<Receipt> receipts) {
        this.receipts = receipts;
    }

    public List<Delivery> getDeliveries() {
        return deliveries;
    }

    public void setDeliveries(List<Delivery> deliveries) {
        this.deliveries = deliveries;
    }
}

Partner有两个子类，receive和Delivery。这是收据类：

@Entity
@Table(name = "receipt")
public class Receipt extends BaseEntity{
    
    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="partnerId")
    private Partner partner;
    
    @Column(name = "name")
    private String name;
    @Column(name = "json")
    private String json;

    @Transient
    private ReceiptContainer receiptContainer;
    
    
    public Receipt() {
    }
    public Receipt(String name){
        this();
        
        this.setName(name);
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getJson() {
        return json;
    }

    public void setJson(String json) {
        this.json = json;
    }

    public ReceiptContainer getReceiptContainer() {
        return receiptContainer;
    }

    public void setReceiptContainer(ReceiptContainer receiptContainer) {
        this.receiptContainer = receiptContainer;
    }

    public Partner getPartner() {
        return partner;
    }

    public void setPartner(Partner partner) {
        this.partner = partner;
    }
    
}

以下是交付类：

@Entity
@Table(name = "delivery")
public class Delivery extends BaseEntity{
    
    @ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="partnerId")
    private Partner partner;
    
    @Column(name = "name")
    private String name;
    @Column(name = "json")
    private String json;

    @Transient
    private DeliveryContainer deliveryContainer;
    
    
    public Delivery() {
    }
    public Delivery(String name){
        this();
        
        this.setName(name);
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getJson() {
        return json;
    }

    public void setJson(String json) {
        this.json = json;
    }

    public DeliveryContainer getDeliveryContainer() {
        return deliveryContainer;
    }

    public void setDeliveryContainer(DeliveryContainer deliveryContainer) {
        this.deliveryContainer = deliveryContainer;
    }

    public Partner getPartner() {
        return partner;
    }

    public void setPartner(Partner partner) {
        this.partner = partner;
    }
    
}

我得到的对象如下：

@Transactional
public Partner get(int id){
    Partner partner = entityManager.find(Partner.class, id);
    return partner;
}

如您所见，partner类包括一个对象列表和一个对象列表，它们分别存储在各自的表receive和delivery中

---在进一步讨论之前，我想指出，数据库中显示的条目数量正确。此问题仅在获取Java应用程序中的对象时发生---

当我添加一个对象而不存在任何对象时，将显示一个对象而不显示任何对象，这是预期的。如果存在一个对象和一个对象，则会再次显示一个对象和一个对象，这是预期的。当存在多个或多个对象时，就会出现问题。例如，如果添加了两个对象，但只添加了一个对象，则会显示两个对象和两个对象

为了更好地说明这一点，请参见下面的测试用例表。意外结果被破折号包围

<Receipt> Obj Added | <Delivery> Obj Added | <Receipt> Obj Displayed | <Delivery> Obj Displayed
         0          |          0           |           0             |            0
         0          |          1           |           0             |            1
         1          |          0           |           1             |            0
         1          |          1           |           1             |            1
         1          |          2           |        ---2---          |         ---2---
         2          |          1           |        ---2---          |         ---2---
         2          |          2           |        ---4---          |         ---4---

我的问题是，为什么我会看到这些意想不到的结果

Answer 1

您看到重复项的原因是您急切地获取子项，这将创建一个外部联接

（您可以使用@Fetch（FetchMode.SELECT），但这将导致额外的查询来检索您的项目）

Hibernate API reference indicating outer join takes place.

下面是对您的问题的深入回答：Hibernate Criteria returns children multiple times with FetchType.EAGER

您可以从列表切换到集合（如果这样做，请确保覆盖equals/compareTo/hashCode）。或者，如果要通过条件从数据库中提取这些项，则可以将结果转换器添加到查询结果中

hibernate建议使用集合而不是列表

Answer 2

您可以将查询结果存储在Set中，它将为您删除重复项

Answer 3

如果您正在使用JPA：

CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<Receipt> query = cb.createQuery(Receipt.class);
query.distinct(true);

否则，请参见Gernan的答案

Answer 4

Hibernate不会为集合启用外部联接获取的查询返回不同的结果（即使我使用了distinct关键字）？阅读more，它可能会对你有所帮助

Answer 5

也许您可以尝试使用DISTINCT属性进行查询

只需将此添加到您的标准中：

criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

如果未使用标准：

SELECT DISTINCT <QUERY>

如果它不能解决您的问题，请显示您的查询代码