Qual è la differenza tra JOIN e JOIN FETCH quando si utilizza JPA e Hibernate

Aiutami a capire dove utilizzare un JOIN regolare e dove un JOIN FETCH.

Ad esempio, se abbiamo queste due query

FROM Employee emp
JOIN emp.department dep

e

FROM Employee emp
JOIN FETCH emp.department dep

C'è qualche differenza tra loro? Se sì, quale usare quando?

In queste due query, si utilizza JOIN per interrogare tutti i dipendenti a cui è associato almeno un reparto.

Ma la differenza è: nella prima query stai restituendo solo i Dipendenti per l'ibernazione. Nella seconda query, si restituiscono i dipendenti e tutti i dipartimenti associati.

Pertanto, se si utilizza la seconda query, non sarà necessario eseguire una nuova query per accedere nuovamente al database per visualizzare i reparti di ciascun dipendente.

È possibile utilizzare la seconda query quando si è certi di aver bisogno del dipartimento di ciascun dipendente. Se non è necessario il dipartimento, utilizzare la prima query.

Consiglio di leggere questo link se è necessario applicare alcune condizioni WHERE (ciò di cui probabilmente avrete bisogno): Come esprimere correttamente JPQL "join fetch" con la clausola "where" come CriteriaQuery JPA 2?

Aggiornare

Se non si utilizza fetche i Reparti continuano a essere restituiti, è perché la mappatura tra Dipendente e Dipartimento (a @OneToMany) è regolata FetchType.EAGER. In questo caso, qualsiasi fetchquery HQL (con o meno) con FROM Employeeporterà tutti i Dipartimenti. Ricorda che tutti i mapping * ToOne ( @ManyToOnee @OneToOne) sono EAGER per impostazione predefinita.

in questo link che ho menzionato prima nel commento, leggi questa parte:

Un join "fetch" consente l'inizializzazione di associazioni o raccolte di valori insieme ai loro oggetti padre utilizzando una sola selezione. Ciò è particolarmente utile nel caso di una collezione. Sovrascrive efficacemente il join esterno e le dichiarazioni pigre del file di mapping per associazioni e raccolte.

questo "JOIN FETCH" avrà effetto se si dispone della proprietà (fetch = FetchType.LAZY) per una raccolta all'interno di un'entità (esempio sotto).

Ed è solo effetto del metodo di "quando la query dovrebbe accadere". E devi anche sapere questo :

l'ibernazione ha due nozioni ortogonali: quando viene recuperata l'associazione e come viene recuperata. È importante non confonderli. Usiamo il recupero per ottimizzare le prestazioni. Possiamo usare lazy per definire un contratto per quali dati sono sempre disponibili in qualsiasi istanza distaccata di una particolare classe.

quando viene recuperata l'associazione -> il tuo tipo "FETCH"

come viene recuperato -> Unisci / seleziona / Sottoseleziona / Batch

Nel tuo caso, FETCH avrà effetto solo se hai un dipartimento come set all'interno del Dipendente, qualcosa del genere nell'entità:

@OneToMany(fetch = FetchType.LAZY)
private Set<Department> department;

quando usi

FROM Employee emp
JOIN FETCH emp.department dep

otterrai empe emp.dep. quando non hai usato il recupero puoi ancora ottenere emp.depma l'ibernazione elaborerà un'altra selezione nel database per ottenere quel set di dipartimenti.

quindi è solo una questione di ottimizzazione delle prestazioni, su di te che vuoi ottenere tutti i risultati (ne hai bisogno o no) in una singola query (recupero desideroso), o vuoi interrogarlo successivamente quando ne hai bisogno (recupero pigro).

Usa il recupero desideroso quando devi ottenere piccoli dati con una selezione (una query grande). Oppure usa il recupero pigro per interrogare ciò di cui hai bisogno in seguito (molte query più piccole).

usa recupera quando:

• nessuna grande raccolta / set non necessari all'interno di quell'entità che stai per ottenere

• la comunicazione dal server delle applicazioni al server di database è troppo lunga e richiede molto tempo

• potresti aver bisogno di quest'ultima raccolta quando non hai accesso ad essa ( al di fuori del metodo / classe transazionale )

ADERIRE

Quando si utilizza JOINcontro associazioni di entità, JPA genererà un JOIN tra l'entità padre e le tabelle entità figlio nell'istruzione SQL generata.

Quindi, prendendo il tuo esempio, quando esegui questa query JPQL:

FROM Employee emp
JOIN emp.department dep

Hibernate genererà la seguente istruzione SQL:

SELECT emp.*
FROM employee emp
JOIN department dep ON emp.department_id = dep.id

Si noti che la SELECTclausola SQL contiene solo le employeecolonne della tabella e non departmentquelle. Per recuperare le departmentcolonne della tabella, è necessario utilizzare JOIN FETCHinvece di JOIN.

UNISCITI FETCH

Pertanto, rispetto a JOIN, JOIN FETCHconsente di proiettare le colonne della tabella di join nella SELECTclausola dell'istruzione SQL generata.

Quindi, nel tuo esempio, quando esegui questa query JPQL:

FROM Employee emp
JOIN FETCH emp.department dep

Hibernate genererà la seguente istruzione SQL:

SELECT emp.*, dept.*
FROM employee emp
JOIN department dep ON emp.department_id = dep.id

Si noti che, questa volta, departmentvengono selezionate anche le colonne della tabella, non solo quelle associate all'entità elencata nella FROMclausola JPQL.

Inoltre, JOIN FETCHè un ottimo modo per affrontare LazyInitializationExceptionquando si utilizza Hibernate in quanto è possibile inizializzare le associazioni di entità utilizzando la FetchType.LAZYstrategia di recupero insieme all'entità principale che si sta recuperando.

Se la @oneToOnemappatura è impostata su FetchType.LAZYe si utilizza la seconda query (poiché è necessario caricare gli oggetti Department come parte degli oggetti Employee), ciò che Hibernate farà, invierà query per recuperare gli oggetti Department per ogni singolo oggetto Employee che recupera dal DB.

Successivamente, nel codice è possibile accedere agli oggetti Dipartimento tramite l'associazione a valore singolo da Dipendente a Dipartimento e Hibernate non invierà alcuna query per recuperare l'oggetto Dipartimento per il Dipendente specificato.

Ricorda, Hibernate emette comunque query pari al numero di dipendenti che ha recuperato. Hibernate emetterà lo stesso numero di query in entrambe le query precedenti, se si desidera accedere agli oggetti Reparto di tutti gli oggetti Dipendente

Dherik: Non sono sicuro di quello che dici, quando non usi il recupero il risultato sarà di tipo: il List<Object[ ]>che significa un elenco di tabelle di oggetti e non un elenco di Employee.

Object[0] refers an Employee entity 
Object[1] refers a Departement entity 

Quando si utilizza il recupero, è disponibile una sola selezione e il risultato è l'elenco dei Dipendenti List<Employee>contenente l'elenco dei dipartimenti. Sostituisce la dichiarazione pigra dell'entità.