Die Forschung in diesem Artikel konzentriert sich hauptsächlich auf den Hibernate -Cache -Mechanismus wie folgt.
Student.java:
öffentliche Klasse Student {/*Student ID*/private int id;/*Schülername*/privater String -Name;/*Beziehung zwischen Schülern und Klasse*/private Klassen Klassen; // Setter- und Getter -Methoden weglassen}Classs.java:
öffentliche Klassenklassen {/*Klassen -ID*/private int id;/*Klassenname*/privater String -Name;/*Beziehung zwischen Klasse und Schülern*/privat Set <student> Studenten; // Setter- und Getter -Methoden weglassen}Student.hbm.xml:
<? table = "t_student"> <id name = "id"> <generator // id> <!-Map normale Eigenschaften-> <Eigenschaft name = "name"/> <!-Viele zu-eins-Zuordnungen, fügen Sie dem mehrfachen Ende-> <viele zu-eins Name = "Klassen" CLAUSS "CLOSSID"/> </> </classe> </hibernate-maping> hinzu "/> </class> </hibernate-maping>
Klassen.hbm.xml:
<? -> <class name = "classes" table = "t_classeses" Lazy = "false"> <id name = "id"> <generator/generator/> </id> <Property name = "name"/> <!-Eins-zu-Many-Mapping, Inverse = "True" bedeutet, die Beziehung mit dem Peer-> <set name = "students" inverse = "true" zu übergeben. </set> </class> </hibernate-Mapping>
Die Erklärungsperiode des Cache der ersten Ebene ist sehr kurz und der Lebenszyklus der Sitzung ist konsistent. Der Cache der ersten Ebene wird auch als Cache auf Sitzungsstufe oder Cache auf Session-Ebene bezeichnet. Der Cache der ersten Stufe ist das Cache-Objekt und kann keine Attribute zwischenspeichern.
Testmethode (verwenden Sie in derselben Sitzung zweimal anlast () Abfrage):
/*Nachdem es herausgenommen hat, wird es in den Cache gestellt, und beim zweiten Mal wird es direkt aus dem Cache abgerufen*/ Student = (Student) Sitzung.load (Student.Class, 1); System.out.println ("student.name =" + student.getName ()); /*Es wird keine Abfrageanweisung ausgestellt, Last verwendet Cache*/ student = (student) session.load (student.class, 1); System.out.println ("student.name =" + student.getName ());HINWEIS: Wir werden feststellen, dass die gefundenen Ergebnisse beim ersten Abfragen in Sitzung, Cache und Stufe One -Cache platziert werden. Wenn ich den Wert nach Load () zum zweiten Mal rechtzeitig erhält, habe ich keine Anweisung in der Datenbank abgefragt, sondern den Wert direkt aus dem Cache abgerufen (er muss in derselben Sitzung sein).
Testmethode zwei (in derselben Sitzung):
Student Student = New Student (); Student.SetName ("Zhang San"); Serialisierbare ID = Sitzung.Save (Student); student = (student) session.load (student.class, id); // Die Abfrageerklärung wird nicht ausgestellt, da Save Cache System.out.println ("student.name =" + student.getName ()) unterstützt;HINWEIS: Die Methode Save () wird aufgerufen und load () wird verwendet, um das Objekt zu laden, und dann wird das Namensattribut tatsächlich erhalten, es wird jedoch keine Anweisung ausgestellt, um die Datenbank abzufragen. Weil die SAVE () -Methode auch Cache unterstützt.
Testen Sie die Zugabe großer Datenanhänge:
public void testcache7 () {session session = null; try {session = hibernateUtils.getSession (); Sitzung.BeginTransaction (); für (int i = 0; i <100; i ++) {Student Student = New Student (); Student.SetName ("Zhang san" + i); Sitzung.Save (Student); // Alle 20 Elemente aktualisieren, wenn (i % 20 == 0) {// den Cache löschen, und nach dem Aufrufen von Flush werden die Daten in der Datenbanksitzung gespeichert.flush (); // die zwischengespeicherte Inhaltssitzung löschen.Clear (); }} Session.getTransaction (). commesent (); } catch (Ausnahme e) {e.printstacktrace (); Session.Gettransaction (). Rollback (); } endlich {HibernateUtils.Closession (Sitzung); }} Notiz:
1. Da die Save () -Methode Cache unterstützt, gibt es ein Problem. Wenn ich gleichzeitig 10 Millionen Datenstücke sparen möchte, befinden sich 10 Millionen Cache -Objekte im Cache, was wahrscheinlich zu Überlauf führt. Hibernate unterstützt daher den Aktualisierungsbetrieb groß angelegter Daten nicht, aber wir können dieses Problem auch sehr flexibel behandeln, z. B. das Löschen des Cache alle 20 Daten mit einer Schleife.
2. Speichern, aktualisieren, saveorUpdate, laden, erhalten, listen, iterieren, Sperrmethoden setzen Objekte in den Cache der ersten Ebene. Der Cache der ersten Stufe kann die Anzahl der Caches nicht steuern. Sie sollten daher auf die Möglichkeit eines Speicherüberlaufs achten, wenn Sie Daten in großen Chargen betreiben. Sie können die Evict and Clear -Methode verwenden, um den Inhalt im Cache zu löschen.
Der sekundäre Cache wird auch Cache auf Prozessebene oder Cache auf SessionFactory-Ebene bezeichnet, und der sekundäre Cache kann von allen Sitzungs-Caches gemeinsam genutzt werden. Der Lebenszyklus des sekundären Cache entspricht dem der SessionFactory. Der SessionFactory kann den sekundären Cache verwalten. Das Prinzip des sekundären Cache wird verwendet, wenn das Lesen viel größer ist als das Schreiben. Der sekundäre Cache wird hauptsächlich zum zwischenströmenden Entitätsobjekten verwendet.
1. Kopieren Sie die Datei ehcahe.xml in das SRC -Verzeichnis.
2. Fügen Sie den Cache -Produktanbieter in die Datei hibernate.cfg.xml hinzu, wie folgt:
<Eigenschaft name = "hibernate.cache.provider_class"> org.hibernate.cache.ehcacheProvider </property>
3.. Aktivieren Sie den Cache von Level 2 (starten kann nicht angezeigt, da der Standard aktiviert ist) wie folgt:
<Eigenschaft name = "hibernate.cache.use_second_level_cache"> true </Eigenschaft>
4. Geben Sie an, welche Entitätsklassen Level 2 -Cache verwenden.
5. Importieren Sie das vom Cache verwendete Schnittstellen lib/optional/ehcache/ehcache-core-2.4.3.jar
Inhalt der Datei eHcache.xml:
<defaultCache maxelementsInmemory = "10000" eternal = "False" Timetoidleseconds = "120" TimetoliveSeconds = "120" Überlauf.
Notiz:
1.MaxelementSinMemory repräsentiert die am meisten gespeicherten Objekte im Cache.
2.Ternal gibt an, ob es niemals ablaufen wird (es ist praktischer, es auf False zu setzen. Wenn es wahr ist, wird es niemals ablaufen, dann sind die folgenden Attribute bedeutungslos).
3. TimetoidleSecods geben an, wie lange ein Objekt nach dem ersten Löschen nicht zugegriffen wurde.
4. TimetoliveSecods repräsentiert die Bestandszeit eines Objekts.
5. Überlauf ist wahr, was bedeutet, dass die Anzahl im Cache die von MaxelementSinMemory angegebene Zahl überschreitet und auf der Festplatte gespeichert ist.
Geben Sie den auf Überlauf gespeicherten Festplattenpfad an:
<diskstore path = "java.io.tmpdir"/>
Hinweis: Dieser Pfad kann geändert werden.
Testmethode (die Prämisse des Cache Level 1 besteht darin, dass er in derselben Sitzung sein muss. Jetzt verwenden wir Level 2 -Cache, um festzustellen, ob in zwei verschiedenen Sitzungen ein Cache vorhanden ist):
public void testcache1 () {session session = null; try {session = hibernateUtils.getSession (); Sitzung.BeginTransaction (); Student Student = (Student) Session.load (Student.Class, 1); System.out.println ("Student.Name =" + Student.getn () Session. {e.printStacktrace (); session.getTransaction (). Rollback ();} Schließlich {hibernateUtils.closeSession (Sitzung);} try {session = hibernatutils.getSession (); Teilen Sie die Daten im sekundären Cache. {Hibernatutils.closeSession (Sitzung);}}Hinweis: Wenn der sekundäre Cache konfiguriert ist, werden wir feststellen, dass selbst wenn die erste Sitzung geschlossen ist und eine andere Sitzung zum Laden von Daten eingeschaltet ist, keine Anweisung ausgibt, um die Daten in der Datenbank abzufragen, da der sekundäre Cache konfiguriert ist, wird er von der gesamten Sitzung geteilt.
Deaktivieren Sie Level 2 -Cache, um die Zugabe großer Datenanhänger zu implementieren:
public void testcache5 () {Session Session = null; try {session = hibernateUtils.getSession (); Sitzung.BeginTransaction (); // Line-First-Cache und sekundäre Cache-Interaktion sind untersagt. für (int i = 0; i <100; i ++) {Student Student = New Student (); Student.SetName ("Zhang san" + i); Sitzung.Save (Student); // Alle 20 Elemente aktualisieren, wenn (i % 20 == 0) {session.flush (); // CLEAR -Session zwischen zwischengespeichertem Inhalt löschen.clear (); }} Session.getTransaction (). commesent (); } catch (Ausnahme e) {e.printstacktrace (); Session.Gettransaction (). Rollback (); } endlich {HibernateUtils.Closession (Sitzung); }}HINWEIS: Session.flush () bedeutet, den Cache der ersten Ebene zu löschen, aber wir haben den Cache der zweiten Stufe erneut gestartet, und nach dem Speichern () speichert er ihn auch auf dem Cache der zweiten Ebene, aber es gibt immer noch einen Überlauf, der durch übermäßiges Cache verursacht wird. In diesem Fall sollten wir also den sekundären Cache deaktivieren: Session.setCachemode (cachemode.ignore);
Query-Cache: Sowohl der Cache der ersten Ebene als auch der Cache-Cache-Cache-Cache-Cache-Entitäts-Objekte auf zweiter Ebene, aber manchmal hoffen wir, bestimmte Attribute zu erhalten und nicht häufig auf die Datenbank zugreifen, sondern sie vom Cache erhalten. Zu diesem Zeitpunkt können wir den Abfrage -Cache verwenden. Darüber hinaus werden Abfrage -Cache -Ergebnissätze für Entitätsobjekte Cache ID. Der Lebenszyklus des Abfrage -Cache wird verändert. Wenn die zugehörige Tabelle geändert wird, endet der Deklarationszyklus des Abfrage -Cache, der nichts mit dem Lebenszyklus der Sitzung zu tun hat.
1. Ändern Sie die Datei hibernate.cfg.xml, um den Abfrage -Cache zu aktivieren. Wenn Falsch Standard ist, ist es nicht aktiviert. Es sollte wie folgt festgelegt werden:
<Eigenschaft name = "hibernate.cache.use_query_cache"> true </property>
2. muss im Programm aktiviert werden, wie z. B.:
query.setcacheable (true)
Testmethode:
public void testcache2 () {session session = null; try {session = hibernateUtils.getSession (); Sitzung.BeginTransaction (); list names = session.createquery ("select s.name aus student s") .setCAaktionable (wahr) .List (); für (int i = 0; i <names.size (); (String) names.get (i); {HibernateUtils.closeSession (Sitzung);} System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- .List (); für (int i = 0; i <names.size (); i ++) {String name = (string) names.get (i); System.out.println (name);} session.gettransaction (). commit ();} catch (Ausnahme E) {E.printstacktrace (); {Hibernatutils.closeSession (Sitzung);}}HINWEIS: Im obigen Code schalten wir den sekundären Cache aus, schalten den Abfrage -Cache ein und befragen dann die normalen Eigenschaften. Führen Sie den Testcode aus und wir können feststellen, dass in der ersten Sitzung die erste Abfrage eine Erklärung ausgibt, dann die Sitzung schließt und dann in der zweiten Sitzung abfragt. Wir werden feststellen, dass die Abfrage in der zweiten Sitzung keine Erklärung ausgibt, was bedeutet, dass der Abfrage -Cache nichts mit dem Lebenszyklus der Sitzung zu tun hat.
Cache -Konfiguration von hibernate.cfg.xml:
<!-Setzen Sie die Implementierungsschnittstelle für die Angabe des sekundären Cache-> <Eigenschaftsname = "hibernate.cache.region.factory_class"> org.hibernate.cache.ehCacheregionFactory </Eigenschaft name = "net.sf.ehcache.configurationResourcename">/ehcache.xml </Property> <! <maping ressourcen = "com/lixue/bean/student.hbm.xml"/> <!
Das obige ist der gesamte Inhalt dieses Artikels über die Codeanalyse von Beispielen des Hibernate -Cache -Mechanismus. Ich hoffe, dass dies für alle hilfreich sein wird. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!