Sospensione: una raccolta con cascade = "all-delete-orphan" non è più stata referenziata dall'istanza dell'entità proprietaria

Sto riscontrando il seguente problema quando provo ad aggiornare la mia entità:

"A collection with cascade=”all-delete-orphan” was no longer referenced by the owning entity instance".

Ho un'entità padre e ha una Set<...>di alcune entità figlio. Quando provo ad aggiornarlo, ottengo tutti i riferimenti da impostare su queste raccolte e impostarlo.

Il seguente codice rappresenta la mia mappatura:

@OneToMany(mappedBy = "parentEntity", fetch = FetchType.EAGER)
@Cascade({ CascadeType.ALL, CascadeType.DELETE_ORPHAN })
public Set<ChildEntity> getChildren() {
    return this.children;
}

Ho provato a pulire solo il Set <..>, secondo questo: Come "possibile" risolvere il problema ma non ha funzionato.

Se hai qualche idea, per favore fatemelo sapere.

Grazie!

Controlla tutti i luoghi in cui stai assegnando qualcosa a sonEntities. Il collegamento a cui fai riferimento indica chiaramente la creazione di un nuovo HashSet ma puoi avere questo errore ogni volta che riassegni il set. Per esempio:

public void setChildren(Set<SonEntity> aSet)
{
    this.sonEntities = aSet; //This will override the set that Hibernate is tracking.
}

Di solito si desidera "nuovo" l'insieme una sola volta in un costruttore. Ogni volta che si desidera aggiungere o eliminare qualcosa all'elenco, è necessario modificare il contenuto dell'elenco anziché assegnare un nuovo elenco.

Per aggiungere bambini:

public void addChild(SonEntity aSon)
{
    this.sonEntities.add(aSon);
}

Per rimuovere i bambini:

public void removeChild(SonEntity aSon)
{
    this.sonEntities.remove(aSon);
}

Il metodo:

public void setChildren(Set<SonEntity> aSet) {
    this.sonEntities = aSet;
}

funziona se parentEntityè staccato e di nuovo se lo aggiorniamo.
Ma se l'entità non è distaccata dal contesto (per es. Le operazioni di ricerca e aggiornamento sono nella stessa transazione), il metodo seguente funziona.

public void setChildren(Set<SonEntity> aSet) {
    //this.sonEntities = aSet; //This will override the set that Hibernate is tracking.
    this.sonEntities.clear();
    if (aSet != null) {
        this.sonEntities.addAll(aSet);
    }
}

Quando ho letto in vari posti che il letargo non ti piaceva assegnare a una raccolta, ho pensato che la cosa più sicura da fare sarebbe ovviamente renderla definitiva in questo modo:

class User {
  private final Set<Role> roles = new HashSet<>();

public void setRoles(Set<Role> roles) {
  this.roles.retainAll(roles);
  this.roles.addAll(roles);
}
}

Tuttavia, questo non funziona e si ottiene l'errore temuto "non più referenziato", che in questo caso è piuttosto fuorviante.

Si scopre che l'ibernazione chiama il tuo metodo setRoles E vuole che la sua classe di raccolta speciale sia installata qui e non accetti la tua classe di raccolta. Questo mi ha fatto rimanere a lungo per molto, nonostante abbia letto tutti gli avvertimenti sul non assegnare alla tua collezione nel tuo metodo set.

Quindi sono passato a questo:

public class User {
  private Set<Role> roles = null;

  public void setRoles(Set<Role> roles) {
  if (this.roles == null) {
    this.roles = roles;
  } else {
    this.roles.retainAll(roles);
   this.roles.addAll(roles);
  }
}
}

In modo che alla prima chiamata, hibernate installi la sua classe speciale e nelle chiamate successive puoi usare tu stesso il metodo senza distruggere tutto. Se vuoi usare la tua classe come bean, probabilmente hai bisogno di un setter funzionante, e questo almeno sembra funzionare.

In realtà, il mio problema riguardava la parità e l'hashcode delle mie entità. Un codice legacy può comportare molti problemi, non dimenticare mai di verificarlo. Tutto quello che ho fatto è stato solo mantenere la strategia di eliminazione degli orfani e correggere uguali e hashcode.

Ho avuto lo stesso errore. Il problema per me era che dopo aver salvato l'entità la raccolta mappata era ancora nulla e quando si cercava di aggiornare l'entità veniva generata l'eccezione. Cosa mi ha aiutato: salvare l'entità, quindi eseguire un aggiornamento (la raccolta non è più nulla) e quindi eseguire l'aggiornamento. Forse l'inizializzazione della raccolta con il nuovo ArrayList () o qualcosa potrebbe anche aiutare.

HA UN TIPO DI RELAZIONE:

Non provare a creare un'istanza della raccolta quando viene dichiarata in hasMany, basta aggiungere e rimuovere oggetti.

class Parent {
    static hasMany = [childs:Child]
}

USARE IL TIPO DI RELAZIONE:

Ma la raccolta potrebbe essere nulla solo quando viene dichiarata come proprietà (relazione di utilizzo) e non è inizializzata nella dichiarazione.

class Parent {
    List<Child> childs = []
}

Ho usato l'approccio @ user2709454 con un piccolo miglioramento.

public class User {
    private Set<Role> roles;

    public void setRoles(Set<Role> roles) {
        if (this.roles == null) {
            this.roles = roles;
        } else if(this.roles != roles) { // not the same instance, in other case we can get ConcurrentModificationException from hibernate AbstractPersistentCollection
            this.roles.clear();
            if(roles != null){
                this.roles.addAll(roles);
            }
        }
    }
}

Ho avuto questo problema durante il tentativo di utilizzo TreeSet. Ho fatto l'inizializzazione oneToManycon TreeSetcui funziona

@OneToMany(mappedBy = "question", fetch = FetchType.EAGER, cascade = { CascadeType.ALL }, orphanRemoval=true)
@OrderBy("id")
private Set<WizardAnswer> answers = new TreeSet<WizardAnswer>();

Ma questo porterà all'errore descritto questionsopra. Quindi sembra hibernatesupportato SortedSete se si cambia la riga sopra in

@OneToMany(mappedBy = "question", fetch = FetchType.EAGER, cascade = { CascadeType.ALL }, orphanRemoval=true)
@OrderBy("id")
private SortedSet<WizardAnswer> answers;

funziona come per magia :) maggiori informazioni su hibernate SortedSetpossono essere qui

L'unica volta che ottengo questo errore è quando provo a passare NULL nel setter per la raccolta. Per evitare ciò, i miei setter si presentano così:

public void setSubmittedForms(Set<SubmittedFormEntity> submittedForms) {
    if(submittedForms == null) {
        this.submittedForms.clear();
    }
    else {
        this.submittedForms = submittedForms;
    }
}

Mi sono imbattuto in questo durante l'aggiornamento di un'entità con una richiesta di post JSON. L'errore si è verificato quando ho aggiornato l'entità senza dati sui figli, anche se non ce n'erano. Aggiunta

"children": [],

al corpo della richiesta risolto il problema.

Un'altra causa potrebbe essere l'uso di lombok.

@Builder- fa risparmiare Collections.emptyList()anche se dici.myCollection(new ArrayList());

@Singular- ignora le impostazioni predefinite a livello di classe e lascia il campo nullanche se il campo della classe è stato dichiarato comemyCollection = new ArrayList()

I miei 2 centesimi, ho appena trascorso 2 ore con lo stesso :)

Stavo diventando A collection with cascade=”all-delete-orphan” was no longer referenced by the owning entity instancequando stavo preparando parent.setChildren(new ArrayList<>()). Quando sono passato a parent.getChildren().clear(), ho risolto il problema.

Verifica ulteriori dettagli: HibernateException - Una raccolta con cascade = "all-delete-orphan" non è più stata referenziata dall'istanza dell'entità proprietaria .

Sto utilizzando Spring Boot e ho riscontrato questo problema con una raccolta, nonostante non lo sovrascrissi direttamente, perché sto dichiarando un campo aggiuntivo per la stessa raccolta con un serializzatore e un deserializzatore personalizzati al fine di fornire una rappresentazione più intuitiva del dati:

  public List<Attribute> getAttributes() {
    return attributes;
  }

  public void setAttributes(List<Attribute> attributes) {
    this.attributes = attributes;
  }

  @JsonSerialize(using = AttributeSerializer.class)
  public List<Attribute> getAttributesList() {
    return attributes;
  }

  @JsonDeserialize(using = AttributeDeserializer.class)
  public void setAttributesList(List<Attribute> attributes) {
    this.attributes = attributes;
  }

Sembra che anche se non sto sovrascrivendo la collezione da solo , la deserializzazione lo fa sotto il cofano, innescando comunque questo problema. La soluzione era quella di cambiare il setter associato al deserializzatore in modo da cancellare l'elenco e aggiungere tutto, anziché sovrascriverlo:

  @JsonDeserialize(using = AttributeDeserializer.class)
  public void setAttributesList(List<Attribute> attributes) {
    this.attributes.clear();
    this.attributes.addAll(attributes);
  }

Ho avuto lo stesso problema, ma era quando il set era nullo. Trova solo nella raccolta Imposta in elenco. Puoi provare all'annotazione in ibernazione @LazyCollection (LazyCollectionOption.FALSE) istallata dell'annotazione JPA fetch = FetchType.EAGER.

La mia soluzione: questa è la mia configurazione e funziona benissimo

@OneToMany(mappedBy = "format", cascade = CascadeType.ALL, orphanRemoval = true)
@LazyCollection(LazyCollectionOption.FALSE)
private Set<Barcode> barcodes;

@OneToMany(mappedBy = "format", cascade = CascadeType.ALL, orphanRemoval = true)
@LazyCollection(LazyCollectionOption.FALSE)
private List<FormatAdditional> additionals;

@OneToMany(mappedBy = 'parent', cascade= CascadeType.ALL, orphanRemoval = true)
List<Child> children = new ArrayList<>();

Ho riscontrato lo stesso errore durante l'aggiunta di un oggetto figlio all'elenco esistente di oggetti figlio.

childService.saveOrUpdate(child);
parent.addToChildren(child);
parentService.saveOrUpdate(parent);

Ciò che ha risolto il mio problema sta cambiando in:

child = childService.saveOrUpdate(child);

Ora il bambino è rinato anche con altri dettagli e ha funzionato bene.

Aggiungendo la mia stupida risposta. Stiamo utilizzando Spring Data Rest. Questa era la nostra relazione piuttosto standard. Il modello è stato usato altrove.

//Parent class
@OneToMany(mappedBy = 'parent', 
           cascade= CascadeType.ALL, orphanRemoval = true)
@LazyCollection(LazyCollectionOption.FALSE)
List<Child> children = new LinkedList<>()


//Child class
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = 'ParentID', updatable = false)
@JsonBackReference
Parent parent

Con la relazione che abbiamo creato, era sempre inteso che i bambini sarebbero stati aggiunti attraverso il loro repository. Non avevo ancora aggiunto il repository. Il test di integrazione che abbiamo svolto stava attraversando un ciclo di vita completo dell'entità tramite chiamate REST in modo che le transazioni si chiudessero tra le richieste. Nessun repository per il bambino significava che JSON aveva i bambini come parte della struttura principale anziché all'interno _embedded. Gli aggiornamenti al genitore causerebbero quindi problemi.

La seguente soluzione ha funzionato per me

//Parent class
@OneToMany(mappedBy = 'parent', 
           cascade= CascadeType.ALL, orphanRemoval = true)
@OrderBy(value="ordinal ASC")
List<Child> children = new ArrayList<>()

//Updated setter of children 
public void setChildren(List<Children> children) {
    this.children.addAll(children);
    for (Children child: children)
        child.setParent(this);
}


//Child class
@ManyToOne
@JoinColumn(name="Parent_ID")
private Parent parent;

Invece di assegnare una nuova raccolta

public void setChildren(Set<ChildEntity> children) {
    this.children = children;
}

Sostituisci tutti gli elementi con

public void setChildren(Set<ChildEntity> children) {
    Collections.replaceAll(this.children,children);
}

stai attento con

BeanUtils.copyProperties(newInsum, insumOld,"code");

Anche questo metodo interrompe il letargo.

Potrebbe essere causato da hibernate-enhance-maven-plugin. Quando ho abilitato la enableLazyInitializationproprietà, questa eccezione ha iniziato a verificarsi nella mia collezione pigra. Sto usando l'ibernazione 5.2.17. Finale.

Nota questi due problemi di ibernazione:

• https://hibernate.atlassian.net/browse/HHH-10708
• https://hibernate.atlassian.net/browse/HHH-11459

Il mio era completamente diverso con Spring Boot! Per me non era dovuto all'impostazione della proprietà della raccolta.

Nei miei test stavo cercando di creare un'entità e stavo ottenendo questo errore per un'altra raccolta che non era stata utilizzata!

Dopo aver provato così tanto ho appena aggiunto un @Transactionalmetodo di prova e l'ho risolto. Non capisco però il motivo.

Questo è in contrasto con le risposte precedenti, ho avuto esattamente lo stesso errore: "Una raccolta con cascade =" all-delete-orphan "non era più referenziata ...." quando la mia funzione setter appariva così:

public void setTaxCalculationRules(Set<TaxCalculationRule> taxCalculationRules_) {
    if( this.taxCalculationRules == null ) {
        this.taxCalculationRules = taxCalculationRules_;
    } else {
        this.taxCalculationRules.retainAll(taxCalculationRules_);
        this.taxCalculationRules.addAll(taxCalculationRules_);
    }
}

E poi è scomparso quando l'ho cambiato alla versione semplice:

public void setTaxCalculationRules(Set<TaxCalculationRule> taxCalculationRules_) {
    this.taxCalculationRules = taxCalculationRules_;
}

(versioni di ibernazione - provato sia il 5.4.10 che il 4.3.11. Ho trascorso diversi giorni a provare ogni sorta di soluzione prima di tornare al semplice incarico nel setter. Ora confuso sul perché).