Hibernate Caching – Eerste Niveau Cache

Welkom bij de Hibernate Caching – Eerste niveau Caché Voorbeeld Tutorial. Onlangs hebben we gekeken naar de Hibernate-architectuur, hibernate-mapping en hoe HQL te gebruiken voor het uitvoeren van SQL-query’s op een objectgeoriënteerde manier. Vandaag zullen we een van de belangrijke aspecten van Hibernate bekijken – Hibernate Caché.

Hibernate Caching

Hibernate Cache kan zeer nuttig zijn om een snelle applicatieprestatie te bereiken als het correct wordt gebruikt. Het idee achter de cache is om het aantal databasequery’s te verminderen, waardoor de doorvoertijd van de applicatie wordt verminderd. Hibernate wordt geleverd met verschillende soorten Caché:

1. Eerste Niveau Cache: De Hibernate eerste niveau cache is geassocieerd met het Session-object. De eerste niveau cache van Hibernate is standaard ingeschakeld en er is geen manier om het uit te schakelen. Hibernate biedt echter methoden waarmee we geselecteerde objecten uit de cache kunnen verwijderen of de cache volledig kunnen wissen. Elk object dat is gecachet in een sessie zal niet zichtbaar zijn voor andere sessies en wanneer de sessie wordt gesloten, zullen alle gecachte objecten ook verloren gaan.
2. Tweede Niveau Cache: Hibernate Tweede Niveau Cache is standaard uitgeschakeld, maar we kunnen het inschakelen via configuratie. Momenteel bieden EHCache en Infinispan implementaties voor de Hibernate tweede niveau cache en we kunnen ze gebruiken. We zullen hier verder op ingaan in de volgende tutorial over Hibernate-caching.
3. Query Cache: Hibernate kan ook het resultaatset van een query cachen. Hibernate Query Cache cacht niet de status van de feitelijke entiteiten in de cache; het cacht alleen identiteitswaarden en resultaten van het waarde type. Het moet dus altijd worden gebruikt in combinatie met de tweede niveau cache.

Hibernate Caching – Voorbeeld Eerste Niveau Cache

Voor mijn voorbeeldprogramma van de eerste-niveau cache van Hibernate, gebruik ik dezelfde configuratie als in HQL Voorbeeld, je kunt dat bekijken en de tabellen configureren en ze vullen met dummygegevens. Laten we eerst naar het programma kijken, de uitvoer ervan en dan zullen we enkele belangrijke punten doornemen met betrekking tot de eerste-niveau cache van Hibernate. HibernateCacheVoorbeeld.java

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 HibernateCacheExample {

	public static void main(String[] args) throws InterruptedException {
		
		SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
		Session session = sessionFactory.getCurrentSession();
		Transaction tx = session.beginTransaction();
		
		//Haal werknemer op met id=1
		Employee emp = (Employee) session.load(Employee.class, new Long(1));
		printData(emp,1);
		
		//wacht even om de gegevens in de backend te wijzigen
		Thread.sleep(10000);
		
		//Haal dezelfde gegevens opnieuw op, controleer de logs dat er geen query is uitgevoerd
		Employee emp1 = (Employee) session.load(Employee.class, new Long(1));
		printData(emp1,2);
		
		//Maak nieuwe sessie aan
		Session newSession = sessionFactory.openSession();
		//Haal werknemer op met id=1, notice the logs for query
		Employee emp2 = (Employee) newSession.load(Employee.class, new Long(1));
		printData(emp2,3);
		
		//START: voorbeeld van wissen om een specifiek object uit de eerste-niveau cache van Hibernate te verwijderen
		//Haal werknemer op met id=2, eerste keer dus query in logs
		Employee emp3 = (Employee) session.load(Employee.class, new Long(2));
		printData(emp3,4);
		
		//wis het werknemerobject met id=1
		session.evict(emp);
		System.out.println("Session Contains Employee with id=1?"+session.contains(emp));

		//aangezien het object uit de eerste-niveau cache is verwijderd, zie je een query in de logs
		Employee emp4 = (Employee) session.load(Employee.class, new Long(1));
		printData(emp4,5);
		
		//dit object is nog steeds aanwezig, dus je ziet geen query in de logs
		Employee emp5 = (Employee) session.load(Employee.class, new Long(2));
		printData(emp5,6);
		//EINDE: voorbeeld van wissen
		
		//START: voorbeeld van wissen om alles uit de eerste-niveau cache te verwijderen
		session.clear();
		Employee emp6 = (Employee) session.load(Employee.class, new Long(1));
		printData(emp6,7);
		Employee emp7 = (Employee) session.load(Employee.class, new Long(2));
		printData(emp7,8);
		
		System.out.println("Session Contains Employee with id=2?"+session.contains(emp7));
		
		tx.commit();
		sessionFactory.close();
	}

	private static void printData(Employee emp, int count) {
		System.out.println(count+":: Name="+emp.getName()+", Zipcode="+emp.getAddress().getZipcode());
	}

}

Als we het bovenstaande voorbeeld uitvoeren, bevat de uitvoer veel informatie over Hibernate. Maar we zijn voornamelijk geïnteresseerd in de specifieke uitvoer van onze code en de door Hibernate uitgevoerde queries om de gegevens te laden. Het uitvoerfragment ziet er als volgt uit.

Hibernate Configuration loaded
Hibernate serviceRegistry created
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=?
1:: Name=Pankaj, Zipcode=95129
2:: Name=Pankaj, Zipcode=95129
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=?
3:: Name=PankajK, Zipcode=95129
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=?
4:: Name=David, Zipcode=95051
Session Contains Employee with id=1?false
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=?
5:: Name=Pankaj, Zipcode=95129
6:: Name=David, Zipcode=95051
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=?
7:: Name=Pankaj, Zipcode=95129
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=?
8:: Name=David, Zipcode=95051
Session Contains Employee with id=2?true

Eerste Niveau Cache in Hibernate Belangrijke Punten

Belangrijke punten over de eerste niveau cache in Hibernate die uit het bovenstaande programma kunnen worden afgeleid, zijn:

1. Hibernate Eerste Niveau cache is standaard ingeschakeld, er zijn geen configuraties nodig hiervoor.
2. Hibernate eerste niveau cache is sessiespecifiek, daarom wordt er geen query uitgevoerd wanneer we dezelfde gegevens in dezelfde sessie ophalen, terwijl er in een andere sessie wel een query wordt uitgevoerd om de gegevens te laden.
3. De Hibernate eerste niveau cache kan oude waarden bevatten, zoals hierboven te zien is, heb ik mijn programma 10 seconden op pauze gezet en in die tijd de waarde (naam van Pankaj naar PankajK) in de database bijgewerkt, maar het werd niet weerspiegeld in dezelfde sessie. Maar in een andere sessie kregen we de bijgewerkte waarde.
4. We kunnen de sessiemethode evict() gebruiken om een enkel object uit de Hibernate eerste niveau cache te verwijderen.
5. We kunnen de sessiemethode clear() gebruiken om de cache te wissen, dat wil zeggen alle objecten uit de cache te verwijderen.
6. We kunnen de sessiemethode contains() gebruiken om te controleren of een object aanwezig is in de Hibernate-cache of niet. Als het object in de cache wordt gevonden, geeft het true terug, anders geeft het false terug.
7. Aangezien Hibernate alle objecten in de sessie-eerste niveau cache opslaat, is het bij het uitvoeren van bulkquery’s of batchupdates noodzakelijk om de cache op bepaalde intervallen te wissen om geheugenproblemen te voorkomen.

Dat is alles voor hibernate caching en eerste niveau cache voorbeeld, in toekomstige berichten zullen we kijken naar Hibernate Second Level Cache – EHCache implementatie.