PersistentObjectException: entitas terpisah dilewatkan untuk bertahan dilemparkan oleh JPA dan Hibernate

Saya memiliki model objek JPA-persisten yang berisi hubungan banyak-ke-satu: Accountmemiliki banyak Transactions. A Transactionmemiliki satu Account.

Berikut cuplikan kode:

@Entity
public class Transaction {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @ManyToOne(cascade = {CascadeType.ALL},fetch= FetchType.EAGER)
    private Account fromAccount;
....

@Entity
public class Account {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    @OneToMany(cascade = {CascadeType.ALL},fetch= FetchType.EAGER, mappedBy = "fromAccount")
    private Set<Transaction> transactions;

Saya dapat membuat Accountobjek, menambahkan transaksi, dan bertahan Accountobjek dengan benar. Tetapi, ketika saya membuat transaksi, menggunakan Akun yang sudah ada yang sudah ada , dan bertahan dalam Transaksi , saya mendapatkan pengecualian:

Disebabkan oleh: org.hibernate.PersistentObjectException: entitas terpisah dilewatkan untuk bertahan: com.paulsanwald.Akun di org.hibernate.event.internal.DefaultPersistEventListener.onPersist (DefaultPersistEventListener.java:141)

Jadi, saya bisa bertahan Accountyang mengandung transaksi, tetapi bukan Transaksi yang memiliki Account. Saya pikir ini karena Accountmungkin tidak dilampirkan, tetapi kode ini masih memberi saya pengecualian yang sama:

if (account.getId()!=null) {
    account = entityManager.merge(account);
}
Transaction transaction = new Transaction(account,"other stuff");
 // the below fails with a "detached entity" message. why?
entityManager.persist(transaction);

Bagaimana saya bisa menyimpan dengan benar Transaction, yang terkait dengan objek yang sudah ada Account?

Ini adalah masalah konsistensi dua arah yang khas. Ini dibahas dengan baik dalam tautan ini dan juga tautan ini.

Sesuai dengan artikel di 2 tautan sebelumnya, Anda perlu memperbaiki setter Anda di kedua sisi hubungan dua arah. Contoh penyetel untuk sisi Satu ada di tautan ini.

Contoh setter untuk sisi Banyak ada di tautan ini.

Setelah Anda memperbaiki setter Anda, Anda ingin mendeklarasikan tipe akses Entity menjadi "Properti". Praktik terbaik untuk menyatakan jenis akses "Properti" adalah memindahkan SEMUA anotasi dari properti anggota ke getter yang sesuai. Kata hati-hati adalah untuk tidak mencampur jenis akses "Field" dan "Property" dalam kelas entitas jika perilaku tidak ditentukan oleh spesifikasi JSR-317.

Solusinya sederhana, cukup gunakan CascadeType.MERGEbukan CascadeType.PERSISTatau CascadeType.ALL.

Saya memiliki masalah yang sama dan CascadeType.MERGEtelah bekerja untuk saya.

Saya harap Anda diurutkan.

Hapus cascading dari entitas anakTransaction , seharusnya hanya:

@Entity class Transaction {
    @ManyToOne // no cascading here!
    private Account account;
}

( FetchType.EAGERdapat dihapus dan itu adalah default untuk @ManyToOne)

Itu saja!

Mengapa? Dengan mengatakan "cascade ALL" pada entitas anak, TransactionAnda mengharuskan setiap operasi DB disebarkan ke entitas induk Account. Jika Anda melakukannya persist(transaction), persist(account)akan dipanggil juga.

Tetapi hanya entitas transien (baru) yang dapat diteruskan ke persist( Transactiondalam hal ini). Yang terlepas (atau keadaan tidak transien lainnya) mungkin tidak ( Accountdalam hal ini, karena sudah dalam DB).

Oleh karena itu Anda mendapatkan pengecualian "entitas terpisah yang dilewati untuk bertahan" . The Accountentitas yang dimaksud! Bukan Transactionkau yang menelepon persist.

Anda biasanya tidak ingin menyebarkan dari anak ke orang tua. Sayangnya ada banyak contoh kode dalam buku (bahkan yang bagus) dan melalui internet, yang melakukan hal itu. Saya tidak tahu, mengapa ... Mungkin kadang-kadang hanya disalin berulang tanpa banyak berpikir ...

Coba tebak apa yang terjadi jika Anda menyebut remove(transaction)masih memiliki "cascade ALL" di @ManyToOne itu? The account(btw, dengan semua transaksi lain!) Akan dihapus dari DB juga. Tapi itu bukan niatmu, kan?

Menggunakan penggabungan berisiko dan rumit, jadi ini solusi yang kotor dalam kasus Anda. Anda harus ingat setidaknya bahwa ketika Anda melewatkan objek entitas untuk digabung, itu berhenti melekat pada transaksi dan sebagai gantinya, entitas yang sekarang dilampirkan dikembalikan. Ini berarti bahwa jika ada yang memiliki objek entitas lama masih dalam kepemilikan mereka, perubahan itu diabaikan secara diam-diam dan dibuang pada komit.

Anda tidak menunjukkan kode lengkap di sini, jadi saya tidak dapat memeriksa ulang pola transaksi Anda. Salah satu cara untuk sampai ke situasi seperti ini adalah jika Anda tidak memiliki transaksi aktif ketika menjalankan penggabungan dan bertahan. Dalam hal ini penyedia persistensi diharapkan untuk membuka transaksi baru untuk setiap operasi JPA yang Anda lakukan dan segera melakukan dan menutupnya sebelum panggilan kembali. Jika demikian, gabungan akan dijalankan dalam transaksi pertama dan kemudian setelah metode gabungan kembali, transaksi diselesaikan dan ditutup dan entitas yang dikembalikan sekarang terlepas. Bertahan di bawahnya kemudian akan membuka transaksi kedua, dan mencoba merujuk ke entitas yang terlepas, memberikan pengecualian. Selalu bungkus kode Anda di dalam transaksi kecuali Anda tahu betul apa yang Anda lakukan.

Menggunakan transaksi yang dikelola kontainer, akan terlihat seperti ini. Perhatikan: ini mengasumsikan metode ini ada di dalam sesi kacang dan dipanggil melalui antarmuka Lokal atau Remote.

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void storeAccount(Account account) {
    ...

    if (account.getId()!=null) {
        account = entityManager.merge(account);
    }

    Transaction transaction = new Transaction(account,"other stuff");

    entityManager.persist(account);
}

Mungkin dalam kasus ini Anda mendapatkan accountobjek Anda menggunakan logika gabungan, dan persistdigunakan untuk bertahan objek baru dan itu akan mengeluh jika hierarki memiliki objek yang sudah ada. Anda harus menggunakan saveOrUpdatedalam kasus seperti itu, bukan persist.

Jangan meneruskan id (pk) untuk bertahan metode atau mencoba metode save () bukannya bertahan ().

Karena ini adalah pertanyaan yang sangat umum, saya menulis artikel ini , yang menjadi dasar jawaban ini.

Untuk memperbaiki masalah, Anda harus mengikuti langkah-langkah ini:

1. Menghapus cascading asosiasi anak

Jadi, Anda harus menghapus @CascadeType.ALLdari @ManyToOneasosiasi. Entitas anak tidak boleh mengalir ke asosiasi orang tua. Hanya entitas induk yang harus mengalir ke entitas anak.

@ManyToOne(fetch= FetchType.LAZY)

Perhatikan bahwa saya mengatur fetchatributnya FetchType.LAZYkarena ingin mengambil sangat buruk untuk kinerja .

2. Atur kedua sisi asosiasi

Setiap kali Anda memiliki asosiasi dua arah, Anda perlu menyinkronkan kedua sisi menggunakan addChilddan removeChildmetode dalam entitas induk:

public void addTransaction(Transaction transaction) {
    transcations.add(transaction);
    transaction.setAccount(this);
}

public void removeTransaction(Transaction transaction) {
    transcations.remove(transaction);
    transaction.setAccount(null);
}

Untuk detail lebih lanjut tentang mengapa penting untuk menyinkronkan kedua ujung dari asosiasi dua arah, periksa artikel ini .

Dalam definisi entitas Anda, Anda tidak menentukan @JoinColumn untuk Accountbergabung dengan a Transaction. Anda akan menginginkan sesuatu seperti ini:

@Entity
public class Transaction {
    @ManyToOne(cascade = {CascadeType.ALL},fetch= FetchType.EAGER)
    @JoinColumn(name = "accountId", referencedColumnName = "id")
    private Account fromAccount;
}

EDIT: Ya, saya kira itu akan berguna jika Anda menggunakan @Tableanotasi di kelas Anda. Heh. :)

Bahkan jika anotasi Anda dinyatakan dengan benar untuk mengelola hubungan satu-ke-banyak dengan benar, Anda masih dapat menemukan pengecualian yang tepat ini. Saat menambahkan objek anak baru Transaction,, ke model data terlampir Anda harus mengelola nilai kunci utama - kecuali Anda tidak seharusnya melakukannya . Jika Anda memberikan nilai kunci utama untuk entitas anak yang dinyatakan sebagai berikut sebelum memanggil persist(T), Anda akan menemukan pengecualian ini.

@Entity
public class Transaction {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
....

Dalam hal ini, anotasi menyatakan bahwa basis data akan mengelola pembuatan nilai kunci primer entitas saat penyisipan. Memberikannya sendiri (seperti melalui setter Id) menyebabkan pengecualian ini.

Atau, tetapi secara efektif sama, deklarasi anotasi ini menghasilkan pengecualian yang sama:

@Entity
public class Transaction {
    @Id
    @org.hibernate.annotations.GenericGenerator(name="system-uuid", strategy="uuid")
    @GeneratedValue(generator="system-uuid")
    private Long id;
....

Jadi, jangan tetapkan idnilai dalam kode aplikasi Anda ketika sudah dikelola.

Jika tidak ada yang membantu dan Anda masih mendapatkan pengecualian ini, tinjau equals() metode - dan jangan masukkan koleksi anak di dalamnya. Terutama jika Anda memiliki struktur koleksi tertanam yang dalam (mis. A mengandung B, B berisi C, dll.).

Dalam contoh Account -> Transactions:

  public class Account {

    private Long id;
    private String accountName;
    private Set<Transaction> transactions;

    @Override
    public boolean equals(Object obj) {
      if (this == obj)
        return true;
      if (obj == null)
        return false;
      if (!(obj instanceof Account))
        return false;
      Account other = (Account) obj;
      return Objects.equals(this.id, other.id)
          && Objects.equals(this.accountName, other.accountName)
          && Objects.equals(this.transactions, other.transactions); // <--- REMOVE THIS!
    }
  }

Dalam contoh di atas hapus transaksi dari equals()cek. Ini karena hibernate akan menyiratkan bahwa Anda tidak mencoba memperbarui objek lama, tetapi Anda meneruskan objek baru untuk bertahan, setiap kali Anda mengubah elemen pada koleksi anak.
Tentu saja solusi ini tidak cocok untuk semua aplikasi dan Anda harus hati-hati merancang apa yang ingin Anda sertakan dalam equalsdan hashCodemetode.

Mungkin itu adalah bug OpenJPA, Ketika kembalikan itu mengatur ulang bidang @Version, tetapi pcVersionInit tetap benar. Saya memiliki AbstraceEntity yang menyatakan bidang @Version. Saya bisa mengatasinya dengan mereset bidang pcVersionInit. Tapi itu bukan ide yang bagus. Saya pikir itu tidak berfungsi ketika memiliki kaskade bertahan.

    private static Field PC_VERSION_INIT = null;
    static {
        try {
            PC_VERSION_INIT = AbstractEntity.class.getDeclaredField("pcVersionInit");
            PC_VERSION_INIT.setAccessible(true);
        } catch (NoSuchFieldException | SecurityException e) {
        }
    }

    public T call(final EntityManager em) {
                if (PC_VERSION_INIT != null && isDetached(entity)) {
                    try {
                        PC_VERSION_INIT.set(entity, false);
                    } catch (IllegalArgumentException | IllegalAccessException e) {
                    }
                }
                em.persist(entity);
                return entity;
            }

            /**
             * @param entity
             * @param detached
             * @return
             */
            private boolean isDetached(final Object entity) {
                if (entity instanceof PersistenceCapable) {
                    PersistenceCapable pc = (PersistenceCapable) entity;
                    if (pc.pcIsDetached() == Boolean.TRUE) {
                        return true;
                    }
                }
                return false;
            }

Anda perlu mengatur Transaksi untuk setiap Akun.

foreach(Account account : accounts){
    account.setTransaction(transactionObj);
}

Atau cukup colud (jika sesuai) untuk mengatur id ke nol di banyak sisi.

// list of existing accounts
List<Account> accounts = new ArrayList<>(transactionObj.getAccounts());

foreach(Account account : accounts){
    account.setId(null);
}

transactionObj.setAccounts(accounts);

// just persist transactionObj using EntityManager merge() method.

cascadeType.MERGE,fetch= FetchType.LAZY

Jawaban saya berdasarkan Data Spring JPA: Saya hanya menambahkan @Transactionalanotasi ke metode luar saya.

Mengapa ini berhasil?

Entitas anak langsung terlepas karena tidak ada konteks sesi Hibernate aktif. Menyediakan transaksi Pegas (Data JPA) memastikan Sesi Hibernasi hadir.

Referensi:

https://vladmihalcea.com/a-beginners-guide-to-jpa-hibernate-entity-state-transitions/

Dalam kasus saya, saya melakukan transaksi ketika metode bertahan digunakan. Pada perubahan bertahan untuk menyimpan metode, itu terselesaikan.

Jika solusi di atas tidak berfungsi hanya satu kali komentar metode pengambil dan penyetel kelas entitas dan tidak menetapkan nilai id. (Kunci utama) Maka ini akan berhasil.

@OneToMany (mappedBy = "xxxx", cascade = {CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REMOVE}) bekerja untuk saya.

Diselesaikan dengan menyimpan objek dependen sebelum yang berikutnya.

Ini terjadi pada saya karena saya tidak mengatur Id (yang tidak dihasilkan secara otomatis). dan mencoba menyimpan dengan relasi @ManytoOne