Wie funktioniert der Second-Level-Cache von Hibernate?

Caching trägt dazu bei, Datenbanknetzwerkaufrufe beim Ausführen von Abfragen zu reduzieren.

Cache und Sitzungsverknüpfung der Stufe 1. Es wird implizit implementiert. Cache der Ebene 1 ist vorhanden bis das Sitzungsobjekt existiert. Sobald das Sitzungsobjekt beendet/geschlossen ist, wird dies der Fall sein Es sind keine zwischengespeicherten Objekte vorhanden. Der Cache der zweiten Ebene funktioniert für mehrere Sitzungsobjekte. es ist verlinkt mit Session Factory. Cache-Objekte der zweiten Ebene stehen allen Sitzungen zur Verfügung Einzelsitzungsfabrik. Diese zwischengespeicherten Objekte werden beendet, wenn eine bestimmte Sitzung stattfindet Die Fabrik ist geschlossen.

L2-Cache implementieren

Wir müssen die folgenden Abhängigkeiten hinzufügen, um den Cache der zweiten Ebene zu verwenden.

<!-- https://mvnrepository.com/artifact/net.sf.ehcache/ehcache -->
<dependency>
   <groupId>net.sf.ehcache</groupId>
   <artifactId>ehcache</artifactId>
   <version>2.10.9.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-ehcache -->
<dependency>
   <groupId>org.hibernate</groupId>
   <artifactId>hibernate-ehcache</artifactId>
   <version>5.4.32.Final</version>
</dependency>

Hinweis – Die Hibernate-Ehcache-Versionsnummer muss mit der Hibernate-Versionsnummer identisch sein.

Jetzt müssen wir die Hibernate-Konfigurationsdatei hinzufügen, mit der Hibernate eine Verbindung herstellen kann Bereitgestellte Datenbank und Verwendung des Second-Level-Cache.

<!DOCTYPE hibernate-configuration PUBLIC
   "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
   "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
   <session-factory>
      <!-- JDBC Database connection settings -->
      <property name="connection.driver_class">com.mysql.cj.jdbc.Driver</property>
      <property name="connection.url">jdbc:mysql://localhost:3306/demo?useSSL=false</property>
      <property name="connection.username">root</property>
      <property name="connection.password">root</property>
      <!-- JDBC connection pool settings ... using built-in test pool -->
      <property name="connection.pool_size">4</property>
      <!-- Echo the SQL to stdout -->
      <property name="show_sql">true</property>
      //caching properties
      <property name="cache.use_second_level_cache">true</property>
      <property name="cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
      <!-- Select our SQL dialect -->
      <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
      <!-- Drop and re-create the database schema on startup -->
      <property name="hbm2ddl.auto">create-drop</property>
      <!-- name of annotated entity class -->
      <mapping class="academy.company.Parent"/>
   </session-factory>
</hibernate-configuration>

Beispiel

Standardmäßig werden nicht alle Entitäten in Java zwischengespeichert. Um das Zwischenspeichern von Entitäten zu ermöglichen, verwenden wir die Annotationen @Cacheable und @Cache in der Entitätsklasse Parent -

import org.hibernate.annotations.CacheConcurrencyStrategy;
import javax.persistence.*;

@Entity
@Table( name = " Employee")
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
public class Parent {
   @Id
   @GeneratedValue(strategy = GenerationType.AUTO)
   Long id;
   @Column(name = "first_name")
   String firstName;
   @Column(name = "last_name")
   String lastName;
}
Now, let’s check whether second level cache works:
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class Main {
   public static void main(String[] args) {
      SessionFactory sessionFactory = new Configuration()
         .configure("academy/company/hibernate.cfg.xml")
         .buildSessionFactory();
      Session session1 = sessionFactory.openSession();
      Parent parent1 = session1.get(Parent.class, 4);
      System.out.println(parent1.id + " " + parent1.firstName + " " + parent1.lastName);
      session1.close();
      
      Session session2 = sessionFactory.openSession();
      Parent parent2 = session2.get(Parent.class, 4);
      System.out.println(parent2.id + " " + parent2.firstName + " " + parent2.lastName);
      session2.close();
   }
}

Ausgabe

Hibernate: select parent0.id as id1, parent0.first_name as first_name1, parent0.last_name as last_name1 from Parent parent0 where parent0.id=?
1 Subash Chopra
1 Subash Chopra

Von der Konsole aus können wir deutlich erkennen, dass Hibernate während Sitzung1 nur eine Abfrage ausgeführt hat. Wenn nun Sitzung2 auf dieselbe Abfrage zugreift, erfolgt kein Netzwerkaufruf an die Datenbank, um sie auszuführen. Da wir stattdessen den Cache der zweiten Ebene verwenden, wird das Cache-Objekt von Sitzung1 abgerufen.

Das obige ist der detaillierte Inhalt vonWie funktioniert der Second-Level-Cache von Hibernate?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!