Hibernate - Uma coleção com cascade = ”all-delete-orphan” não era mais referenciada pela instância da entidade proprietária

Estou com o seguinte problema ao tentar atualizar minha entidade:

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

Eu tenho uma entidade pai e ela tem uma Set<...>de algumas entidades filhas. Quando tento atualizá-lo, recebo todas as referências a serem configuradas para essas coleções e defini-lo.

O código a seguir representa meu mapeamento:

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

Tentei limpar apenas o Set <..>, de acordo com o seguinte: Como "possível" resolver o problema, mas não funcionou.

Se você tiver alguma idéia, entre em contato.

Obrigado!

Verifique todos os lugares onde você está atribuindo algo para sonEntities. O link que você referiu distintamente indica a criação de um novo HashSet, mas você pode ter esse erro sempre que redesignar o conjunto. Por exemplo:

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

Geralmente você deseja "novo" apenas o conjunto uma vez em um construtor. Sempre que você deseja adicionar ou excluir algo da lista, você deve modificar o conteúdo da lista em vez de atribuir uma nova lista.

Para adicionar filhos:

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

Para remover crianças:

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

O método:

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

funciona se o parentEntityestiver desanexado e novamente se o atualizarmos.
Porém, se a entidade não for desanexada por contexto, (ou seja, as operações de localização e atualização estão na mesma transação), o método abaixo funcionará.

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 li em vários lugares que o hibernate não gostaria que você atribuísse a uma coleção, presumi que a coisa mais segura a fazer seria obviamente torná-la final assim:

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

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

No entanto, isso não funciona, e você recebe o temido erro "não mais referenciado", o que é realmente bastante enganador neste caso.

Acontece que o hibernate chama seu método setRoles E deseja que sua classe de coleção especial seja instalada aqui e não aceita sua classe de coleção. Isso me deixou perplexo por muito tempo, apesar de ler todos os avisos sobre não atribuir à sua coleção no seu método definido.

Então eu mudei para isso:

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, na primeira chamada, o hibernate instale sua classe especial e, nas chamadas subsequentes, você possa usar o método sem destruir tudo. Se você quiser usar sua classe como um bean, provavelmente precisará de um levantador de trabalho, e isso pelo menos parece funcionar.

Na verdade, meu problema era sobre iguais e hashcode das minhas entidades. Um código legado pode trazer muitos problemas, nunca se esqueça de conferir. Tudo o que fiz foi apenas manter a estratégia de excluir órfãos e corrigir os iguais e o código de hash.

Eu tive o mesmo erro. O problema para mim foi que, depois de salvar a entidade, a coleção mapeada ainda era nula e, ao tentar atualizar a entidade, a exceção foi lançada. O que me ajudou: Salvar a entidade, fazer uma atualização (a coleção não é mais nula) e executar a atualização. Talvez inicializar a coleção com o novo ArrayList () ou algo possa ajudar também.

TEM TIPO DE RELAÇÃO:

Não tente instanciar a coleção quando ela estiver declarada hasMany, basta adicionar e remover objetos.

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

TIPO DE RELAÇÃO DE USO:

Mas a coleção pode ser nula somente quando é declarada como uma propriedade (relação de uso) e não é inicializada na declaração.

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

Eu usei a abordagem @ user2709454 com pequenas melhorias.

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

Eu tive esse problema ao tentar usar TreeSet. Eu inicializei oneToManycom o TreeSetque funciona

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

Mas, isso trará o erro descrito questionacima. Parece que é hibernatesuportado SortedSete se alguém mudar a linha acima para

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

funciona como mágica :) mais informações hibernate SortedSetpodem estar aqui

A única vez que recebo esse erro é quando tento passar NULL para o setter da coleção. Para evitar isso, meus setters ficam assim:

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

Eu me deparei com isso ao atualizar uma entidade com uma solicitação de postagem JSON. O erro ocorreu quando atualizei a entidade sem dados sobre os filhos, mesmo quando não havia nenhum. Adicionando

"children": [],

ao organismo da solicitação resolveu o problema.

Uma outra causa pode estar usando o lombok.

@Builder- causas para salvar, Collections.emptyList()mesmo se você disser.myCollection(new ArrayList());

@Singular - ignora os padrões no nível da classe e deixa o campo null mesmo que o campo da classe tenha sido declarado comomyCollection = new ArrayList()

Meus 2 centavos, apenas passei 2 horas com o mesmo :)

Eu estava pegando A collection with cascade=”all-delete-orphan” was no longer referenced by the owning entity instancequando estava sentado parent.setChildren(new ArrayList<>()). Quando mudei paraparent.getChildren().clear() , ele resolveu o problema.

Verifique para obter mais detalhes: HibernateException - Uma coleção com cascade = "all-delete-orphan" não era mais referenciada pela instância da entidade proprietária .

Estou usando o Spring Boot e tive esse problema com uma coleção, apesar de não a sobrescrever diretamente, porque estou declarando um campo extra para a mesma coleção com um serializador e desserializador personalizado , a fim de fornecer uma representação mais amigável ao front-end do dados:

  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 mesmo que eu não estou substituindo a coleção mim mesmo , a desserialização faz isso sob o capô, provocando esta questão tudo a mesma coisa. A solução foi alterar o setter associado ao desserializador para limpar a lista e adicionar tudo, em vez de substituí-lo:

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

Eu tive o mesmo problema, mas foi quando o conjunto foi nulo. Somente na coleção Definir na lista de trabalho encontra. Você pode tentar a anotação de hibernação @LazyCollection (LazyCollectionOption.FALSE) instalada na anotação de JPA fetch = FetchType.EAGER.

Minha solução: esta é minha configuração e funciona bem

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

Ocorreu o mesmo erro ao adicionar o objeto filho à lista existente de objetos filho.

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

O que resolveu meu problema está mudando para:

child = childService.saveOrUpdate(child);

Agora a criança também revive com outros detalhes e funcionou bem.

Adicionando minha resposta idiota. Estamos usando o Spring Data Rest. Esse era o nosso relacionamento bastante padrão. O padrão foi usado em outro 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

Com o relacionamento que criamos, sempre se pretendeu que as crianças fossem adicionadas através de seu próprio repositório. Eu ainda não tinha adicionado o repositório. O teste de integração que tínhamos estava passando por um ciclo de vida completo da entidade por meio de chamadas REST, para que as transações fossem fechadas entre solicitações. Nenhum repo para a criança significava que o json tinha os filhos como parte da estrutura principal em vez de dentro _embedded. Atualizações para o pai causariam problemas.

A seguinte solução funcionou para mim

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

Em vez de atribuir nova coleção

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

Substitua todos os elementos por

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

tenha cuidado com

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

Este método também interrompe a hibernação.

Pode ser causado por hibernate-enhance-maven-plugin. Quando eu ativeienableLazyInitialization propriedade, essa exceção começou a acontecer na minha coleção lenta. Estou usando o hibernate 5.2.17.Final.

Observe estes dois problemas de hibernação:

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

O meu era completamente diferente com o Spring Boot! Para mim, não foi devido à configuração da propriedade de coleção.

Nos meus testes, eu estava tentando criar uma entidade e estava recebendo esse erro para outra coleção que não era usada!

Depois de tanto tentar, acabei de adicionar um @Transactionalno método de teste e ele o resolveu. Não, não a razão embora.

Isso contrasta com as respostas anteriores, eu tive exatamente o mesmo erro: "Uma coleção com cascade =” all-delete-órphan ”não era mais referenciada ...." quando minha função setter ficou assim:

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

E então desapareceu quando eu mudei para a versão simples:

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

(versões de hibernação - tentei 5.4.10 e 4.3.11. Passei vários dias tentando todos os tipos de soluções antes de retornar à tarefa simples no setter. Confuso agora sobre o motivo disso.)