Hibernate Session get() vs load() verschil met voorbeelden

Hibernate-sessie biedt verschillende methoden om gegevens uit de database op te halen. Twee daarvan zijn – get() en load(). Er zijn ook veel overlappende methoden voor deze, die we in verschillende omstandigheden kunnen gebruiken. Op het eerste gezicht lijken zowel get() als load() op elkaar omdat ze beide gegevens uit de database halen, maar er zijn enkele verschillen tussen hen. Laten we ze bekijken aan de hand van een eenvoudig voorbeeld.

package com.journaldev.hibernate.main;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import com.journaldev.hibernate.model.Employee;
import com.journaldev.hibernate.util.HibernateUtil;

public class HibernateGetVsLoad {

	public static void main(String[] args) {
		
		// Voorbereidend werk
		SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
		Session session = sessionFactory.openSession();
		Transaction tx = session.beginTransaction();
		
		// Voorbeeld ophalen
		Employee emp = (Employee) session.get(Employee.class, new Long(2));
		System.out.println("Employee get called");
		System.out.println("Employee ID= "+emp.getId());
		System.out.println("Employee Get Details:: "+emp+"\n");
		
		// Voorbeeld laden
		Employee emp1 = (Employee) session.load(Employee.class, new Long(1));
		System.out.println("Employee load called");
		System.out.println("Employee ID= "+emp1.getId());
		System.out.println("Employee load Details:: "+emp1+"\n");
		
		// Sluit resources
		tx.commit();
		sessionFactory.close();
	}
}

Wanneer ik bovenstaande code uitvoer, wordt de volgende uitvoer gegenereerd.

Hibernate: select employee0_.emp_id as emp_id1_1_0_, employee0_.emp_name as emp_name2_1_0_, employee0_.emp_salary as emp_sala3_1_0_, address1_.emp_id as emp_id1_0_1_, address1_.address_line1 as address_2_0_1_, address1_.city as city3_0_1_, address1_.zipcode as zipcode4_0_1_ from EMPLOYEE employee0_ left outer join ADDRESS address1_ on employee0_.emp_id=address1_.emp_id where employee0_.emp_id=?
Employee get called
Employee ID= 2
Employee Get Details:: Id= 2, Name= David, Salary= 200.0, {Address= AddressLine1= Arques Ave, City=Santa Clara, Zipcode=95051}

Employee load called
Employee ID= 1
Hibernate: select employee0_.emp_id as emp_id1_1_0_, employee0_.emp_name as emp_name2_1_0_, employee0_.emp_salary as emp_sala3_1_0_, address1_.emp_id as emp_id1_0_1_, address1_.address_line1 as address_2_0_1_, address1_.city as city3_0_1_, address1_.zipcode as zipcode4_0_1_ from EMPLOYEE employee0_ left outer join ADDRESS address1_ on employee0_.emp_id=address1_.emp_id where employee0_.emp_id=?
Employee load Details:: Id= 1, Name= Pankaj, Salary= 100.0, {Address= AddressLine1= Albany Dr, City=San Jose, Zipcode=95129}

Uit de uitvoer is het duidelijk dat get() het object retourneert door het uit de database of uit de hibernate-cache te halen, terwijl load() alleen de verwijzing naar een object retourneert dat mogelijk niet daadwerkelijk bestaat. Het laadt de gegevens uit de database of cache pas wanneer u andere eigenschappen van het object benadert. Laten we nu proberen gegevens op te halen die niet in de database bestaan.

// Voorbeeld ophalen
try{
Employee emp = (Employee) session.get(Employee.class, new Long(200));
System.out.println("Employee get called");
if(emp != null){
System.out.println("Employee GET ID= "+emp.getId());
System.out.println("Employee Get Details:: "+emp+"\n");
}
}catch(Exception e){
	e.printStackTrace();
}

// Voorbeeld laden
try{
Employee emp1 = (Employee) session.load(Employee.class, new Long(100));
System.out.println("Employee load called");
System.out.println("Employee LOAD ID= "+emp1.getId());
System.out.println("Employee load Details:: "+emp1+"\n");
}catch(Exception e){
	e.printStackTrace();
}

De bovenstaande code produceert de volgende uitvoer.

Hibernate: select employee0_.emp_id as emp_id1_1_0_, employee0_.emp_name as emp_name2_1_0_, employee0_.emp_salary as emp_sala3_1_0_, address1_.emp_id as emp_id1_0_1_, address1_.address_line1 as address_2_0_1_, address1_.city as city3_0_1_, address1_.zipcode as zipcode4_0_1_ from EMPLOYEE employee0_ left outer join ADDRESS address1_ on employee0_.emp_id=address1_.emp_id where employee0_.emp_id=?
Employee get called
Employee load called
Employee LOAD ID= 100
Hibernate: select employee0_.emp_id as emp_id1_1_0_, employee0_.emp_name as emp_name2_1_0_, employee0_.emp_salary as emp_sala3_1_0_, address1_.emp_id as emp_id1_0_1_, address1_.address_line1 as address_2_0_1_, address1_.city as city3_0_1_, address1_.zipcode as zipcode4_0_1_ from EMPLOYEE employee0_ left outer join ADDRESS address1_ on employee0_.emp_id=address1_.emp_id where employee0_.emp_id=?
org.hibernate.ObjectNotFoundException: No row with the given identifier exists: [com.journaldev.hibernate.model.Employee#100]
	at org.hibernate.internal.SessionFactoryImpl$1$1.handleEntityNotFound(SessionFactoryImpl.java:253)
	at org.hibernate.proxy.AbstractLazyInitializer.checkTargetState(AbstractLazyInitializer.java:262)
	at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:176)
	at org.hibernate.proxy.AbstractLazyInitializer.getImplementation(AbstractLazyInitializer.java:286)
	at org.hibernate.proxy.pojo.javassist.JavassistLazyInitializer.invoke(JavassistLazyInitializer.java:185)
	at com.journaldev.hibernate.model.Employee_$$_jvst407_1.toString(Employee_$$_jvst407_1.java)
	at java.lang.String.valueOf(String.java:2847)
	at java.lang.StringBuilder.append(StringBuilder.java:128)
	at com.journaldev.hibernate.main.HibernateExample.main(HibernateExample.java:36)

Kijk goed naar de uitvoer, wanneer we get() gebruiken om gegevens op te halen die niet bestaan, retourneert het null. Dat is logisch omdat het probeert de gegevens te laden zodra het wordt aangeroepen. Met load() kunnen we de id afdrukken, maar zodra we proberen andere velden te benaderen, wordt er een databasequery uitgevoerd en wordt org.hibernate.ObjectNotFoundException gegenereerd als er geen record is gevonden met de opgegeven identificatie. Het is een specifieke Runtime Exception van Hibernate, dus we hoeven deze niet expliciet te vangen. Laten we ook eens kijken naar enkele van de overladingen. Bovenstaande get() en load() methoden hadden ook als volgt kunnen worden geschreven.

Employee emp = (Employee) session.get("com.journaldev.hibernate.model.Employee", new Long(2));

Employee emp1 = (Employee) session.load("com.journaldev.hibernate.model.Employee", new Long(1));

Employee emp2 = new Employee();
session.load(emp1, new Long(1));

Er zijn andere methoden met LockOptions-argument maar ik heb ze niet gebruikt. Let op dat we het volledige klassenaam als argument moeten doorgeven. Gebaseerd op de bovenstaande uitleg hebben we de volgende verschillen tussen get() vs load():

1. get() laadt de gegevens zodra het wordt aangeroepen terwijl load() een proxy-object retourneert en gegevens alleen laadt wanneer het daadwerkelijk nodig is, dus load() is beter omdat het lazy loading ondersteunt.
2. Aangezien load() een uitzondering gooit wanneer de gegevens niet zijn gevonden, moeten we het alleen gebruiken wanneer we weten dat de gegevens bestaan.
3. We moeten get() gebruiken wanneer we zeker willen zijn dat de gegevens in de database bestaan.

Dat is alles voor de Hibernate get- en load-methoden, ik hoop dat het enkele twijfels zal wegnemen en u zal helpen bij het beslissen welke te gebruiken in verschillende scenario’s.