Kriteria Hibernasi mengembalikan anak beberapa kali dengan FetchType.EAGER

Saya memiliki Orderkelas yang memiliki daftar OrderTransactionsdan saya memetakannya dengan pemetaan Hibernate satu-ke-banyak seperti:

@OneToMany(targetEntity = OrderTransaction.class, cascade = CascadeType.ALL)
public List<OrderTransaction> getOrderTransactions() {
    return orderTransactions;
}

Ini Orderjuga memiliki bidang orderStatus, yang digunakan untuk memfilter dengan Kriteria berikut:

public List<Order> getOrderForProduct(OrderFilter orderFilter) {
    Criteria criteria = getHibernateSession()
            .createCriteria(Order.class)
            .add(Restrictions.in("orderStatus", orderFilter.getStatusesToShow()));
    return criteria.list();
}

Ini berhasil dan hasilnya seperti yang diharapkan.

Sekarang inilah pertanyaan saya : Mengapa, ketika saya menyetel jenis pengambilan secara eksplisit ke EAGER, apakah Ordermuncul beberapa kali dalam daftar yang dihasilkan?

@OneToMany(targetEntity = OrderTransaction.class, fetch = FetchType.EAGER, cascade = CascadeType.ALL)
public List<OrderTransaction> getOrderTransactions() {
    return orderTransactions;
}

Bagaimana saya harus mengubah kode Kriteria saya untuk mencapai hasil yang sama dengan pengaturan baru?

Ini sebenarnya adalah perilaku yang diharapkan jika saya memahami konfigurasi Anda dengan benar.

Anda mendapatkan Ordercontoh yang sama di salah satu hasil, tetapi karena sekarang Anda melakukan penggabungan dengan OrderTransaction, itu harus mengembalikan jumlah hasil yang sama dengan gabungan sql biasa akan mengembalikan

Jadi sebenarnya itu harus muncul beberapa kali. ini dijelaskan dengan sangat baik oleh penulis (Gavin King) sendiri di sini : Keduanya menjelaskan mengapa, dan bagaimana tetap mendapatkan hasil yang berbeda

Hibernate tidak mengembalikan hasil yang berbeda untuk kueri dengan pengambilan gabungan luar diaktifkan untuk koleksi (meskipun saya menggunakan kata kunci yang berbeda)? Pertama, Anda perlu memahami SQL dan cara kerja OUTER JOIN di SQL. Jika Anda tidak sepenuhnya memahami dan memahami gabungan luar dalam SQL, jangan lanjutkan membaca item FAQ ini tetapi lihat manual atau tutorial SQL. Jika tidak, Anda tidak akan memahami penjelasan berikut dan Anda akan mengeluh tentang perilaku ini di forum Hibernate.

Contoh umum yang mungkin mengembalikan referensi duplikat dari objek Order yang sama:

List result = session.createCriteria(Order.class)
                    .setFetchMode("lineItems", FetchMode.JOIN)
                    .list();

---

<class name="Order">
    ...
    <set name="lineItems" fetch="join">

---

List result = session.createCriteria(Order.class)
                       .list();
List result = session.createQuery("select o from Order o left join fetch o.lineItems").list();

Semua contoh ini menghasilkan pernyataan SQL yang sama:

SELECT o.*, l.* from ORDER o LEFT OUTER JOIN LINE_ITEMS l ON o.ID = l.ORDER_ID

Ingin tahu mengapa duplikatnya ada? Lihatlah set hasil SQL, Hibernate tidak menyembunyikan duplikat ini di sisi kiri hasil gabungan luar tetapi mengembalikan semua duplikat dari tabel penggerak. Jika Anda memiliki 5 pesanan dalam database, dan setiap pesanan memiliki 3 item baris, kumpulan hasil akan menjadi 15 baris. Daftar hasil Java dari query ini akan memiliki 15 elemen, semua bertipe Order. Hanya 5 instance Order yang akan dibuat oleh Hibernate, tetapi duplikat dari kumpulan hasil SQL disimpan sebagai referensi duplikat untuk 5 instance ini. Jika Anda tidak memahami kalimat terakhir ini, Anda perlu membaca tentang Java dan perbedaan antara instance di heap Java dan referensi ke instance semacam itu.

(Mengapa left outer join? Jika Anda memiliki pesanan tambahan tanpa item baris, kumpulan hasil akan menjadi 16 baris dengan NULL mengisi sisi kanan, di mana data item baris untuk pesanan lain. Anda menginginkan pesanan meskipun mereka tidak memiliki item baris, bukan? Jika tidak, gunakan inner join fetch di HQL Anda).

Hibernate tidak memfilter referensi duplikat ini secara default. Beberapa orang (bukan Anda) sebenarnya menginginkan ini. Bagaimana Anda bisa menyaringnya?

Seperti ini:

Collection result = new LinkedHashSet( session.create*(...).list() );

Selain apa yang disebutkan oleh Eran, cara lain untuk mendapatkan perilaku yang Anda inginkan, adalah dengan mengatur transformator hasil:

criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

mencoba

@Fetch (FetchMode.SELECT) 

sebagai contoh

@OneToMany(targetEntity = OrderTransaction.class, fetch = FetchType.EAGER, cascade = CascadeType.ALL)
@Fetch (FetchMode.SELECT)
public List<OrderTransaction> getOrderTransactions() {
return orderTransactions;

}

Jangan gunakan List dan ArrayList tapi Set dan HashSet.

@OneToMany(targetEntity = OrderTransaction.class, cascade = CascadeType.ALL)
public Set<OrderTransaction> getOrderTransactions() {
    return orderTransactions;
}

Menggunakan Java 8 dan Streams, saya menambahkan metode utilitas saya, pernyataan pengembalian ini:

return results.stream().distinct().collect(Collectors.toList());

Stream menghapus duplikat dengan sangat cepat. Saya menggunakan anotasi di kelas Entitas saya seperti ini:

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinTable(name = "STUDENT_COURSES")
private List<Course> courses;

Saya pikir lebih baik di aplikasi saya untuk menggunakan sesi dalam metode di mana saya membutuhkan data dari basis data. Tutup sesi ketika saya selesai. Tentu saja menyetel kelas Entitas saya untuk menggunakan jenis pengambilan yang disewakan. Saya pergi ke refactor.

Saya memiliki masalah yang sama untuk mengambil 2 koleksi terkait: pengguna memiliki 2 peran (Set) dan 2 makanan (Daftar) dan makanan digandakan.

@Table(name = "users")
public class User extends AbstractNamedEntity {

   @CollectionTable(name = "user_roles", joinColumns = @JoinColumn(name = "user_id"))
   @Column(name = "role")
   @ElementCollection(fetch = FetchType.EAGER)
   @BatchSize(size = 200)
   private Set<Role> roles;

   @OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
   @OrderBy("dateTime DESC")
   protected List<Meal> meals;
   ...
}

DISTINCT tidak membantu (kueri DATA-JPA):

@EntityGraph(attributePaths={"meals", "roles"})
@QueryHints({@QueryHint(name= org.hibernate.jpa.QueryHints.HINT_PASS_DISTINCT_THROUGH, value = "false")}) // remove unnecessary distinct from select
@Query("SELECT DISTINCT u FROM User u WHERE u.id=?1")
User getWithMeals(int id);

Akhirnya saya menemukan 2 solusi:

1. Ubah Daftar ke LinkedHashSet
2. Gunakan EntityGraph hanya dengan kolom "meal" dan ketik LOAD, yang memuat peran seperti yang dideklarasikan (EAGER dan BatchSize = 200 untuk mencegah masalah N + 1):

Solusi akhir:

@EntityGraph(attributePaths = {"meals"}, type = EntityGraph.EntityGraphType.LOAD)
@Query("SELECT u FROM User u WHERE u.id=?1")
User getWithMeals(int id);

Daripada menggunakan peretasan seperti:

• Set dari pada List
• criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);

yang tidak mengubah kueri sql Anda, kami dapat menggunakan (mengutip spesifikasi JPA)

q.select(emp).distinct(true);

yang memang mengubah kueri sql yang dihasilkan, sehingga memiliki a DISTINCTdi dalamnya.

Kedengarannya bukan perilaku yang bagus dengan menerapkan gabungan luar dan membawa hasil duplikat. Satu-satunya solusi yang tersisa adalah memfilter hasil kami menggunakan aliran. Terima kasih java8 memberikan cara yang lebih mudah untuk memfilter.

return results.stream().distinct().collect(Collectors.toList());