PersistentObjectException: odłączony obiekt przekazany do persist wyrzucony przez JPA i Hibernate

Rozwiązanie jest proste, wystarczy użyć CascadeType.MERGE zamiast CascadeType.PERSIST lub CascadeType.ALL.

Miałem ten sam problem i CascadeType.MERGE zadziałał dla mnie.

Usuń kaskadowanie z jednostki potomnejTransaction, powinno być tylko:

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

(FetchType.EAGER można usunąć, jak również jest to domyślne dla @ManyToOne)

To wszystko!

Ale tylko przejściowe (nowe) byty mogą być przekazywane do persist (Transaction w tym przypadku). Wolnostojący (lub inny stan nie-transientowy) może nie (Account w tym przypadku, ponieważ jest już w DB).

Dlatego otrzymujesz wyjątek "odłączony obiekt przekazany do persist". Account byt jest przeznaczony! Nie Transaction, na które dzwonisz persist.

Zazwyczaj nie chcesz rozmnażać się z dziecka Na rodzica. Niestety jest wiele przykładów kodu w książkach (nawet w dobrych) i w sieci, które właśnie to robią. Nie wiem, dlaczego... Może czasami po prostu kopiowane bez zastanowienia...

Zgadnij, co się stanie, jeśli zadzwonisz remove(transaction) nadal masz "kaskadowe wszystko" w tym @ ManyToOne? account (btw, ze wszystkimi innymi transakcjami!) zostaną również usunięte z DB. Ale to nie był twój zamiar, prawda?

Nie przekazuj id (pk) do metody persist lub spróbuj metody save () zamiast persist ().

Używanie merge jest ryzykowne i trudne, więc jest to brudne obejście w Twoim przypadku. Musisz pamiętać, że gdy przekazujesz obiekt encji do scalenia, to zatrzymuje dołączenie do transakcji, a zamiast tego zwracany jest nowy, teraz dołączony encja. Oznacza to, że jeśli ktoś posiada stary obiekt encji, zmiany w nim są po cichu ignorowane i odrzucane przy zatwierdzaniu.

Nie pokazujesz tutaj pełnego kodu, więc nie mogę dwukrotnie sprawdzić twojego wzór transakcji. Jednym ze sposobów, aby dostać się do takiej sytuacji jest, jeśli nie masz aktywnej transakcji podczas wykonywania merge and persist. W takim przypadku oczekuje się, że dostawca persistence otworzy nową transakcję dla każdej operacji JPA i natychmiast zatwierdzi ją i zamknie przed powrotem połączenia. W takim przypadku scalanie zostanie uruchomione w pierwszej transakcji, a następnie po powrocie metody merge transakcja zostanie zakończona i zamknięta, a zwrócony obiekt zostanie odłączony. Persist pod nim otworzy drugą transakcję i spróbuje odnieść się do jednostki, która jest odłączona, dając wyjątek. Zawsze zawijaj kod wewnątrz transakcji, chyba że dobrze wiesz, co robisz.

Używając transakcji zarządzanej kontenerem wyglądałoby to mniej więcej tak. Uwaga: zakłada się, że metoda znajduje się w fasoli sesji i jest wywoływana przez lokalny lub Zdalny interfejs.

@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);
}

Prawdopodobnie w tym przypadku uzyskałeś swój obiekt account używając logiki merge, a {[1] } jest używany do utrzymywania nowych obiektów i będzie narzekać, jeśli hierarchia ma już utrzymany obiekt. W takich przypadkach należy użyć saveOrUpdate zamiast persist.

Usuwanie asocjacji dziecka

Więc musisz usunąć {[2] } ze Stowarzyszenia @ManyToOne. Podmioty potomne nie powinny kaskadowo łączyć się ze stowarzyszeniami rodziców. Tylko jednostki nadrzędne powinny kaskadowo przekształcać się w jednostki podrzędne.

@ManyToOne(fetch= FetchType.LAZY)

Zauważ, że ustawiłem atrybut fetch na FetchType.LAZY, ponieważ eager fetching jest bardzo zły dla wydajności.

Ustawienie obu stron Stowarzyszenia

Gdy masz dwukierunkowy związek, musisz zsynchronizować obie strony za pomocą addChild i removeChild metody w jednostce dominującej:

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

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

W definicji encji nie określasz @ JoinColumn dla Account połączonego z Transaction. Będziesz chciał coś takiego:

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

EDIT: Cóż, myślę, że byłoby to przydatne, gdybyś używał @Table adnotacji na swojej klasie. Heh. :)

Nawet jeśli Twoje adnotacje są poprawnie zadeklarowane, aby prawidłowo zarządzać relacją jeden do wielu, nadal możesz napotkać ten precyzyjny wyjątek. Podczas dodawania nowego obiektu potomnego, Transaction, do dołączonego modelu danych musisz zarządzać wartością klucza głównego - , chyba że nie powinieneś . Jeśli przed wywołaniem persist(T) podasz podstawową wartość klucza dla elementu potomnego zadeklarowanego w następujący sposób, napotkasz ten wyjątek.

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

W tym przypadku adnotacje deklarują że baza danych będzie zarządzać generowaniem podstawowych wartości klucza jednostki po wstawieniu. Podanie jednego samodzielnie (np. poprzez setter Id) powoduje ten wyjątek.

Alternatywnie, ale faktycznie tak samo, deklaracja adnotacji daje ten sam wyjątek:

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

Dlatego nie ustawiaj wartości id w kodzie aplikacji, gdy jest już zarządzana.

Jeśli nic nie pomaga i nadal otrzymujesz ten wyjątek, Przejrzyj swoje metody equals() - i nie dołączaj do nich kolekcji potomnych. Szczególnie jeśli masz głęboką strukturę osadzonych kolekcji(np. A zawiera Bs, B zawiera Cs, itp.).

W przykładzie 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!
    }
  }

W powyższym przykładzie Usuń transakcje z czeków equals(). Dzieje się tak, ponieważ hibernate oznacza, że nie próbujesz zaktualizować starego obiektu, ale przekazujesz nowy obiekt do persist, za każdym razem, gdy zmienisz element na kolekcja dla dzieci.
Oczywiście te rozwiązania nie będą pasować do wszystkich aplikacji i powinieneś starannie zaprojektować to, co chcesz uwzględnić w metodach equals i hashCode.

Moja Wiosenna odpowiedź oparta na JPA: po prostu dodałem adnotację @Transactional do mojej zewnętrznej metody.

Dlaczego to działa

Obiekt potomny natychmiast został odłączony, ponieważ nie było aktywnego kontekstu sesji hibernacji. Dostarczenie transakcji Spring (Data JPA) zapewnia obecność sesji hibernacji.

Odniesienie:

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

Może to błąd OpenJPA, po wycofaniu resetuje pole @ Version, ale pcVersionInit zachowuje prawdę. Mam abstrakcję, która zadeklarowała pole @ Version. Mogę obejść to, resetując pole pcVersionInit. Ale to nie jest dobry pomysł. Myślę, że to nie działa, gdy kaskada utrzymują podmiot.

    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;
            }

Musisz ustawić transakcję dla każdego konta.

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

Lub wystarczy (jeśli to właściwe) ustawić ids NA null po wielu stronach.

// 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

Rozwiązane przez zapisanie obiektu zależnego przed następnym.

Przydarzyło mi się to, ponieważ nie ustawiałem identyfikatora (który nie był generowany automatycznie). and trying to save with relation @ManytoOne

W moim przypadku dokonywałem transakcji przy użyciu metody persist . Po zmianie metody persist na Save została ona rozwiązana.

Jeśli powyższe rozwiązania nie działają tylko jeden raz skomentuj metody getter i setter klasy entity i nie ustawiaj wartości id.(Klucz podstawowy) Więc to zadziała.

@OneToMany (mappedBy = "xxxx", cascade={CascadeType.MERGE, CascadeType.PERSIST, CascadeType.Usunąć}) zadziałało na mnie.