Anmerkung
Hibernate -Annotation ist eine neueste Methode, bei der XML -Dateien nicht zum Definieren von Zuordnungen verwendet werden. Anmerkungen können in XML -Mapping -Metadaten verwendet werden, die getrennt oder ersetzt werden.
Die Annotationen von Hibernate sind eine starke Möglichkeit, Zuordnungen von Metadatenobjekten und relationalen Tischen zu liefern. Alle Metadaten werden zusammen mit der Pojo Java -Datei gepechert. Dies kann den Benutzern helfen, die Struktur der Tabelle und des Pojo während des Entwicklungsprozesses zu verstehen.
Wenn Sie beabsichtigen, die Anwendung in andere EJB3-spezifische ORM-Anwendungen zu portieren, müssen Sie Annotationen verwenden, um die Zuordnungsinformationen darzustellen. Wenn Sie jedoch eine größere Flexibilität wünschen, sollten Sie XML-basierte Zuordnung verwenden.
Wenn Sie zuerst die Annotation von Winterschlafanungen in der Umgebung festlegen, müssen Sie sicherstellen, dass Sie JDK5.0 verwenden. Andernfalls müssen Sie JDK auf JDK5.0 -Native -Support mit Anmerkungen aktualisieren.
Zweitens müssen Sie das 3.x-Annotation-Verteilungspaket von Hibernate installieren.
Kommentierte Klasseninstanz:
Wie bereits erwähnt, kann alle Metadaten, die mit Winterschlafannotation in der obigen Pojo -Java -Datei arbeiten, den Benutzern helfen, sowohl die Tabellenstruktur als auch das Pojo während der Entwicklung zu verstehen.
Betrachten Sie das Objekt, das mit der folgenden Mitarbeitertabelle gespeichert wird:
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 finden Sie die Zuordnung der Objekt -Mitarbeiterklasse mit Anmerkungen, um mit der definierten Mitarbeitertabelle zu kartieren:
Javax.Persistence importieren. @Column (name = "first_name") private String FirstName; @Column (name = "last_name") private String LastName; @Column (name = "Gehalt") Private int -Gehalt; public Employee () {} 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; }}Hibernate erkennt, dass die @ID -Annotation gegen ein Feld stammt, und geht davon aus, dass sie über die Laufzeitdomäne direkt auf die Eigenschaften eines Objekts zugreifen sollte. Wenn @ID mit der GetID () -Methode kommentiert wird, wird auf die Eigenschaft standardmäßig über Gotter- und Setter -Methoden zugegriffen. Daher werden auch alle anderen Kommentare entweder in Feld- oder Gettter -Methoden platziert, wie unter der Richtlinie ausgewählt. Der folgende Abschnitt erläutert die in der obigen Klasse verwendeten Kommentare.
@Entity Annotation:
Die Beschreibung der EJB3 -Spezifikation ist im Paket von Javax.Persistence enthalten. Daher importieren wir dieses Paket als erste Schritt. Zweitens haben wir die @Entity -Annotation verwendet, um diese Klasse als Bean -Mitarbeiterklasse der Entität zu markieren, sodass sie einen parameterlosen Konstruktor haben muss, der schließlich mit Schutz sichtbar ist.
@Table Annotation:
Mit der @Table -Annotation kann die angegebene Tabelle detaillierte Informationen über die Entität in der Datenbank enthalten.
Die @Table -Annotation bietet vier Eigenschaften, die es ermöglichen, den Namen der Tabelle, ihr Verzeichnis, sein Schema und die Ausführung eindeutiger Einschränkungen in den Spalten in der Tabelle zu überschreiben. Jetzt verwenden wir gerade den Namen der Mitarbeitertabelle.
@ID und @GeneratedValue -Anmerkungen:
Jede Entitätsbean wird in der @ID -Annotation der Klasse einen primären Schlüssel annotieren. Der Primärschlüssel kann ein einzelnes Feld oder eine Kombination mehrerer Felder gemäß der Tabellenstruktur sein.
Standardmäßig bestimmt die @ID -Annotation automatisch die zu verwendende Strategie der Primärschlüsselgenerierung. Sie kann jedoch durch Anwenden der @generatedValue -Annotation verwendet werden, die zwei Parameter, Strategie und Generator akzeptiert, hier nicht erörtert werden. Lassen Sie Hibernate den Generatortyp ermitteln, um die Code -Portabilität zwischen verschiedenen Datenbanken zu ermitteln.
@Column Annotation:
Die @Column -Annotation wird verwendet, um die Details der Spalte in ein Feld oder eine Eigenschaft anzugeben, die zugeordnet werden. Die folgenden am häufigsten verwendeten Eigenschaften können unter Verwendung von Spalten kommentiert werden:
Das Namensattribut ermöglicht es explizit den Namen der Spalte.
Mit der Länge -Eigenschaft können die Größe einer Spalte, die speziell für einen String -Wert erfolgt, zuordnen.
Mit der nullbaren Eigenschaft kann die Spalte bei der Erzeugung des Schemas nicht markiert werden.
Die eindeutige Eigenschaft ermöglicht Spalten, die nur eindeutige Werte enthalten.
Erstellen Sie eine Anwendungsklasse:
Schließlich erstellen wir die main () -Methode der Anwendungsklasse, um die Anwendung auszuführen. Wir werden diese App verwenden, um einige Mitarbeiterdatensätze zu sparen, und beantragen dann Aufzeichnungen zu CRUD -Operationen.
importieren java.util.list; Import Java.util.date; Import Java.util.iterator; import org.hibernate.hibernateException; import org.hibernate.session; import org.hibernate.transaction; import org.hibernate.cfg.annotationConfiguration; import org.hibernate.sessionFactory; public static void main (String [] args) {try {factory = new AnnotationConfiguration (). konfigurieren(). //addpackage("com.xyz ") // Paket hinzufügen, falls sie verwendet werden. AddannotatedClass (Mitarbeiter.Class). 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", 1000); Ganzzahl empid2 = me.addOPhPer ("Daisy", "Das", 5000); Ganzzahl empid3 = me.addEmPl ("John", "Paul", 10000); / * Auflisten Sie alle Mitarbeiter auf */ me.listOplomee (); / * Aktualisieren der Aufzeichnungen des Mitarbeiters */ me.updateOper (empid1, 5000); / * Einen Mitarbeiter aus der Datenbank löschen */ me.deleteEMple (empid2); / * LISTE neue Liste der Mitarbeiter */ me.listOplepel (); } / * 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 (); Mitarbeiter Mitarbeiter Mitarbeiter = neuer Mitarbeiter (); Mitarbeiter.SetFirstName (fname); Mitarbeiter.SetLastName (lname); Mitarbeiter.SetSalary (Gehalt); EmployeEID = (Integer) Sitzung.Save (Mitarbeiter); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E. printstacktrace (); } endlich {Session.close (); } Return EmployeEID; } / * Methode, um alle Mitarbeiter zu lesen Transaktion TX = NULL; try {tx = session.beginTransaction (); List Employees = Session.createquery ("From Employee"). 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 (); }} / * Methode zur Aktualisierung des Gehalts für einen Mitarbeiter * / public void updatePoperee (Integer EmployeeId, Int -Gehalt) {Session Session = Factory.OpenSession (); Transaktion TX = NULL; try {tx = session.beginTransaction (); Arbeitnehmermitarbeiter Mitarbeiter = (Mitarbeiter) Sitzung.get (Mitarbeiter.Class, EmployeeId); Mitarbeiter.SetSalary (Gehalt); Sitzung.Update (Mitarbeiter); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E. printstacktrace (); } endlich {Session.close (); }} / * Methode zum Löschen eines Mitarbeiters aus den Datensätzen * / public void DeletePoepoMeee (Integer EmployeeID) {session session = factory.openSession (); Transaktion TX = NULL; try {tx = session.beginTransaction (); Arbeitnehmermitarbeiter Mitarbeiter = (Mitarbeiter) Sitzung.get (Mitarbeiter.Class, EmployeeId); Sitzung.Delete (Mitarbeiter); tx.commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E. printstacktrace (); } endlich {Session.close (); }}} Datenbankkonfiguration:
Lassen Sie uns nun eine Konfigurationsdatei hibernate.cfg.xml erstellen, um die relevanten Parameter der Datenbank zu definieren.
<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> <property name = "hibernate.connection.password"> cohondob </property> </session-factory> </hibernate-Configuration>
Kompilieren und ausführen:
Hier sind die Schritte zum Kompilieren und Ausführen der obigen Anwendung. Stellen Sie sicher, dass dieser Pfad und der Klassenpfad vor dem Zusammenstellen und Ausführen entsprechend eingestellt sind.
Entfernen Sie die Mapping -Datei der Mitarbeiter.hbm.xml vom Pfad.
Erstellen Sie die Quelldatei von Employee.java, wie im obigen Bild gezeigt, und kompilieren Sie sie.
Erstellen Sie die Quelldatei "ManagyePoepopoPoEtraPoeee.java", wie im obigen Bild gezeigt, und kompilieren Sie sie.
Führen Sie die Binärdatei verwalten, um das Programm auszuführen.
Die folgenden Ergebnisse werden erzielt und die Aufzeichnungen werden in der Mitarbeitertabelle angezeigt.
$java ManageEmployee.........VARIOUS LOG MESSAGES WILL DISPLAY HERE.........First Name: Zara Last Name: Ali Salary: 1000First Name: Daisy Last Name: Das Salary: 5000First Name: John Last Name: Paul Salary: 10000First Name: Zara Last Name: Ali Salary: 5000First Name: John Last Name: Paul Salary: 10000
Wenn Sie die Mitarbeitertabelle überprüfen, sollten die folgenden Aufzeichnungen vorhanden sind:
MySQL> SELECT * vom Mitarbeiter;+----+------------+-----------+--------+| id | First_Name | last_name | Gehalt |+----+------------+-----------+--------+| 29 | Zara | Ali | 5000 || 31 | John | Paul | 10000 |+----+------------+-----------+--------+2 Zeilen in Set (0,00 Secysql>
Cache
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:
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.
Dieser Code verwendet eine Methode, um Hibernate zu sagen, dass sie Abfragen zu Mitarbeitern im Cache speichern und finden sollen.