Winterschlafcache
Bei Caching dreht sich alles um die Leistungsoptimierung der Anwendung und befindet sich zwischen der Anwendung und der Datenbank, um mehrere Datenbankzugriffe zu vermeiden und leistungskritische Anwendungen zu ermöglichen, um eine bessere Leistung zu erzielen.
Das Caching ist für Winterschlafe wichtig und nimmt ein nachstehend beschriebenes Multi-Level-Caching-Schema an:
Stufe 1 Cache:
Der Cache der ersten Ebene ist der Sitzungs -Cache, der ein obligatorischer Cache ist, und alle Anfragen müssen übergeben werden. Sitzungsobjekte werden ständig von Objekten betrieben, bevor sie an die Datenbank übermittelt werden.
Wenn mehrere Aktualisierungen erteilt werden, versucht Hibernate, die Aktualisierungen so lange wie möglich zu verzögern, um die Anzahl der ausgestellten Aktualisierungen ausgestelltem SQL -Anweisungen zu verringern. Wenn Sie die Sitzung schließen, gehen alle zwischengespeicherten Objekte entweder persistent oder in der Datenbank aktualisiert.
Stufe 2 Cache:
Level 2 Cache ist optional und Cache Level 1, der immer gesucht wird, bevor der Cache eines Objekts Level 2 -Cache gefunden wird. Der Cache der zweiten Ebene kann auf einer Basis pro Klasse und pro Kategorie konfiguriert werden, die hauptsächlich für Objekte verantwortlich ist, die in der Sitzung zwischengespeichert werden.
Jeder Cache von Drittanbietern kann Hibernate verwenden. Die Schnittstelle org.hiberNate.cache.cacheProvider bietet und es ist erforderlich, eine Handle -Cache -Implementierung zur Bereitstellung von Winterschlafungen zu implementieren.
Abfragebereich Cache:
Hibernate implementiert auch die enge Integration von Cache -Set -Set -Cache und Level 2 -Cache.
Dies ist eine optionale Funktion, für die zwei zusätzliche physische Caches erforderlich sind, um zwischengespeicherte Abfragenergebnisse und -regionen zu speichern, wenn eine Tabelle zuletzt aktualisiert wird. Dies ist nur sehr nützlich für Abfragen, die oft mit denselben Parametern ausgeführt werden.
Stufe 2 Cache:
Der Hibernate verwendet Level 1 -Cache standardmäßig. Sie tun nichts mit Cache Level 1. Gehen wir direkt zum optionalen Cache der zweiten Ebene. Nicht alle Klassen profitieren von dem Caching, daher ist es wichtig, Level -2 -Cache zu deaktivieren.
Der Hibernate Level 2 -Cache wird auf zwei Schritte eingestellt. Zunächst müssen Sie entscheiden, welche Parallelitätsstrategie verwendet werden soll. Danach können Sie den Cache -Ablauf konfigurieren und Cache verwenden, um physische Cache -Attribute bereitzustellen.
Parallelitätsstrategie:
Eine Parallelitätsrichtlinie ist ein Mediator, der für das Speichern von Datenelementen im Cache und das Abrufen von Cache verantwortlich ist. Wenn Sie das Caching der Stufe 2 aktivieren möchten, müssen Sie entscheiden, welche Cache -Parallelitätsrichtlinie für jede anhaltende Klasse und Sammlung verwendet werden soll.
Transaktions: Die Verwendung dieser Strategie zum Lesen von Daten zur Verhinderung von gleichzeitigen Transaktionen veralteter Daten ist in seltenen Fällen von Aktualisierungen von entscheidender Bedeutung.
Leseschreiber: Verwenden dieser Strategie erneut die Hauptlesung von Daten ist entscheidend, um gleichzeitige Transaktionen von abgestandenen Daten in seltenen Fällen von Aktualisierungen zu verhindern.
Nicht-Read-Schreiben: Diese Strategie garantiert keine Konsistenz zwischen Cache und Datenbank. Mit dieser Strategie besteht der Schlüssel nicht darin, aufmerksam zu sein, wenn die Daten selten geändert werden und die Möglichkeit von veralteten Daten veraltet ist.
Schreibgeschützte: Die Parallelitätsrichtlinie ist für Daten geeignet und wird sich nie ändern. Die verwendeten Daten dienen nur als Referenz.
Wenn wir den Cache der zweiten Ebene als Mitarbeiterklasse verwenden möchten, fügen wir die Mapping -Elemente hinzu, die erforderlich sind, um den Hibernate zu sagen, dass sie eine lesbare und schriftliche Cache -Richtlinie für Mitarbeiterinstanzen verwenden sollen.
<? Tabelle = "Mitarbeiter"> <meta Attribute = "Klasse-De-Scription"> Diese Klasse enthält das Detail der Mitarbeiter. </meta> <cache useage = "read-write"/> <id name = "id" type = "int" column = "id"> <generator/> </id> <Eigenschaft name = "firstname" column = "first_name" type = "String"/> <Eigenschaft name = "lastname" salary = "salary" salary "salary"/"string"/> < </class> </hibernate-Mapping>
Die Nutzung = "Read-Write" -Mobilie fordert den Hibernate auf, einen Cache zu verwenden, der durch eine Read-Write-Parallelitätsrichtlinie definiert ist.
Cache -Anbieter:
Nachdem Sie die Parallelitätspolitik Ihrer Cache -Kandidatenklasse berücksichtigt haben, besteht der nächste Schritt darin, einen Cache -Anbieter auszuwählen. Winterschlafkräfte, die einen Cache auswählen, um die gesamte Anwendung zu bedienen.
Cache in der angegebenen Hibernate.cfg.xml -Konfigurationsdatei. Wählen Sie EHCache als Cache -Anbieter der zweiten Ebene aus:
<xml version = "1.0" coding = "utf-8"?> <! docType hibernate-configuration System "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <Hiebernate-configuration> <s Session-Factory> <Bodeny name = " org.hiberNate.dialect.mysqldialect </Property> <Property name = "hibernate.connection.driver_class"> com.mysql.jdbc.driver </property> <!-Angenommen, die Schüler ist der Datenbankname-> <Eigentum name = "hibernate.connection.url"> jdbc: mysql: // örtlich. name = "hibernate.connection.username"> root </Property> <Eigenschaft name = "hibernate.connection.password"> root123 </property> <Eigenschaft name = "hibernate Resource = "Mitarbeiter.hbm.xml"/> </Session-Factory> </hibernate-configuration>
Jetzt müssen Sie die Eigenschaften des Cache -Bereichs angeben. EHCache hat eine eigene Konfigurationsdatei EHCache.xml in der Anwendung im ClassPath. In EHCache.xml könnte die Cache -Konfiguration der Mitarbeiterklasse so aussehen:
<diskstore path = "java.io.tmpdir"/> <defaultCachemaxelementSinMemory = "1000" eternal = "False" TimetoidleSeconds = "120" TimetoliveSeconds = "120" Überlauf = "True"/> <cache name = "Mitarbeiter" MaxelementSinMemory = "500" Eternal = "True" Timetoidleseconds = "0" TimetoliveSeconds = "0" Überlaufodisk = "False"/>
Das ist es, jetzt zu ermöglichen, dass der Sekundärcache der Mitarbeiterklasse nun den sekundären Cache hat, wenn ein Mitarbeiter durchsucht oder wenn der Mitarbeiter durch eine Kennung geladen wird.
Sie sollten alle Ihre Klassen analysieren und die entsprechende Caching -Strategie für jede Klasse auswählen. Manchmal kann der sekundäre Cache die Leistung der Anwendung beeinträchtigen. Daher wird der Benchmark -Anwendung empfohlen, die das Caching zum ersten Mal nicht ermöglicht, was sehr für das Caching und die Überprüfung der Leistung geeignet ist. Wenn der Cache die Systemleistung nicht verbessert, ist es bedeutungslos, eine Art von Cache zu erstellen.
Abfragebereich Cache:
Mit Query -Cache muss er zuerst in der Hibernate -Eigenschaftskonfigurationsdatei für Hibernate aktiviert werden. Wenn diese Eigenschaft auf true eingestellt ist, lassen Sie den Hibernate den erforderlichen Cache im Speicher erstellen, um die Abfrage- und Bezeichner -Menge zu speichern.
Als nächstes können Sie mit Abfrage -Cache die setCacheable (boolesche) Methode der Abfrageklasse verwenden. Zum Beispiel:
Sitzung Session
Hibernate unterstützt auch sehr feinkörnige Cache-Unterstützung durch das Konzept eines Cache-Bereichs. Der Cache ist Teil des Cache bei einem Namen.
Sitzung Session
Dieser Code verwendet eine Methode, um Hibernate zu sagen, dass sie Abfragen zu Mitarbeitern im Cache speichern und finden sollen.
Hibernate Native SQL
Sie können native SQL verwenden, um Datenbankabfragen auszudrücken. Wenn Sie datenbankspezifische Funktionen verwenden möchten, z. B. Abfragenanforderungen oder Verbinden von Schlüsselwörtern in Oracle. Hibernate3.x ermöglicht die Verwendung von handgeschriebenen SQL -Anweisungen, einschließlich gespeicherter Prozeduren, aller Erstellungs-, Aktualisierungs-, Löschen- und Lastvorgänge.
Die Anwendung erstellt eine native SQL -Abfrage (auf der Sitzungsschnittstelle) aus der Sitzung creesSQLQuery ():
public SQLQuery erstelltQlQuery (String SQLString) löst HibernateException aus
Beim Übergeben einer SQL -Abfrage an die Methode createsQLQuery () können Sie die Methode Addentity () verwenden, die mit einer vorhandenen Hibernate -Entität zugeordnet ist, oder ein skalares Ergebnis unter Verwendung der Methode Addentity (), AddJoin () und AddScalar ().
Skalaranfrage:
Die grundlegendste SQL -Abfrage besteht darin, eine Liste von Skalaren (numerischen Werten) aus einem oder mehreren Tabellen zu erhalten. Hier sind die Werte der Syntax mit nativen SQL -Skalaren:
String SQL = "SELECT FIRST_NAME, Gehalt vom Mitarbeiter";
Entitätsanfrage:
Die obigen Abfragen alle Rückgabe -Skalarwerte, dh die "nackten" Daten, die aus dem Ergebnis zurückgegeben wurden. Das Folgende ist die Syntax, um Entitätsobjekte als Ganzes aus der nativen SQL -Abfrage über die Addentity () -Methode zu erhalten.
String SQL = "SELECT * vom Mitarbeiter";
Named SQL -Abfrage:
Im Folgenden finden Sie die Syntax, um Entitätsobjekte aus nativen SQL -Abfragen zu erhalten und mit dem Namen SQL -Abfragen über die Addentity () -Methode zu verwenden.
String SQL = "SELECT * vom Mitarbeiter wobei id =: Employee_id";
Native SQL -Beispiel:
Betrachten Sie die folgende Pojo -Klasse:
Mitarbeiter der öffentlichen Klasse {private int id; private String FirstName; private Zeichenfolge Lastname; privates Int -Gehalt; public Employee () {} public Employee (String fname, String lName, int -Gehalt) {this.firstname = fname; this.lastName = lname; this.Salary = Gehalt; } public int getid () {return id; } public void setId (int id) {this.id = id; } public String getFirstName () {return firstname; } public void setfirstname (String first_name) {this.firstname = first_name; } public String getLastName () {return LastName; } public void setLastName (String last_name) {this.lastName = last_name; } public int getSalary () {Rückgabegehalt; } public void setSalary (Int -Gehalt) {this.Salary = Gehalt; }}Erstellen wir die folgende Mitarbeitertabelle, um das Mitarbeiterobjekt zu speichern:
table -Mitarbeiter erstellen (ID int nicht null auto_increment, First_name varchar (20) Standardnull, last_name varchar (20) Standardnull, Gehalt int Standard Null, Primärschlüssel (ID));
Im Folgenden werden Dateien abgebildet.
<? Tabelle = "Mitarbeiter"> <meta Attribute = "Klasse-De-Scription"> Diese Klasse enthält das Detail der Mitarbeiter. </meta> <id name = "id" type = "int" column = "id"> <generator/> </id> <Eigenschaft name = "FirstName" column = "first_name" type = "String"/> <Eigenschaft name = "lastname" column = "last_name" type
Schließlich erstellen wir die Main () -Methode der Anwendungsklasse, die ausgeführt werden soll, und verwenden native SQL -Abfrageanwendungen:
import Java.util.*; import org.hibernate.hibernateException; import org.hibernate.session; import org.hibernate.transaction; import org.hibernate public static void main (string [] args) {try {factory = new configuration (). configure (). BuildSessionFactory (); } catch (throwable ex) {System.err.println ("SessionFactory -Objekt nicht erstellt." + ex); Neue ExecessIninitializerError (Ex) werfen; } ManagyeAmee me = new ManageAmployee (); / * Fügen Sie einige Mitarbeiterdatensätze in die Datenbank hinzu */ Integer empID1 = me.addEmPl ("Zara", "Ali", 2000); Ganzzahl empid2 = me.addOPhPer ("Daisy", "Das", 5000); Ganzzahl empid3 = me.addEmPl ("John", "Paul", 5000); Integer empid4 = me.addOPhPer ("Mohd", "Yasee", 3000); / * Listen Sie die Mitarbeiter und ihr Gehalt mit skalarer Abfrage auf */ me.listopertoesscalar (); / * Listen Sie die vollständigen Mitarbeiterinformationen mithilfe der Entitätsabfrage auf */ me.listOplopoEntoEntity (); } / * Methode zum Erstellen eines Mitarbeiters in der Datenbank * / public Integer addPelyee (String fname, String lName, int -Gehalt) {Session Session = Factory.OpenSession (); Transaktion TX = NULL; Integer EmployeeId = NULL; try {tx = session.beginTransaction (); Mitarbeitermitarbeiter Mitarbeiter = neuer Mitarbeiter (fname, lname, Gehalt); EmployeEID = (Integer) Sitzung.Save (Mitarbeiter); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E. printstacktrace (); } endlich {Session.close (); } Return EmployeEID; } / * Methode zum Lesen aller Mitarbeiter mit skalarer Abfrage * / public void listoperyeesscalar () {session session = factory.openSession (); Transaktion TX = NULL; try {tx = session.beginTransaction (); String SQL = "Wählen Sie First_Name, Gehalt vom Mitarbeiter"; SQLQuery query = session.createSQLQuery (SQL); query.setResultTransformer (Kriterien.ALIAS_TO_ENTITY_MAP); List data = query.list (); für (Objektobjekt: Daten) {map row = (map) Objekt; System.out.print ("Vorname:" + row.get ("first_name"); System.out.println (", Gehalt:" + row.get ("Gehalt")); } tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E. printstacktrace (); } endlich {Session.close (); }} / * Methode zum Lesen aller Mitarbeiter mithilfe von Entity Query * / public void ListOploToPoTeSentity () {Session Session = Factory.OpenSession (); Transaktion TX = NULL; try {tx = session.beginTransaction (); String SQL = "SELECT * vom Mitarbeiter"; SQLQuery query = session.createSQLQuery (SQL); query.addentity (Mitarbeiter.Class); List Employees = query.list (); für (Iterator iterator = Mitarbeiter System.out.print ("Vorname:" + Mitarbeiter.getFirstname ()); System.out.print ("Nachname:" + Mitarbeiter.getLastName ()); System.out.println ("Gehalt:" + Mitarbeiter.getSalary ()); } tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E. printstacktrace (); } endlich {Session.close (); }}} Kompilieren und ausführen:
Hier sind die Schritte zum Kompilieren und Ausführen der obigen Anwendung. Bitte stellen Sie sicher, dass dieser Pfad und der Klassenpfad vor dem Zusammenstellen und Ausführen entsprechend eingestellt sind.
Führen Sie die Binärdatei verwalten, um das Programm auszuführen.
Die folgenden Ergebnisse werden erzielt und der Datensatz in der Mitarbeitertabelle erstellt.
$ java verwaltete Menschenschaft
...... Verschiedene Protokollnachrichten werden hier angezeigt ......... Vorname: Zara, Gehalt: 2000First Name: Daisy, Gehalt: 5000First Name: John, Gehalt: 5000First Name: Mohd, Gehalt: 3000First Name: Zara Last Name: Ali Gehalt: 2000First Name: 5000 Last Name: 5000 Last Name: 5000 FAURIG NAME: 5000First Name: John Last Name: 5000 Letzte Name: 5000 FAURIG NAME: 5000 FAURIG NAME: John Last Name: 5000 -Last -Name: 5000 FAURIG NAME: John Last Name: 5000 -Last -Namen: 5000 -Gehaltsname: John Last Name: 5.000 FAURIG NAME: John Last Name: 5.000 FAURIG NAME: John Last Name: 5.000 FAURIG NAME: John Last Name: 5.000 FAURIG NAME: John Last Name. Mohd Nachname: Yasee -Gehalt: 3000
Wenn Sie die Mitarbeitertabelle überprüfen, sollte er aufgezeichnet haben, dass sie Folgendes enthält:
MySQL> SELECT * vom Mitarbeiter;
+------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------