Hibernate Second-Level Cache implementeren met NCache

Handleidingen
Hibernate

In deze handleiding zullen we een tweedelijns cache in Hibernate implementeren met behulp van NCache.

We zullen een Java-toepassing opzetten met Hibernate. Daarna zullen we NCache configureren als tweedelijns cache. Ten slotte zullen we de implementatie testen om te zien hoe caching de databasebelasting vermindert en de prestaties verbeterd.

Basis

Voordat we de implementatie in detail bespreken, laten we eerst de basis van Hibernate, NCache en de Hibernate tweedelijns cache begrijpen.

Hibernate

Hibernate is een opensource object-relationele mapping (ORM) framework voor Java-toepassingen. Het vereenvoudigt de ontwikkeling van databaseinteracties door Java-objecten te mapen naar database tabellen en vice versa.

Om de prestaties te verbeteren biedt Hibernate twee niveaus van caching:

1. Eerstelijns Cache

Het eerstelijns cache is geassocieerd met de Hibernate sessie en wordt standaard ingeschakeld. Het slaat de door een sessie opgehaalde objecten op en vermindert het nodige aan databasebezoeken voor hetzelfde object.

Het eerstelijns cache is beperkt tot de scope van een sessie en wordt niet gedeeld over sessies.

Het is ook niet persistent en wordt geleegd als de sessie wordt gesloten of expliciet geleegd.

2. Tweede-Lijns Cache

De tweede-niveauscache wordt gedeeld over sessies en kan worden geconfigureerd om gegevens op het toepassingsniveau te cachen. Het reduceert het aantal database aanvragen door objecten langer op te slaan.

De tweede-niveauscache moet expliciet worden geconfigureerd en kan worden geïmplementeerd met verschillende cachingproviders zoals NCache, Ehcache, enzovoort.

NCache

NCache is een uitgebreide cachingoplossing voor .NET en Java-toepassingen. Het biedt een in-memory gegevensopslag die kan worden gebruikt om gegevens die vaak worden aangevraagd te cachen en de prestaties van applicaties te verbetern.

NCache ondersteunt verschillende cachingtopologieën zoals gedeeld, gedeeld met partities en clientcache.

NCache kan worden gebruikt als tweede-niveauscache in Hibernate om objecten uit de cache te halen in plaats van de database te raken.

Code Setup

Beginnen we met het maken van een Java-applicatie en het instellen van Hibernate om te communiceren met de database.

We zullen Maven gebruiken om afhankelijkheden te beheren en het project te bouwen. De applicatie zal een entityklasse om gegevens te definiëren en een clientklasse om te communiceren met de database bevatten.

Eerst zullen we de applicatie testen zonder caching om de databaseinteracties te zien. Dan zullen we NCache configureren als tweede-niveauscache in Hibernate om entityobjecten te cachen en het aantal databaseaanvragen te reduceren.

Afhankelijkheden

We beginnen met het toevoegen van de vereiste afhankelijkheden voor Hibernate en NCache in het pom.xml bestand:



<dependencies>
    <!-- Hibernate dependencies -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>6.6.1.Final</version>
    </dependency>
    <!-- NCache dependencies -->
    <dependency>
        <groupId>com.alachisoft.ncache</groupId>
        <artifactId>ncache-hibernate</artifactId>
        <version>5.3.3</version>     </dependency>
</dependencies>

Let op dat de hier vermelde versies kunnen variëren op basis van de nieuwste releases. Zorg ervoor dat u de juiste versies gebruikt voor uw project.

Entity Class

Laten we nu een entity-klasse maken om de gegevens weer te geven die we willen cachen. We definiëren een eenvoudige Customer-klasse met id en name-velden:



@Entity
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE, region = "CustomerRegion")
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // getters en setters
}

De Customer-klasse is geannoteerd met @Entity en @Cacheable om het te definiëren als een cachebare entity. Het heeft een id-veld geannoteerd met @Id en @GeneratedValue om automatisch unieke identificatoren te genereren.

We gebruiken ook de @Cache-annotatie om de cachingstrategie en regio voor de entity te specificeren.

NONSTRICT_READ_WRITE vertelt Hibernate om de cache te updaten wanneer gegevens worden gelezen of geschreven met uiteindelijke consistentie.

Het region-attribuut specificeert de cache-regio waar de gegevens worden opgeslagen.

We zullen NCache configureren om deze regio te gebruiken om de gecachede gegevens op te slaan.

Hibernate Configuratie

We moeten Hibernate configureren om te interageren met de database en caching in te schakelen.

Laten we een hibernate.cfg.xml-bestand maken in de src/main/resources-directory met de volgende configuratie:



<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:xe</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.Oracle12cDialect</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
        <property name="hibernate.show_sql">true</property>
    </session-factory>
</hibernate-configuration>

In dit configuratiebestand specificeren we de databaseverbindingdetails, dialect en cache-instellingen. We gebruiken Oracle als de database en configureren Hibernate om het schema automatisch bij te werken.

Client Class

We kunnen een clientclass aanmaken om te interageren met de database en de cachingmechanisme te testen. We kunnen een main class schrijven om Customer objecten op te slaan en te ontvangen met behulp van Hibernate:



public class HibernateClient {
    public static void main(String[] args) {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();

        Customer customer = new Customer();
        customer.setName("John Doe");

        session.save(customer);
        transaction.commit();
        session.close();

        session = sessionFactory.openSession();
        transaction = session.beginTransaction();

        Customer retrievedCustomer = session.get(Customer.class, customer.getId());
        System.out.println("Retrieved Customer: " + retrievedCustomer.getName());

        transaction.commit();
        session.close();

        session = sessionFactory.openSession();
        transaction = session.beginTransaction();

        retrievedCustomer = session.get(Customer.class, customer.getId());
        System.out.println("Retrieved Customer: " + retrievedCustomer.getName());

        transaction.commit();
        session.close();
    }
}

In deze clientclass maken we een SessionFactory aan op basis van de Hibernate configuratie en openen we een sessie om te interageren met de database. We slaan een Customer object op in de database en halen het op met behulp van het id.

Dan bellen we de retrieveCustomer methode twee keer af in twee aparte sessies om de databaseinteracties zonder caching te zien.

We zullen observeren dat de database twee keer wordt aangeroepen om hetzelfde object te halen:

Als we kunnen zien, wordt de Hibernate query twee keer uitgevoerd.

Installeren van de NCache Server

Om NCache als tweede niveau cache in Hibernate te gebruiken, moeten we een NCache server installeren en configureren om de gecachete data op te slaan.

NCache biedt een geïntegreerde caching oplossing die op Windows en Linux servers kan worden geïnstalleerd. We zullen een cache cluster met NCache aanmaken en configureren.一旦 de cache cluster is opgebouwd, kunnen we er vanuit onze Java applicatie mee verbinden.

Activeren van NCache als Tweede Niveau Cache in Hibernate

Zodra de NCache server is opgebouwd, kunnen we Hibernate configureren om NCache te gebruiken als tweede niveau cache provider. We zullen de Hibernate configuratiebestand bijwerken en de cache instellingen specificeren om caching in te schakelen.

Activeren van Cacheregio’s

Laat’s de cacheinstellingen in het bestand hibernate.cfg.xml bijwerken om NCache als tweede-niveau cacheprovider in te schakelen:



<hibernate-configuration>
    <session-factory>
        <property name="hibernate.cache.use_second_level_cache">true</property>
        <property name="hibernate.cache.region.factory_class">com.alachisoft.ncache.NCacheRegionFactory</property>
        ...
    </session-factory>
</hibernate-configuration>

Hier stellen we de eigenschap hibernate.cache.use_second_level_cache in op true om de tweede-niveau cache in te schakelen. We specificeren ook de eigenschap hibernate.cache.region.factory_class om de NCacheRegionFactory te gebruiken, een implementatie van de JCacheRegionFactory, als cacheprovider.

Configureren van NCache-eigenschappen

NCache biedt een set eigenschappen aan om de cacheinstellingen in Hibernate te configureren. We kunnen deze instellen in het bestand ncache-hibernate.xml:



<configuration>
    <application-config application-id="myapp" enable-cache-exception="true" default-region-name="DefaultRegion"
                        key-case-sensitivity="false">
        <cache-regions>
            <region name="CustomerRegion" cache-name="demoCache" priority="AboveNormal" expiration-type="Sliding"
                    expiration-period="8"/>
            <region name="DefaultRegion" cache-name="demoCache" priority="default" expiration-type="None" expiration-period="0"/>
        </cache-regions>
        <database-dependencies>
            <dependency entity-name="hibernator.BLL.Customer" type="oledb"
                        sql-statement="SELECT CustomerID FROM Customers WHERE CustomerID ='?';"
                        cache-key-format="Customers#[pk]"
                        connection-string="Provider=SQLOLEDB;Data Source=20.200.20.40,1433;Initial Catalog=Northwind;User ID=john;Password=1234;"/>
        </database-dependencies>
    </application-config>
</configuration>

In dit configuratiebestand definiëren we de cachezone CustomerRegion met de cache naam, prioriteit, verlooptype en verloopperiode. We stellen de expiration-type in op Sliding met een verloopperiode van 8 seconden. Dit betekent dat de gecacheerde gegevens na 8 seconden van inactiviteit verlopen zijn en verwijderd worden uit de cache.

Additioneel definiëren we een DefaultRegion met standaardinstellingen voor andere entiteiten die geen specifieke cachezone hebben. Dit wordt gebruikt als terugvalzone voor entiteiten die niet expliciet zijn geconfigureerd.

Het hebben van meerdere cacheregio’s laat ons verschillende cacheinstellingen definiëren voor verschillende entiteiten op basis van hun vereisten.

Vervolgens definiëren we een database afhankelijkheid voor de Customers entiteit. Hiermee wordt de cache ge synchroniseerd met de database en wordt de gegevens in de cache bijgewerkt of verwijderd wanneer wijzigingen worden aangebracht in de database.

We specificeren de SQL-instructie om de CustomerID uit de Customers tabel te halen en de verbindingsreeks om verbinding te maken met de database.

Het formaat van de cache-sleutel specificeert hoe de cache-sleutel wordt gegenereerd op basis van de primaire sleutel van de entiteit.

Testen

Nu we NCache als tweedelige cache in Hibernate zijn geconfigureerd, laten we de toepassing testen om te zien hoe caching de prestaties verbetert. We zullen de clientklasse opnieuw draaien en de databaseinteracties observeren met cache ingeschakeld.

Als we de clientklasse draaien, zullen we zien dat de eerste aanroep om het Customer object te verkrijgen de database raadt om de gegevens op te halen. Echter, de tweede aanroep om hetzelfde object te verkrijgen haalt het uit de cache in plaats van de database opnieuw aan te roepen. Dit toont hoe caching de databasebelasting reduceert en de prestaties verbetert door gegevens uit de cache te leveren.

Benefieten van het gebruik van NCache met Hibernate

Het gebruik van NCache als tweedelige cache in Hibernate biedt verschillende voordelen:

  • Verbeterde prestaties: NCache biedt snelle in-memory opslag voor gecachet data, waardoor de latency wordt verminderd en de doorvoer verbeterd. Het biedt ook asynchrone bewerkingen om de cache achter de schermen bij te werken, waardoor de invloed op de prestaties van de toepassing wordt verminderd.
  • Schaalbaarheid: Met de groei van de toepassing kan NCache horizontaal schalen om grote hoeveelheden data en gebruikersverzoeken af te handelen. Het kan in een cluster worden geïmplementeerd en ondersteunt functies zoals cache-replicatie en partitieering om de belasting te verdelen.
  • Verschillende configuraties: NCache biedt verschillende caching topologieën en configuraties om aan verschillende toepassingsvereisten te voldoen. Bovendien dankzij de gebruik van cacheregio’s kunnen verschillende entiteiten verschillende cacheinstellingen hebben op basis van hun behoeften. Dit biedt fijn gemote controle over het gedrag van de cache.
  • Synchronisatie: NCache biedt de optie voor database synchronisatie om de cache in sync te houden met de database. Dit zorgt ervoor dat de geCachete data up-to-date is en de laatste wijzigingen in de database weergeeft.

Samenvatting

In deze handleiding hebben we gekeken hoe een tweedelige cache in Hibernate kan worden geïmplementeerd met behulp van NCache voor Java-toepassingen.

We zijn begonnen door de basis te begrijpen van Hibernate, NCache en de tweedelige Hibernate-cache. Daarna hebben we een Java-toepassing opgesette met Hibernate en geconfigureerd NCache als tweede-niveau cache. Eindelijk hebben we de implementatie getest om te zien hoe caching de prestaties verbetert door de database aanrakingen te verminderen en data direct uit de cache te leveren.

Met het gebruik van NCache bij Hibernate kunnen ontwikkelaars de prestaties, schaalbaarheid en betrouwbaarheid van hun toepassingen vergroten door gebruik te maken van de kracht van gegevensvergelijkingen. NCache biedt een robuuste oplossing voor caching die gemakkelijk integreert met Hibernate en andere Java-frameworks, waardoor het een ideale keuze is voor het cachen van gegevens in Java-toepassingen.

Source:
https://dzone.com/articles/implement-hibernate-second-level-cache-with-ncache