In che modo JPA orphanRemoval = true differisce dalla clausola DML ON DELETE CASCADE

Sono un po 'confuso sull'attributo JPA 2.0 orphanRemoval.

Penso di poter vedere che è necessario quando uso gli strumenti di generazione DB del mio provider JPA per creare il database DDL sottostante per avere una ON DELETE CASCADErelazione specifica.

Tuttavia, se il DB esiste e ha già una ON DELETE CASCADErelazione, questo non è sufficiente per eliminare in modo appropriato la cancellazione? Cosa fa orphanRemovalin aggiunta?

Saluti

orphanRemovalnon ha niente a che fare con ON DELETE CASCADE.

orphanRemovalè una cosa completamente specifica per ORM . Contrassegna l'entità "figlio" da rimuovere quando non fa più riferimento all'entità "padre", ad esempio quando si rimuove l'entità figlio dalla raccolta corrispondente dell'entità padre.

ON DELETE CASCADEè una cosa specifica del database , elimina la riga "figlio" nel database quando viene eliminata la riga "padre".

Un esempio preso qui :

Quando un Employeeoggetto entità viene rimosso, l'operazione di rimozione viene messa in cascata Addresssull'oggetto entità referenziato . A questo proposito, orphanRemoval=truee cascade=CascadeType.REMOVEsono identici, e se orphanRemoval=trueè specificato, CascadeType.REMOVEè ridondante.

La differenza tra le due impostazioni sta nella risposta alla disconnessione di una relazione. Ad esempio, ad esempio quando si imposta il campo dell'indirizzo su nullo su un altro Addressoggetto.

• Se orphanRemoval=trueviene specificato, l' Addressistanza disconnessa viene automaticamente rimossa. Ciò è utile per ripulire oggetti dipendenti (ad es. Address) Che non dovrebbero esistere senza un riferimento da un oggetto proprietario (ad es Employee.).

• Se cascade=CascadeType.REMOVEviene specificato solo , non viene intrapresa alcuna azione automatica poiché la disconnessione di una relazione non è un'operazione di rimozione.

Per evitare riferimenti penzolanti a seguito della rimozione orfana, questa funzione deve essere abilitata solo per i campi che contengono oggetti dipendenti privati ​​non condivisi.

Spero che questo renda più chiaro.

Nel momento in cui rimuovi un'entità figlio dalla raccolta, rimuoverai anche quell'entità figlio dal DB. orphanRemoval implica anche che non puoi cambiare i genitori; se c'è un reparto che ha dipendenti, una volta rimosso quell'impiegato per inserirlo in un altro reparto, sarà inavvertitamente rimosso quell'impiegato dal DB in flush / commit (che viene prima). Il morale è di impostare OrphanRemoval su true fintanto che si è certi che i figli di quel genitore non migreranno verso un altro genitore durante la loro esistenza. L'attivazione di orphanRemoval aggiunge automaticamente RIMUOVI all'elenco a cascata.

La mappatura JPA equivalente per DDL ON DELETE CASCADEè cascade=CascadeType.REMOVE. Rimozione orfana significa che le entità dipendenti vengono rimosse quando viene distrutta la relazione con la loro entità "genitore". Ad esempio, se un figlio viene rimosso da una @OneToManyrelazione senza rimuoverla esplicitamente nel gestore entità.

La differenza è:
- orphanRemoval = true: l'entità "figlio" viene rimossa quando non è più referenziata (il suo genitore potrebbe non essere rimosso).
- CascadeType.REMOVE: l'entità "Child" viene rimossa solo quando viene rimosso il suo "Parent".

Poiché questa è una domanda molto comune, ho scritto questo articolo , su cui si basa questa risposta.

Transizioni dello stato delle entità

JPA traduce le transizioni dello stato dell'entità in istruzioni SQL, come INSERT, UPDATE o DELETE.

Quando si è persistun'entità, si sta pianificando che l'istruzione INSERT venga eseguita quando EntityManagerviene scaricata, automaticamente o manualmente.

quando sei removeun'entità, stai pianificando l'istruzione DELETE, che verrà eseguita quando il Contesto di persistenza viene svuotato.

Transizioni di stato entità a cascata

Per comodità, JPA consente di propagare le transizioni di stato delle entità da entità padre a quella figlio.

Pertanto, se si dispone di Postun'entità padre che ha @OneToManyun'associazione con l' PostCommententità figlio:

La commentsraccolta Postnell'entità è mappata come segue:

@OneToMany(
    mappedBy = "post", 
    cascade = CascadeType.ALL,
    orphanRemoval = true
)
private List<Comment> comments = new ArrayList<>();

CascadeType.ALL

L' cascadeattributo indica al provider JPA di passare la transizione dello stato dell'entità Postdall'entità padre a tutte le PostCommententità contenute incomments raccolta.

Quindi, se rimuovi l' Postentità:

Post post = entityManager.find(Post.class, 1L);
assertEquals(2, post.getComments().size());

entityManager.remove(post);

Il provider JPA rimuoverà PostCommentprima l' entità e quando tutte le entità figlio verranno eliminate, eliminerà anche l' Postentità:

DELETE FROM post_comment WHERE id = 1
DELETE FROM post_comment WHERE id = 2

DELETE FROM post WHERE id = 1

Rimozione orfana

Quando si imposta l' orphanRemovalattributo su true, il provider JPA pianificherà removeun'operazione quando l'entità figlio viene rimossa dalla raccolta.

Quindi, nel nostro caso,

Post post = entityManager.find(Post.class, 1L);
assertEquals(2, post.getComments().size());

PostComment postComment = post.getComments().get(0);
assertEquals(1L, postComment.getId());

post.getComments().remove(postComment);

Il provider JPA rimuoverà il post_commentrecord associato poiché l' PostCommententità non fa più riferimento nella commentsraccolta:

DELETE FROM post_comment WHERE id = 1

ALLA CANCELLAZIONE DELLA CASCATA

Il ON DELETE CASCADEè definito a livello FK:

ALTER TABLE post_comment 
ADD CONSTRAINT fk_post_comment_post_id 
FOREIGN KEY (post_id) REFERENCES post 
ON DELETE CASCADE;

Una volta che lo fai, se elimini una postriga:

DELETE FROM post WHERE id = 1

Tutte le post_commententità associate vengono rimosse automaticamente dal motore di database. Tuttavia, questa operazione può essere molto pericolosa se si elimina un'entità radice per errore.

Conclusione

Il vantaggio dell'APP cascadee delle orphanRemovalopzioni è che puoi anche trarre vantaggio dal blocco ottimistico per evitare la perdita di aggiornamenti .

Se si utilizza il meccanismo a cascata JPA, non è necessario utilizzare il livello DDL ON DELETE CASCADE, che può essere un'operazione molto pericolosa se si rimuove un'entità radice che ha molte entità figlio su più livelli.

Per maggiori dettagli su questo argomento, consulta questo articolo .

@GaryK risposta è assolutamente grande, ho passato un'ora alla ricerca di una spiegazione orphanRemoval = truevs CascadeType.REMOVEe mi ha aiutato a capire.

Riassumendo: orphanRemoval = truefunziona come CascadeType.REMOVE SOLO SE stiamo cancellando object ( entityManager.delete(object)) e vogliamo che anche gli oggetti child vengano rimossi.

In siti completamente diversi, quando recuperiamo alcuni dati come List<Child> childs = object.getChilds()e quindi rimuoviamo un figlio ( entityManager.remove(childs.get(0)) usando orphanRemoval=true, quell'entità corrispondente childs.get(0)verrà eliminata dal database.

la rimozione orfana ha lo stesso effetto di ON DELETE CASCADE nel seguente scenario: - Diciamo che abbiamo una semplice relazione molti-a-uno tra un'entità studentesca e un'entità guida, dove molti studenti possono essere mappati sulla stessa guida e nel database abbiamo un relazione chiave esterna tra la tabella Student e Guide in modo tale che la tabella student abbia id_guide come FK.

    @Entity
    @Table(name = "student", catalog = "helloworld")
    public class Student implements java.io.Serializable {
     @Id
     @GeneratedValue(strategy = IDENTITY)
     @Column(name = "id")
     private Integer id;

    @ManyToOne(cascade={CascadeType.PERSIST,CascadeType.REMOVE})
    @JoinColumn(name = "id_guide")
    private Guide guide;

// L'entità padre

    @Entity
    @Table(name = "guide", catalog = "helloworld")
    public class Guide implements java.io.Serializable {

/**
 * 
 */
private static final long serialVersionUID = 9017118664546491038L;

@Id
@GeneratedValue(strategy = IDENTITY)
@Column(name = "id", unique = true, nullable = false)
private Integer id;

@Column(name = "name", length = 45)
private String name;

@Column(name = "salary", length = 45)
private String salary;


 @OneToMany(mappedBy = "guide", orphanRemoval=true) 
 private Set<Student> students = new  HashSet<Student>(0);

In questo scenario, la relazione è tale che l'entità studente è il proprietario della relazione e come tale dobbiamo salvare l'entità studente per mantenere l'intero grafico dell'oggetto, ad es.

    Guide guide = new Guide("John", "$1500");
    Student s1 = new Student(guide, "Roy","ECE");
    Student s2 = new Student(guide, "Nick", "ECE");
    em.persist(s1);
    em.persist(s2);

Qui stiamo mappando la stessa guida con due diversi oggetti studente e poiché viene utilizzato CASCADE.PERSIST, il grafico degli oggetti verrà salvato come di seguito nella tabella del database (MySql nel mio caso)

Tavolo STUDENT: -

ID nome Dipartimento Id_Guide

1 Roy ECE 1

2 Nick ECE 1

Tabella GUIDA: -

ID NOME Stipendio

1 Giovanni $ 1500

e ora se voglio rimuovere uno degli studenti, usando

      Student student1 = em.find(Student.class,1);
      em.remove(student1);

e quando viene rimosso un record dello studente, deve essere rimosso anche il record della guida corrispondente, è qui che viene visualizzato l'attributo CASCADE.REMOVE nell'entità Studente e ciò che fa; rimuove lo studente con l'identificatore 1 e l'oggetto guida corrispondente (identificatore 1). Ma in questo esempio, esiste un altro oggetto studente mappato allo stesso record della guida e, a meno che non utilizziamo l' attributo orphanRemoval = true nell'entità guida, il codice di rimozione sopra non funzionerà.