Unterschied zwischen Hibernate Session get() und load() mit Beispielen

Hibernate-Sitzung bietet verschiedene Methoden zum Abrufen von Daten aus der Datenbank an. Zwei davon sind – get() und load(). Es gibt auch viele überladene Methoden dafür, die wir in verschiedenen Situationen verwenden können. Auf den ersten Blick scheinen sowohl get() als auch load() ähnlich zu sein, weil sie beide die Daten aus der Datenbank abrufen. Es gibt jedoch einige Unterschiede zwischen ihnen, lassen Sie uns sie anhand eines einfachen Beispiels betrachten.

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) {
		
		// Vorbereitungsarbeiten 
		SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
		Session session = sessionFactory.openSession();
		Transaction tx = session.beginTransaction();
		
		// Beispiel für get 
		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");
		
		// Beispiel für load 
		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");
		
		// Ressourcen schließen 
		tx.commit();
		sessionFactory.close();
	}
}

Wenn ich den obigen Code ausführe, erzeugt er folgende Ausgabe.

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}

Aus der Ausgabe ist klar, dass get() das Objekt zurückgibt, indem es es aus der Datenbank oder dem Hibernate-Cache abruft, während load() lediglich die Referenz auf ein Objekt zurückgibt, das möglicherweise nicht tatsächlich existiert. Es lädt die Daten aus der Datenbank oder dem Cache nur, wenn Sie auf andere Eigenschaften des Objekts zugreifen. Lassen Sie uns nun versuchen, Daten abzurufen, die nicht in der Datenbank vorhanden sind.

// Beispiel für get 
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();
}

// Beispiel für load 
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();
}

Der obige Code erzeugt folgende Ausgabe.

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)

Schau dir die Ausgabe genau an. Wenn wir get() verwenden, um Daten abzurufen, die nicht vorhanden sind, gibt es null zurück. Das macht Sinn, weil es versucht, die Daten sofort zu laden, wenn sie aufgerufen werden. Mit load() können wir die ID drucken, aber sobald wir versuchen, auf andere Felder zuzugreifen, wird eine Datenbankabfrage ausgelöst und es wird eine org.hibernate.ObjectNotFoundException geworfen, wenn kein Datensatz mit der angegebenen Kennung gefunden wird. Es handelt sich um eine hibernatespezifische Laufzeit-Ausnahme, daher müssen wir sie nicht explizit abfangen. Schauen wir uns auch einige der überladenen Methoden an. Die oben genannten get() und load()-Methoden könnten auch wie folgt geschrieben worden sein.

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

Es gibt andere Methoden mit dem Argument LockOptions, aber ich habe sie nicht verwendet. Beachten Sie, dass wir den vollständigen Klassennamen als Argument übergeben müssen. Basierend auf den obigen Erklärungen haben wir folgende Unterschiede zwischen get() vs load():

1. get() lädt die Daten sofort, wenn sie aufgerufen werden, während load() ein Proxy-Objekt zurückgibt und die Daten nur lädt, wenn es tatsächlich erforderlich ist, daher ist load() besser, weil es Lazy Loading unterstützt.
2. Da load() eine Ausnahme wirft, wenn Daten nicht gefunden werden, sollten wir es nur verwenden, wenn wir wissen, dass die Daten vorhanden sind.
3. Wir sollten get() verwenden, wenn wir sicherstellen wollen, dass Daten in der Datenbank vorhanden sind.

Das ist alles zu den Hibernate-Methoden get() und load(). Ich hoffe, das klärt einige Zweifel und hilft Ihnen dabei zu entscheiden, welche in verschiedenen Szenarien zu verwenden.