Hibernate: la instancia de la entidad propietaria ya no hace referencia a una colección con cascade = "all-delete-huérfano"

Tengo el siguiente problema al intentar actualizar mi entidad:

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

Tengo una entidad principal y tiene una Set<...>de algunas entidades secundarias. Cuando intento actualizarlo, obtengo todas las referencias que se establecerán en estas colecciones y lo configuro.

El siguiente código representa mi mapeo:

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

He tratado de limpiar el Set <..> solamente, de acuerdo con esto: Cómo "posible" resolver el problema, pero no funcionó.

Si tiene alguna idea, hágamelo saber.

¡Gracias!

Verifique todos los lugares donde está asignando algo a sonEntities. El enlace al que hizo referencia señala claramente la creación de un nuevo HashSet, pero puede tener este error cada vez que reasigna el conjunto. Por ejemplo:

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

Por lo general, solo desea "nuevo" el conjunto una vez en un constructor. Cada vez que desee agregar o eliminar algo a la lista, debe modificar el contenido de la lista en lugar de asignar una nueva lista.

Para agregar niños:

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

Para eliminar niños:

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

El método:

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

funciona si parentEntityestá separado y nuevamente si lo actualizamos.
Pero si la entidad no está separada de cada contexto (es decir, las operaciones de búsqueda y actualización están en la misma transacción), el método siguiente funciona.

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

Cuando leí en varios lugares que a Hibernate no le gustaba que asignaras a una colección, supuse que lo más seguro sería, por supuesto, hacerla final así:

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

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

Sin embargo, esto no funciona, y obtiene el temido error "ya no se hace referencia", que en realidad es bastante engañoso en este caso.

Resulta que hibernate llama a su método setRoles Y quiere que su clase de colección especial esté instalada aquí, y no aceptará su clase de colección. Esto me dejó perplejo por MUCHO tiempo, a pesar de leer todas las advertencias sobre no asignar a su colección en su método establecido.

Entonces cambié a esto:

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

Para que en la primera llamada, hibernate instale su clase especial, y en las llamadas posteriores puede usar el método usted mismo sin destruir todo. Si desea utilizar su clase como un bean, probablemente necesite un setter que funcione, y esto al menos parece funcionar.

En realidad, mi problema era sobre iguales y hashcode de mis entidades. Un código heredado puede traer muchos problemas, nunca olvides revisarlo. Todo lo que hice fue mantener la estrategia de borrar huérfanos y corregir los iguales y el código hash.

Yo tenía el mismo error. El problema para mí era que, después de guardar la entidad, la colección asignada seguía siendo nula y cuando intentaba actualizar la entidad se generaba la excepción. Lo que me ayudó: Guardar la entidad, luego hacer una actualización (la colección ya no es nula) y luego realizar la actualización. Tal vez inicializar la colección con el nuevo ArrayList () o algo podría ayudar también.

TIENE TIPO DE RELACIÓN:

No intentes crear una instancia de la colección cuando esté declarada hasMany, solo agrega y elimina objetos.

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

TIPO DE RELACIÓN DE USO:

Pero la colección podría ser nula solo cuando se declara como una propiedad (relación de uso) y no se inicializa en la declaración.

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

Utilicé el enfoque @ user2709454 con una pequeña mejora.

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

Tuve este problema al intentar usar TreeSet. Inicialicé oneToManycon TreeSetqué obras

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

Pero, esto traerá el error descrito en lo questionanterior. Entonces parece que es hibernatecompatible SortedSety si uno solo cambia la línea de arriba a

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

funciona como magia :) más información sobre hibernate SortedSetpuede estar aquí

La única vez que recibo este error es cuando intento pasar NULL al setter para la colección. Para evitar esto, mis setters se ven así:

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

Me encontré con esto al actualizar una entidad con una solicitud de publicación JSON. El error ocurrió cuando actualicé la entidad sin datos sobre los hijos, incluso cuando no había ninguno. Agregando

"children": [],

El cuerpo de la solicitud resolvió el problema.

Otra causa puede estar usando lombok.

@Builder- hace que se guarde Collections.emptyList()incluso si dices.myCollection(new ArrayList());

@Singular- ignora los valores predeterminados de nivel de clase y deja el campo nullincluso si el campo de clase se declaró comomyCollection = new ArrayList()

Mis 2 centavos, solo pasé 2 horas con lo mismo :)

Me estaba poniendo A collection with cascade=”all-delete-orphan” was no longer referenced by the owning entity instancecuando estaba configurando parent.setChildren(new ArrayList<>()). Cuando cambié a parent.getChildren().clear(), resolvió el problema.

Verifique para más detalles: HibernateException - La colección propietaria ya no hizo referencia a una colección con cascade = "all-delete-huérfano" .

Estoy usando Spring Boot y tuve este problema con una colección, a pesar de no sobrescribirlo directamente, porque estoy declarando un campo adicional para la misma colección con un serializador y deserializador personalizado para proporcionar una representación más amigable de la interfaz. datos:

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

Parece que aunque no estoy sobrescribiendo la colección yo mismo , la deserialización lo hace bajo el capó, desencadenando este problema de todos modos. La solución fue cambiar el setter asociado con el deserializador para que borre la lista y agregue todo, en lugar de sobrescribirlo:

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

Tuve el mismo problema, pero fue cuando el conjunto era nulo. Solo en la colección Establecer en el trabajo de búsqueda de lista. Puede intentar la anotación de hibernación @LazyCollection (LazyCollectionOption.FALSE) en lugar de la anotación JPA fetch = FetchType.EAGER.

Mi solución: esta es mi configuración y funciona bien

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

Experimenté el mismo error cuando estaba agregando objetos secundarios a la lista existente de objetos secundarios.

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

Lo que resolvió mi problema está cambiando a:

child = childService.saveOrUpdate(child);

Ahora el niño también revive con otros detalles y funcionó bien.

Agregando mi tonta respuesta. Estamos usando Spring Data Rest. Esta fue nuestra relación bastante estándar. El patrón se usó en otro lugar.

//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 relación que creamos, siempre se pretendía que los niños se agregaran a través de su propio repositorio. Todavía no había agregado el repositorio. La prueba de integración que tuvimos fue a través de un ciclo de vida completo de la entidad a través de llamadas REST para que las transacciones se cerraran entre las solicitudes. Ningún repositorio para el niño significaba que el json tenía a los niños como parte de la estructura principal en lugar de dentro _embedded. Las actualizaciones a los padres causarían problemas.

La siguiente solución funcionó para mí

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

En lugar de asignar una nueva colección

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

Reemplace todos los elementos con

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

ten cuidado con

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

Este método también rompe la hibernación.

Puede ser causado por hibernate-enhance-maven-plugin. Cuando habilité la enableLazyInitializationpropiedad, esta excepción comenzó a suceder en mi colección perezosa. Estoy usando hibernate 5.2.17.Final.

Tenga en cuenta estos dos problemas de hibernación:

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

¡El mío fue completamente diferente con Spring Boot! Para mí no se debió a la configuración de la propiedad de colección.

¡En mis pruebas estaba tratando de crear una entidad y estaba recibiendo este error para otra colección que no se usó!

Después de tanto intentarlo, simplemente agregué un @Transactionalmétodo de prueba y lo resolvió. Sin embargo, no la razón.

Esto está en contraste con las respuestas anteriores, tuve exactamente el mismo error: "Una colección con cascade =" all-delete-huérfano "ya no estaba referenciada ..." cuando mi función de configuración se veía así:

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

Y luego desapareció cuando lo cambié a la versión simple:

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

(versiones de hibernación: probé 5.4.10 y 4.3.11. Pasé varios días probando todo tipo de soluciones antes de volver a la tarea simple en el setter. Ahora estoy confundido sobre por qué esto es así).