Ruhezustand - Kurzanleitung

Was ist JDBC?

JDBC steht für Java Database Connectivity. Es bietet eine Reihe von Java-APIs für den Zugriff auf die relationalen Datenbanken über ein Java-Programm. Mit diesen Java-APIs können Java-Programme SQL-Anweisungen ausführen und mit jeder SQL-kompatiblen Datenbank interagieren.

JDBC bietet eine flexible Architektur zum Schreiben einer datenbankunabhängigen Anwendung, die auf verschiedenen Plattformen ausgeführt werden und ohne Änderungen mit verschiedenen DBMS interagieren kann.

Vor- und Nachteile von JDBC

Vorteile von JDBC	Nachteile von JDBC
Saubere und einfache SQL-Verarbeitung Gute Leistung bei großen Datenmengen Sehr gut für kleine Anwendungen Einfache Syntax so einfach zu erlernen	Komplex, wenn es in großen Projekten verwendet wird Großer Programmieraufwand Keine Einkapselung Schwer zu implementierendes MVC-Konzept Die Abfrage ist DBMS-spezifisch

Warum Object Relational Mapping (ORM)?

Wenn wir mit einem objektorientierten System arbeiten, besteht eine Nichtübereinstimmung zwischen dem Objektmodell und der relationalen Datenbank. RDBMS stellen Daten in einem Tabellenformat dar, während objektorientierte Sprachen wie Java oder C # sie als miteinander verbundene Diagramme von Objekten darstellen.

Betrachten Sie die folgende Java-Klasse mit geeigneten Konstruktoren und zugehöriger öffentlicher Funktion:

public class Employee {
   private int id;
   private String first_name; 
   private String last_name;   
   private int salary;  

   public Employee() {}
   public Employee(String fname, String lname, int salary) {
      this.first_name = fname;
      this.last_name = lname;
      this.salary = salary;
   }
   
   public int getId() {
      return id;
   }
   
   public String getFirstName() {
      return first_name;
   }
   
   public String getLastName() {
      return last_name;
   }
   
   public int getSalary() {
      return salary;
   }
}

Beachten Sie, dass die oben genannten Objekte gespeichert und in der folgenden RDBMS-Tabelle abgerufen werden sollen.

create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

Erstes Problem: Was ist, wenn wir das Design unserer Datenbank ändern müssen, nachdem wir einige Seiten oder unsere Anwendung entwickelt haben? Zweitens sind wir beim Laden und Speichern von Objekten in einer relationalen Datenbank den folgenden fünf Nichtübereinstimmungsproblemen ausgesetzt:

Sr.Nr.	Nichtübereinstimmung & Beschreibung
1	Granularity Manchmal haben Sie ein Objektmodell, das mehr Klassen als die Anzahl der entsprechenden Tabellen in der Datenbank enthält.
2	Inheritance RDBMS definieren nichts Ähnliches wie Vererbung, ein natürliches Paradigma in objektorientierten Programmiersprachen.
3	Identity Ein RDBMS definiert genau einen Begriff von "Gleichheit": den Primärschlüssel. Java definiert jedoch sowohl die Objektidentität (a == b) als auch die Objektgleichheit (a.equals (b)).
4	Associations Objektorientierte Sprachen repräsentieren Assoziationen unter Verwendung von Objektreferenzen, während ein RDBMS eine Assoziation als Fremdschlüsselspalte darstellt.
5	Navigation Die Art und Weise, wie Sie auf Objekte in Java und in RDBMS zugreifen, unterscheidet sich grundlegend.

Das OObjekt-Relational MApping (ORM) ist die Lösung, um alle oben genannten Impedanzfehlanpassungen zu behandeln.

Was ist ORM?

ORM steht für OObjekt-Relational MApping (ORM) ist eine Programmiertechnik zum Konvertieren von Daten zwischen relationalen Datenbanken und objektorientierten Programmiersprachen wie Java, C # usw.

Ein ORM-System bietet gegenüber einfachem JDBC die folgenden Vorteile:

Sr.Nr.	Vorteile
1	Lassen Sie uns eher auf Geschäftscode-Zugriffsobjekte als auf DB-Tabellen zugreifen.
2	Blendet Details von SQL-Abfragen vor der OO-Logik aus.
3	Basierend auf JDBC "unter der Haube".
4	Sie müssen sich nicht mit der Datenbankimplementierung befassen.
5	Entitäten, die eher auf Geschäftskonzepten als auf Datenbankstrukturen basieren.
6	Transaktionsmanagement und automatische Schlüsselgenerierung.
7	Schnelle Anwendungsentwicklung.

Eine ORM-Lösung besteht aus den folgenden vier Entitäten:

Sr.Nr.	Lösungen
1	Eine API zum Ausführen grundlegender CRUD-Operationen für Objekte persistenter Klassen.
2	Eine Sprache oder API zum Angeben von Abfragen, die sich auf Klassen und Eigenschaften von Klassen beziehen.
3	Eine konfigurierbare Funktion zum Festlegen von Zuordnungsmetadaten.
4	Eine Technik zur Interaktion mit Transaktionsobjekten, um Dirty Checking, Lazy Association Fetching und andere Optimierungsfunktionen durchzuführen.

Java ORM Frameworks

In Java gibt es mehrere dauerhafte Frameworks und ORM-Optionen. Ein beständiges Framework ist ein ORM-Dienst, der Objekte in einer relationalen Datenbank speichert und abruft.

Enterprise JavaBeans Entity Beans
Java-Datenobjekte
Castor
TopLink
Frühling DAO
Hibernate
Und viele mehr

Ruhezustand ist ein OObjekt-Relational MApping (ORM) -Lösung für JAVA. Es handelt sich um ein Open-Source-Persistent-Framework, das 2001 von Gavin King erstellt wurde. Es ist ein leistungsstarker, leistungsstarker Dienst für objektrelationale Persistenz und Abfrage für jede Java-Anwendung.

Der Ruhezustand ordnet Java-Klassen Datenbanktabellen und von Java-Datentypen SQL-Datentypen zu und entlastet den Entwickler von 95% der gängigen Programmieraufgaben im Zusammenhang mit der Datenpersistenz.

Der Ruhezustand befindet sich zwischen herkömmlichen Java-Objekten und dem Datenbankserver, um alle Arbeiten zum Fortbestehen dieser Objekte basierend auf den entsprechenden O / R-Mechanismen und -Mustern durchzuführen.

Vorteile im Ruhezustand

Hibernate sorgt dafür, dass Java-Klassen mithilfe von XML-Dateien und ohne Schreiben einer Codezeile Datenbanktabellen zugeordnet werden.
Bietet einfache APIs zum Speichern und Abrufen von Java-Objekten direkt in und aus der Datenbank.
Wenn sich Änderungen in der Datenbank oder in einer Tabelle ergeben, müssen Sie nur die Eigenschaften der XML-Datei ändern.
Entfernt die unbekannten SQL-Typen und bietet eine Möglichkeit, vertraute Java-Objekte zu umgehen.
Für den Ruhezustand ist kein Anwendungsserver erforderlich.
Manipuliert komplexe Zuordnungen von Objekten Ihrer Datenbank.
Minimiert den Datenbankzugriff mit intelligenten Abrufstrategien.
Bietet eine einfache Abfrage von Daten.

Unterstützte Datenbanken

Der Ruhezustand unterstützt fast alle wichtigen RDBMS. Im Folgenden finden Sie eine Liste einiger von Hibernate unterstützter Datenbankmodule:

HSQL-Datenbankmodul
DB2/NT
MySQL
PostgreSQL
FrontBase
Oracle
Microsoft SQL Server-Datenbank
Sybase SQL Server
Informix Dynamic Server

Unterstützte Technologien

Hibernate unterstützt eine Vielzahl anderer Technologien, darunter -

XDoclet-Feder
J2EE
Eclipse-Plug-Ins
Maven

Hibernate verfügt über eine mehrschichtige Architektur, mit der der Benutzer arbeiten kann, ohne die zugrunde liegenden APIs kennen zu müssen. Hibernate verwendet die Datenbank- und Konfigurationsdaten, um der Anwendung Persistenzdienste (und persistente Objekte) bereitzustellen.

Im Folgenden finden Sie eine sehr allgemeine Ansicht der Hibernate-Anwendungsarchitektur.

Im Folgenden finden Sie eine detaillierte Ansicht der Hibernate-Anwendungsarchitektur mit ihren wichtigen Kernklassen.

Hibernate verwendet verschiedene vorhandene Java-APIs wie JDBC, Java Transaction API (JTA) und Java Naming and Directory Interface (JNDI). JDBC bietet eine rudimentäre Abstraktionsebene für Funktionen, die relationalen Datenbanken gemeinsam sind, sodass nahezu jede Datenbank mit einem JDBC-Treiber von Hibernate unterstützt werden kann. Mit JNDI und JTA kann Hibernate in J2EE-Anwendungsserver integriert werden.

Der folgende Abschnitt enthält eine kurze Beschreibung aller Klassenobjekte, die an der Hibernate Application Architecture beteiligt sind.

Konfigurationsobjekt

Das Konfigurationsobjekt ist das erste Ruhezustand-Objekt, das Sie in einer Ruhezustand-Anwendung erstellen. Es wird normalerweise nur einmal während der Anwendungsinitialisierung erstellt. Es stellt eine Konfigurations- oder Eigenschaftendatei dar, die vom Ruhezustand benötigt wird.

Das Konfigurationsobjekt enthält zwei Schlüsselkomponenten:

Database Connection- Dies erfolgt über eine oder mehrere Konfigurationsdateien, die von Hibernate unterstützt werden. Diese Dateien sindhibernate.properties und hibernate.cfg.xml.
Class Mapping Setup - Diese Komponente stellt die Verbindung zwischen den Java-Klassen und den Datenbanktabellen her.

SessionFactory-Objekt

Das Konfigurationsobjekt wird verwendet, um ein SessionFactory-Objekt zu erstellen, das wiederum den Ruhezustand für die Anwendung unter Verwendung der mitgelieferten Konfigurationsdatei konfiguriert und die Instanziierung eines Sitzungsobjekts ermöglicht. Die SessionFactory ist ein threadsicheres Objekt und wird von allen Threads einer Anwendung verwendet.

Die SessionFactory ist ein schwergewichtiges Objekt. Es wird normalerweise beim Start der Anwendung erstellt und für die spätere Verwendung aufbewahrt. Sie benötigen ein SessionFactory-Objekt pro Datenbank mit einer separaten Konfigurationsdatei. Wenn Sie also mehrere Datenbanken verwenden, müssen Sie mehrere SessionFactory-Objekte erstellen.

Sitzungsobjekt

Eine Sitzung wird verwendet, um eine physische Verbindung mit einer Datenbank herzustellen. Das Session-Objekt ist leichtgewichtig und kann jedes Mal instanziiert werden, wenn eine Interaktion mit der Datenbank erforderlich ist. Persistente Objekte werden über ein Sitzungsobjekt gespeichert und abgerufen.

Die Sitzungsobjekte sollten nicht lange offen gehalten werden, da sie normalerweise nicht threadsicher sind und sie nach Bedarf erstellt und zerstört werden sollten.

Transaktionsobjekt

Eine Transaktion stellt eine Arbeitseinheit mit der Datenbank dar und der größte Teil des RDBMS unterstützt die Transaktionsfunktionalität. Transaktionen im Ruhezustand werden von einem zugrunde liegenden Transaktionsmanager und einer zugrunde liegenden Transaktion (von JDBC oder JTA) abgewickelt.

Dies ist ein optionales Objekt, und Hibernate-Anwendungen verwenden diese Schnittstelle möglicherweise nicht, sondern verwalten Transaktionen in ihrem eigenen Anwendungscode.

Objekt abfragen

Abfrageobjekte verwenden eine SQL- oder HQL-Zeichenfolge (Hibernate Query Language), um Daten aus der Datenbank abzurufen und Objekte zu erstellen. Eine Abfrageinstanz wird verwendet, um Abfrageparameter zu binden, die Anzahl der von der Abfrage zurückgegebenen Ergebnisse zu begrenzen und schließlich die Abfrage auszuführen.

Kriterienobjekt

Kriterienobjekte werden zum Erstellen und Ausführen objektorientierter Kriterienabfragen zum Abrufen von Objekten verwendet.

In diesem Kapitel wird erläutert, wie Sie Hibernate und andere zugehörige Pakete installieren, um eine Umgebung für die Hibernate-Anwendungen vorzubereiten. Wir werden mit der MySQL-Datenbank arbeiten, um mit Beispielen für den Ruhezustand zu experimentieren. Stellen Sie daher sicher, dass Sie bereits ein Setup für die MySQL-Datenbank haben. Weitere Informationen zu MySQL finden Sie in unserem MySQL-Tutorial .

Hibernate herunterladen

Es wird davon ausgegangen, dass Sie bereits die neueste Version von Java auf Ihrem System installiert haben. Im Folgenden finden Sie die einfachen Schritte zum Herunterladen und Installieren von Hibernate auf Ihrem System:

Treffen Sie eine Auswahl, ob Sie Hibernate unter Windows oder Unix installieren möchten, und fahren Sie dann mit dem nächsten Schritt fort, um die ZIP-Datei für Windows und die ZZ-Datei für Unix herunterzuladen.
Laden Sie die neueste Version von Hibernate von herunter http://www.hibernate.org/downloads.
Zum Zeitpunkt des Schreibens dieses Tutorials habe ich heruntergeladen hibernate-distribution3.6.4.Final Wenn Sie die heruntergeladene Datei entpacken, erhalten Sie die Verzeichnisstruktur wie in der folgenden Abbildung gezeigt

Hibernate installieren

Nachdem Sie die neueste Version der Hibernate-Installationsdatei heruntergeladen und entpackt haben, müssen Sie die folgenden zwei einfachen Schritte ausführen. Stellen Sie sicher, dass Sie Ihre CLASSPATH-Variable richtig einstellen, da sonst beim Kompilieren Ihrer Anwendung Probleme auftreten.

Kopieren Sie nun alle Bibliotheksdateien von /lib in Ihren CLASSPATH und ändern Sie Ihre Klassenpfadvariable so, dass alle JARs enthalten sind -
Zum Schluss kopieren hibernate3.jarDatei in Ihren CLASSPATH. Diese Datei befindet sich im Stammverzeichnis der Installation und ist die primäre JAR, die Hibernate für seine Arbeit benötigt.

Voraussetzungen für den Ruhezustand

Im Folgenden finden Sie eine Liste der Pakete / Bibliotheken, die für den Ruhezustand erforderlich sind. Sie sollten sie installieren, bevor Sie mit dem Ruhezustand beginnen. Um diese Pakete zu installieren, müssen Sie Bibliotheksdateien von kopieren/lib in Ihren CLASSPATH und ändern Sie Ihre CLASSPATH-Variable entsprechend.

Sr.Nr.	Pakete / Bibliotheken
1	dom4j XML-Analyse www.dom4j.org/
2	Xalan XSLT-Prozessor https://xml.apache.org/xalan-j/
3	Xerces Der Xerces Java Parser https://xml.apache.org/xerces-j/
4	cglib Angemessene Änderungen an Java-Klassen zur Laufzeit http://cglib.sourceforge.net/
5	log4j Protokollierung von Faremwork https://logging.apache.org/log4j
6	Commons Protokollierung, E-Mail usw. https://jakarta.apache.org/commons
7	SLF4J Protokollierungsfassade für Java https://www.slf4j.org

Für den Ruhezustand muss im Voraus bekannt sein, wo sich die Zuordnungsinformationen befinden, die definieren, wie sich Ihre Java-Klassen auf die Datenbanktabellen beziehen. Für den Ruhezustand sind außerdem eine Reihe von Konfigurationseinstellungen erforderlich, die sich auf die Datenbank und andere verwandte Parameter beziehen. Alle diese Informationen werden normalerweise als Standard-Java-Eigenschaftendatei mit dem Namen bereitgestellthibernate.propertiesoder als XML-Datei mit dem Namen hibernate.cfg.xml.

Ich werde XML-formatierte Datei betrachten hibernate.cfg.xmlum die erforderlichen Eigenschaften für den Ruhezustand in meinen Beispielen anzugeben. Die meisten Eigenschaften nehmen ihre Standardwerte an und müssen nicht in der Eigenschaftendatei angegeben werden, es sei denn, dies ist wirklich erforderlich. Diese Datei befindet sich im Stammverzeichnis des Klassenpfads Ihrer Anwendung.

Eigenschaften für den Ruhezustand

Im Folgenden finden Sie eine Liste wichtiger Eigenschaften, die Sie in einer eigenständigen Situation für eine Datenbank konfigurieren müssen.

Sr.Nr.	Eigenschaften & Beschreibung
1	hibernate.dialect Mit dieser Eigenschaft generiert Hibernate das entsprechende SQL für die ausgewählte Datenbank.
2	hibernate.connection.driver_class Die JDBC-Treiberklasse.
3	hibernate.connection.url Die JDBC-URL zur Datenbankinstanz.
4	hibernate.connection.username Der Datenbank-Benutzername.
5	hibernate.connection.password Das Datenbankkennwort.
6	hibernate.connection.pool_size Begrenzt die Anzahl der Verbindungen, die im Verbindungspool der Hibernate-Datenbank warten.
7	hibernate.connection.autocommit Ermöglicht die Verwendung des Autocommit-Modus für die JDBC-Verbindung.

Wenn Sie eine Datenbank zusammen mit einem Anwendungsserver und JNDI verwenden, müssen Sie die folgenden Eigenschaften konfigurieren:

Sr.Nr.	Eigenschaften & Beschreibung
1	hibernate.connection.datasource Der im Anwendungsserverkontext definierte JNDI-Name, den Sie für die Anwendung verwenden.
2	hibernate.jndi.class Die InitialContext-Klasse für JNDI.
3	hibernate.jndi.<JNDIpropertyname> Übergibt eine beliebige JNDI-Eigenschaft an den JNDI InitialContext .
4	hibernate.jndi.url Stellt die URL für JNDI bereit.
5	hibernate.connection.username Der Datenbank-Benutzername.
6	hibernate.connection.password Das Datenbankkennwort.

Ruhezustand mit MySQL-Datenbank

MySQL ist eines der beliebtesten Open-Source-Datenbanksysteme, die heute verfügbar sind. Lasst uns erschaffenhibernate.cfg.xmlKonfigurationsdatei und platzieren Sie sie im Stammverzeichnis des Klassenpfads Ihrer Anwendung. Sie müssen sicherstellen, dass Sie habentestdb Datenbank in Ihrer MySQL-Datenbank verfügbar und Sie haben einen Benutzer test verfügbar, um auf die Datenbank zuzugreifen.

Die XML-Konfigurationsdatei muss mit der Hibernate 3-Konfigurations-DTD übereinstimmen, die unter verfügbar ist http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd.

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM 
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
   <session-factory>
   
      <property name = "hibernate.dialect">
         org.hibernate.dialect.MySQLDialect
      </property>
      
      <property name = "hibernate.connection.driver_class">
         com.mysql.jdbc.Driver
      </property>
      
      <!-- Assume test is the database name -->
      
      <property name = "hibernate.connection.url">
         jdbc:mysql://localhost/test
      </property>
      
      <property name = "hibernate.connection.username">
         root
      </property>
      
      <property name = "hibernate.connection.password">
         root123
      </property>
      
      <!-- List of XML mapping files -->
      <mapping resource = "Employee.hbm.xml"/>
      
   </session-factory>
</hibernate-configuration>

Die obige Konfigurationsdatei enthält <mapping> Tags, die sich auf die Hibernatemapping-Datei beziehen, und wir werden im nächsten Kapitel sehen, was genau eine Hibernat-Mapping-Datei ist und wie und warum wir sie verwenden.

Im Folgenden finden Sie eine Liste verschiedener wichtiger Dialekt-Eigenschaftstypen für Datenbanken.

Sr.Nr.	Datenbank- und Dialekteigenschaft
1	DB2 org.hibernate.dialect.DB2Dialect
2	HSQLDB org.hibernate.dialect.HSQLDialect
3	HypersonicSQL org.hibernate.dialect.HSQLDialect
4	Informix org.hibernate.dialect.InformixDialect
5	Ingres org.hibernate.dialect.IngresDialect
6	Interbase org.hibernate.dialect.InterbaseDialect
7	Microsoft SQL Server 2000 org.hibernate.dialect.SQLServerDialect
8	Microsoft SQL Server 2005 org.hibernate.dialect.SQLServer2005Dialect
9	Microsoft SQL Server 2008 org.hibernate.dialect.SQLServer2008Dialect
10	MySQL org.hibernate.dialect.MySQLDialect
11	Oracle (any version) org.hibernate.dialect.OracleDialect
12	Oracle 11g org.hibernate.dialect.Oracle10gDialect
13	Oracle 10g org.hibernate.dialect.Oracle10gDialect
14	Oracle 9i org.hibernate.dialect.Oracle9iDialect
15	PostgreSQL org.hibernate.dialect.PostgreSQLDialect
16	Progress org.hibernate.dialect.ProgressDialect
17	SAP DB org.hibernate.dialect.SAPDBDialect
18	Sybase org.hibernate.dialect.SybaseDialect
19	Sybase Anywhere org.hibernate.dialect.SybaseAnywhereDialect

Die Sitzungsobjekte sollten nicht lange offen gehalten werden, da sie normalerweise nicht threadsicher sind und sie nach Bedarf erstellt und zerstört werden sollten. Die Hauptfunktion der Sitzung besteht darin, Operationen für Instanzen zugeordneter Entitätsklassen anzubieten, zu erstellen, zu lesen und zu löschen.

Instanzen können zu einem bestimmten Zeitpunkt in einem der folgenden drei Zustände existieren -

transient - Eine neue Instanz einer persistenten Klasse, die keiner Sitzung zugeordnet ist und keine Darstellung in der Datenbank hat und keinen Bezeichnerwert hat, wird von Hibernate als vorübergehend angesehen.
persistent- Sie können eine vorübergehende Instanz dauerhaft machen, indem Sie sie einer Sitzung zuordnen. Eine persistente Instanz hat eine Darstellung in der Datenbank, einen Bezeichnerwert und ist einer Sitzung zugeordnet.
detached - Sobald wir die Ruhezustandssitzung schließen, wird die persistente Instanz zu einer getrennten Instanz.

Eine Sitzungsinstanz ist serialisierbar, wenn ihre persistenten Klassen serialisierbar sind. Eine typische Transaktion sollte die folgende Redewendung verwenden:

Session session = factory.openSession();
Transaction tx = null;

try {
   tx = session.beginTransaction();
   // do some work
   ...
   tx.commit();
}

catch (Exception e) {
   if (tx!=null) tx.rollback();
   e.printStackTrace(); 
} finally {
   session.close();
}

Wenn die Sitzung eine Ausnahme auslöst, muss die Transaktion zurückgesetzt und die Sitzung verworfen werden.

Methoden der Sitzungsschnittstelle

Es gibt eine Reihe von Methoden, die von der SessionSchnittstelle, aber ich werde nur einige wichtige Methoden auflisten, die wir in diesem Tutorial verwenden werden. In der Dokumentation zum Ruhezustand finden Sie eine vollständige Liste der zugeordneten MethodenSession und SessionFactory.

Sr.Nr.	Sitzungsmethoden & Beschreibung
1	Transaction beginTransaction() Beginnen Sie eine Arbeitseinheit und geben Sie das zugehörige Transaktionsobjekt zurück.
2	void cancelQuery() Brechen Sie die Ausführung der aktuellen Abfrage ab.
3	void clear() Beenden Sie die Sitzung vollständig.
4	Connection close() Beenden Sie die Sitzung, indem Sie die JDBC-Verbindung trennen und bereinigen.
5	Criteria createCriteria(Class persistentClass) Erstellen Sie eine neue Kriterieninstanz für die angegebene Entitätsklasse oder eine Oberklasse einer Entitätsklasse.
6	Criteria createCriteria(String entityName) Erstellen Sie eine neue Kriterieninstanz für den angegebenen Entitätsnamen.
7	Serializable getIdentifier(Object object) Gibt den Bezeichnerwert der angegebenen Entität zurück, der dieser Sitzung zugeordnet ist.
8	Query createFilter(Object collection, String queryString) Erstellen Sie eine neue Instanz von Query für die angegebene Sammlung und Filterzeichenfolge.
9	Query createQuery(String queryString) Erstellen Sie eine neue Instanz von Query für die angegebene HQL-Abfragezeichenfolge.
10	SQLQuery createSQLQuery(String queryString) Erstellen Sie eine neue Instanz von SQLQuery für die angegebene SQL-Abfragezeichenfolge.
11	void delete(Object object) Entfernen Sie eine persistente Instanz aus dem Datenspeicher.
12	void delete(String entityName, Object object) Entfernen Sie eine persistente Instanz aus dem Datenspeicher.
13	Session get(String entityName, Serializable id) Gibt die persistente Instanz der angegebenen benannten Entität mit dem angegebenen Bezeichner zurück oder null, wenn keine solche persistente Instanz vorhanden ist.
14	SessionFactory getSessionFactory() Rufen Sie die Sitzungsfactory ab, die diese Sitzung erstellt hat.
15	void refresh(Object object) Lesen Sie den Status der angegebenen Instanz erneut aus der zugrunde liegenden Datenbank.
16	Transaction getTransaction() Rufen Sie die dieser Sitzung zugeordnete Transaktionsinstanz ab.
17	boolean isConnected() Überprüfen Sie, ob die Sitzung derzeit verbunden ist.
18	boolean isDirty() Enthält diese Sitzung Änderungen, die mit der Datenbank synchronisiert werden müssen?
19	boolean isOpen() Überprüfen Sie, ob die Sitzung noch geöffnet ist.
20	Serializable save(Object object) Behalten Sie die angegebene transiente Instanz bei und weisen Sie zuerst einen generierten Bezeichner zu.
21	void saveOrUpdate(Object object) Speichern oder aktualisieren Sie die angegebene Instanz entweder (Objekt) oder aktualisieren Sie sie (Objekt).
22	void update(Object object) Aktualisieren Sie die persistente Instanz mit der Kennung der angegebenen getrennten Instanz.
23	void update(String entityName, Object object) Aktualisieren Sie die persistente Instanz mit der Kennung der angegebenen getrennten Instanz.

Das gesamte Konzept von Hibernate besteht darin, die Werte aus Java-Klassenattributen in einer Datenbanktabelle zu speichern. Mithilfe eines Zuordnungsdokuments kann Hibernate bestimmen, wie die Werte aus den Klassen abgerufen und mit Tabellen und zugehörigen Feldern zugeordnet werden sollen.

Java-Klassen, deren Objekte oder Instanzen in Datenbanktabellen gespeichert werden, werden im Ruhezustand als persistente Klassen bezeichnet. Der Ruhezustand funktioniert am besten, wenn diese Klassen einigen einfachen Regeln folgen, die auch als bezeichnet werdenPlain Old Java Object (POJO) Programmiermodell.

Es gibt folgende Hauptregeln für persistente Klassen, jedoch ist keine dieser Regeln eine harte Anforderung -

Alle Java-Klassen, die beibehalten werden, benötigen einen Standardkonstruktor.
Alle Klassen sollten eine ID enthalten, damit Ihre Objekte im Ruhezustand und in der Datenbank leicht identifiziert werden können. Diese Eigenschaft wird der Primärschlüsselspalte einer Datenbanktabelle zugeordnet.
Alle Attribute, die beibehalten werden, sollten als privat deklariert werden und haben getXXX und setXXX Methoden, die im JavaBean-Stil definiert sind.
Ein zentrales Merkmal von Hibernate, Proxys, hängt davon ab, ob die persistente Klasse entweder nicht endgültig ist oder ob eine Schnittstelle implementiert wird, die alle öffentlichen Methoden deklariert.
Alle Klassen, die einige vom EJB-Framework geforderte spezielle Klassen und Schnittstellen nicht erweitern oder implementieren.

Der POJO-Name wird verwendet, um hervorzuheben, dass ein bestimmtes Objekt ein gewöhnliches Java-Objekt ist, kein spezielles Objekt und insbesondere keine Enterprise JavaBean.

Einfaches POJO-Beispiel

Basierend auf den wenigen oben genannten Regeln können wir eine POJO-Klasse wie folgt definieren:

public class Employee {
   private int id;
   private String firstName; 
   private String lastName;   
   private int salary;  

   public Employee() {}
   public Employee(String fname, String lname, int salary) {
      this.firstName = fname;
      this.lastName = lname;
      this.salary = salary;
   }
   
   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() {
      return salary;
   }
   
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Objekt- / relationale Zuordnungen werden normalerweise in einem XML-Dokument definiert. Diese Zuordnungsdatei weist Hibernate an, wie die definierte Klasse oder die definierten Klassen den Datenbanktabellen zugeordnet werden sollen.

Obwohl viele Benutzer im Ruhezustand das XML von Hand schreiben, gibt es eine Reihe von Tools zum Generieren des Zuordnungsdokuments. Diese schließen einXDoclet, Middlegen und AndroMDA für fortgeschrittene Benutzer im Ruhezustand.

Betrachten wir unsere zuvor definierte POJO-Klasse, deren Objekte in der im nächsten Abschnitt definierten Tabelle verbleiben.

public class Employee {
   private int id;
   private String firstName; 
   private String lastName;   
   private int salary;  

   public Employee() {}
   
   public Employee(String fname, String lname, int salary) {
      this.firstName = fname;
      this.lastName = lname;
      this.salary = salary;
   }
   
   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() {
      return salary;
   }
   
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Zu jedem Objekt, das Sie bereitstellen möchten, gibt es eine Tabelle. Beachten Sie, dass die oben genannten Objekte gespeichert und in der folgenden RDBMS-Tabelle abgerufen werden müssen.

create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

Basierend auf den beiden oben genannten Entitäten können wir die folgende Zuordnungsdatei definieren, die Hibernate anweist, wie die definierte Klasse oder die definierten Klassen den Datenbanktabellen zugeordnet werden sollen.

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 

<hibernate-mapping>
   <class name = "Employee" table = "EMPLOYEE">
      
      <meta attribute = "class-description">
         This class contains the employee detail. 
      </meta>
      
      <id name = "id" type = "int" column = "id">
         <generator class="native"/>
      </id>
      
      <property name = "firstName" column = "first_name" type = "string"/>
      <property name = "lastName" column = "last_name" type = "string"/>
      <property name = "salary" column = "salary" type = "int"/>
      
   </class>
</hibernate-mapping>

Sie sollten das Zuordnungsdokument in einer Datei mit dem Format <Klassenname> .hbm.xml speichern. Wir haben unser Zuordnungsdokument in der Datei Employee.hbm.xml gespeichert.

Lassen Sie uns ein kleines Detail über die in der Mapping-Datei verwendeten Mapping-Elemente verstehen -

Das Zuordnungsdokument ist ein XML-Dokument mit <hibernate-mapping> als Wurzelelement, das alle enthält <class> Elemente.
Das <class>Elemente werden verwendet, um bestimmte Zuordnungen von Java-Klassen zu den Datenbanktabellen zu definieren. Der Java-Klassenname wird mit dem angegebenname Attribut des Klassenelements und der Datenbank table Der Name wird mit dem Tabellenattribut angegeben.
Das <meta> element ist ein optionales Element und kann zum Erstellen der Klassenbeschreibung verwendet werden.
Das <id>element ordnet das eindeutige ID-Attribut in der Klasse dem Primärschlüssel der Datenbanktabelle zu. Dasname Das Attribut des ID-Elements bezieht sich auf die Eigenschaft in der Klasse und die columnAttribut bezieht sich auf die Spalte in der Datenbanktabelle. Dastype Das Attribut enthält den Zuordnungstyp für den Ruhezustand. Diese Zuordnungstypen werden vom Java- in den SQL-Datentyp konvertiert.
Das <generator>Element innerhalb des ID-Elements wird verwendet, um die Primärschlüsselwerte automatisch zu generieren. Dasclass Attribut des Generatorelements wird auf gesetzt native um den Winterschlaf auch aufnehmen zu lassen identity, sequence, oder hilo Algorithmus zum Erstellen eines Primärschlüssels in Abhängigkeit von den Funktionen der zugrunde liegenden Datenbank.
Das <property>Element wird verwendet, um eine Java-Klasseneigenschaft einer Spalte in der Datenbanktabelle zuzuordnen. Dasname Das Attribut des Elements bezieht sich auf die Eigenschaft in der Klasse und die columnAttribut bezieht sich auf die Spalte in der Datenbanktabelle. Dastype Das Attribut enthält den Zuordnungstyp für den Ruhezustand. Diese Zuordnungstypen werden vom Java- in den SQL-Datentyp konvertiert.

Es sind andere Attribute und Elemente verfügbar, die in einem Zuordnungsdokument verwendet werden. Ich würde versuchen, so viele wie möglich zu behandeln, während ich andere Themen im Zusammenhang mit dem Ruhezustand diskutiere.

Wenn Sie ein Hibernate-Zuordnungsdokument vorbereiten, stellen Sie fest, dass Sie die Java-Datentypen RDBMS-Datentypen zuordnen. Dastypesdeklariert und in den Zuordnungsdateien verwendet sind keine Java-Datentypen; Sie sind auch keine SQL-Datenbanktypen. Diese Typen werden aufgerufenHibernate mapping types, die von Java in SQL-Datentypen und umgekehrt übersetzt werden können.

In diesem Kapitel werden alle grundlegenden, Datums- und Uhrzeitangaben, großen Objekte und verschiedene andere integrierte Zuordnungstypen aufgelistet.

Primitive Typen

Zuordnungstyp	Java-Typ	ANSI SQL-Typ
ganze Zahl	int oder java.lang.Integer	GANZE ZAHL
lange	long oder java.lang.Long	BIGINT
kurz	kurz oder java.lang.Short	SMALLINT
schweben	float oder java.lang.Float	SCHWEBEN
doppelt	double oder java.lang.Double	DOPPELT
big_decimal	java.math.BigDecimal	NUMERISCH
Charakter	java.lang.String	CHAR (1)
Zeichenfolge	java.lang.String	VARCHAR
Byte	byte oder java.lang.Byte	Winzig
Boolescher Wert	boolean oder java.lang.Boolean	BISSCHEN
ja Nein	boolean oder java.lang.Boolean	CHAR (1) ('Y' oder 'N')
wahr falsch	boolean oder java.lang.Boolean	CHAR (1) ('T' oder 'F')

Datums- und Uhrzeittypen

Zuordnungstyp	Java-Typ	ANSI SQL-Typ
Datum	java.util.Date oder java.sql.Date	DATUM
Zeit	java.util.Date oder java.sql.Time	ZEIT
Zeitstempel	java.util.Date oder java.sql.Timestamp	TIMESTAMP
Kalender	java.util.Calendar	TIMESTAMP
Kalenderdatum	java.util.Calendar	DATUM

Binäre und große Objekttypen

Zuordnungstyp	Java-Typ	ANSI SQL-Typ
binär	Byte[]	VARBINARY (oder BLOB)
Text	java.lang.String	CLOB
serialisierbar	Jede Java-Klasse, die java.io.Serializable implementiert	VARBINARY (oder BLOB)
Clob	java.sql.Clob	CLOB
Klecks	java.sql.Blob	KLECKS

JDK-bezogene Typen

Zuordnungstyp	Java-Typ	ANSI SQL-Typ
Klasse	java.lang.Class	VARCHAR
Gebietsschema	java.util.Locale	VARCHAR
Zeitzone	java.util.TimeZone	VARCHAR
Währung	java.util.Currency	VARCHAR

Nehmen wir nun ein Beispiel, um zu verstehen, wie wir Hibernate verwenden können, um Java-Persistenz in einer eigenständigen Anwendung bereitzustellen. Wir werden die verschiedenen Schritte zum Erstellen einer Java-Anwendung mithilfe der Hibernate-Technologie durchgehen.

Erstellen Sie POJO-Klassen

Der erste Schritt beim Erstellen einer Anwendung besteht darin, die Java-POJO-Klasse oder -Klassen zu erstellen, abhängig von der Anwendung, die in der Datenbank beibehalten wird. Betrachten wir unsereEmployee Klasse mit getXXX und setXXX Methoden, um es JavaBeans-kompatible Klasse zu machen.

Ein POJO (Plain Old Java Object) ist ein Java-Objekt, das einige spezielle Klassen und Schnittstellen, die vom EJB-Framework benötigt werden, nicht erweitert oder implementiert. Alle normalen Java-Objekte sind POJO.

Wenn Sie eine Klasse entwerfen, die von Hibernate beibehalten werden soll, ist es wichtig, JavaBeans-kompatiblen Code sowie ein Attribut bereitzustellen, das wie ein Index funktioniert id Attribut in der Employee-Klasse.

public class Employee {
   private int id;
   private String firstName; 
   private String lastName;   
   private int salary;  

   public Employee() {}
   public Employee(String fname, String lname, int salary) {
      this.firstName = fname;
      this.lastName = lname;
      this.salary = salary;
   }
   
   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() {
      return salary;
   }
   
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Erstellen Sie Datenbanktabellen

Der zweite Schritt wäre das Erstellen von Tabellen in Ihrer Datenbank. Es würde eine Tabelle geben, die jedem Objekt entspricht. Sie sind bereit, Persistenz bereitzustellen. Beachten Sie, dass die oben genannten Objekte gespeichert und in der folgenden RDBMS-Tabelle abgerufen werden müssen.

create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

Erstellen Sie eine Zuordnungskonfigurationsdatei

In diesem Schritt wird eine Zuordnungsdatei erstellt, die Hibernate anweist, wie die definierte Klasse oder die definierten Klassen den Datenbanktabellen zugeordnet werden sollen.

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 

<hibernate-mapping>
   <class name = "Employee" table = "EMPLOYEE">
      
      <meta attribute = "class-description">
         This class contains the employee detail. 
      </meta>
      
      <id name = "id" type = "int" column = "id">
         <generator class="native"/>
      </id>
      
      <property name = "firstName" column = "first_name" type = "string"/>
      <property name = "lastName" column = "last_name" type = "string"/>
      <property name = "salary" column = "salary" type = "int"/>
      
   </class>
</hibernate-mapping>

Sie sollten das Zuordnungsdokument in einer Datei mit dem Format <Klassenname> .hbm.xml speichern. Wir haben unser Zuordnungsdokument in der Datei Employee.hbm.xml gespeichert. Lassen Sie uns wenig Details über das Kartendokument sehen -

Das Zuordnungsdokument ist ein XML-Dokument mit <Hibernate-Mapping> als Stammelement, das alle <Klassen> -Elemente enthält.
Das <class>Elemente werden verwendet, um bestimmte Zuordnungen von Java-Klassen zu den Datenbanktabellen zu definieren. Der Java-Klassenname wird mit dem angegebenname Das Attribut des Klassenelements und der Name der Datenbanktabelle werden mit dem angegeben table Attribut.
Das <meta> element ist ein optionales Element und kann zum Erstellen der Klassenbeschreibung verwendet werden.
Das <id>element ordnet das eindeutige ID-Attribut in der Klasse dem Primärschlüssel der Datenbanktabelle zu. Dasname Das Attribut des ID-Elements bezieht sich auf die Eigenschaft in der Klasse und die columnAttribut bezieht sich auf die Spalte in der Datenbanktabelle. Dastype Das Attribut enthält den Zuordnungstyp für den Ruhezustand. Diese Zuordnungstypen werden vom Java- in den SQL-Datentyp konvertiert.
Das <generator>Element innerhalb des ID-Elements wird verwendet, um die Primärschlüsselwerte automatisch zu generieren. Dasclass Attribut des Generatorelements wird auf gesetzt native um den Winterschlaf auch aufnehmen zu lassen identity, sequence oder hilo Algorithmus zum Erstellen eines Primärschlüssels in Abhängigkeit von den Funktionen der zugrunde liegenden Datenbank.
Das <property>Element wird verwendet, um eine Java-Klasseneigenschaft einer Spalte in der Datenbanktabelle zuzuordnen. Dasname Das Attribut des Elements bezieht sich auf die Eigenschaft in der Klasse und die columnAttribut bezieht sich auf die Spalte in der Datenbanktabelle. Dastype Das Attribut enthält den Zuordnungstyp für den Ruhezustand. Diese Zuordnungstypen werden vom Java- in den SQL-Datentyp konvertiert.

Anwendungsklasse erstellen

Schließlich erstellen wir unsere Anwendungsklasse mit der main () -Methode, um die Anwendung auszuführen. Wir werden diese Anwendung verwenden, um einige Mitarbeiterdatensätze zu speichern, und dann werden wir CRUD-Operationen auf diese Datensätze anwenden.

import 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.SessionFactory;
import org.hibernate.cfg.Configuration;

public class ManageEmployee {
   private static SessionFactory factory; 
   public static void main(String[] args) {
      
      try {
         factory = new Configuration().configure().buildSessionFactory();
      } catch (Throwable ex) { 
         System.err.println("Failed to create sessionFactory object." + ex);
         throw new ExceptionInInitializerError(ex); 
      }
      
      ManageEmployee ME = new ManageEmployee();

      /* Add few employee records in database */
      Integer empID1 = ME.addEmployee("Zara", "Ali", 1000);
      Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
      Integer empID3 = ME.addEmployee("John", "Paul", 10000);

      /* List down all the employees */
      ME.listEmployees();

      /* Update employee's records */
      ME.updateEmployee(empID1, 5000);

      /* Delete an employee from the database */
      ME.deleteEmployee(empID2);

      /* List down new list of the employees */
      ME.listEmployees();
   }
   
   /* Method to CREATE an employee in the database */
   public Integer addEmployee(String fname, String lname, int salary){
      Session session = factory.openSession();
      Transaction tx = null;
      Integer employeeID = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = new Employee(fname, lname, salary);
         employeeID = (Integer) session.save(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
      return employeeID;
   }
   
   /* Method to  READ all the employees */
   public void listEmployees( ){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         List employees = session.createQuery("FROM Employee").list(); 
         for (Iterator iterator = employees.iterator(); iterator.hasNext();){
            Employee employee = (Employee) iterator.next(); 
            System.out.print("First Name: " + employee.getFirstName()); 
            System.out.print("  Last Name: " + employee.getLastName()); 
            System.out.println("  Salary: " + employee.getSalary()); 
         }
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
   
   /* Method to UPDATE salary for an employee */
   public void updateEmployee(Integer EmployeeID, int salary ){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = (Employee)session.get(Employee.class, EmployeeID); 
         employee.setSalary( salary );
		 session.update(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
   
   /* Method to DELETE an employee from the records */
   public void deleteEmployee(Integer EmployeeID){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = (Employee)session.get(Employee.class, EmployeeID); 
         session.delete(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
}

Zusammenstellung und Ausführung

Hier sind die Schritte zum Kompilieren und Ausführen der oben genannten Anwendung. Stellen Sie sicher, dass Sie PATH und CLASSPATH entsprechend eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.

Erstellen Sie die Konfigurationsdatei hibernate.cfg.xml wie im Konfigurationskapitel erläutert.
Erstellen Sie die Zuordnungsdatei Employee.hbm.xml wie oben gezeigt.
Erstellen Sie die Employee.java-Quelldatei wie oben gezeigt und kompilieren Sie sie.
Erstellen Sie die Quelldatei ManageEmployee.java wie oben gezeigt und kompilieren Sie sie.
Führen Sie die ManageEmployee-Binärdatei aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten und Datensätze in der Tabelle EMPLOYEE erstellt.

$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........

First Name: Zara  Last Name: Ali  Salary: 1000
First Name: Daisy  Last Name: Das  Salary: 5000
First Name: John  Last Name: Paul  Salary: 10000
First Name: Zara  Last Name: Ali  Salary: 5000
First Name: John  Last Name: Paul  Salary: 10000

Wenn Sie Ihre EMPLOYEE-Tabelle überprüfen, sollte sie die folgenden Datensätze enthalten:

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 29 | Zara       | Ali       |   5000 |
| 31 | John       | Paul      |  10000 |
+----+------------+-----------+--------+
2 rows in set (0.00 sec

mysql>

Bisher haben wir eine sehr grundlegende O / R-Zuordnung im Ruhezustand gesehen, aber es gibt drei wichtige Zuordnungsthemen, die wir im Detail lernen müssen.

Dies sind -

Kartierung von Sammlungen,
Zuordnung von Assoziationen zwischen Entitätsklassen und
Komponentenzuordnungen.

Sammlungszuordnungen

Wenn eine Entität oder Klasse eine Sammlung von Werten für eine bestimmte Variable hat, können wir diese Werte mithilfe einer der in Java verfügbaren Sammlungsschnittstellen zuordnen. Der Ruhezustand kann Instanzen von beibehaltenjava.util.Map, java.util.Set, java.util.SortedMap, java.util.SortedSet, java.util.Listund alle array von persistenten Entitäten oder Werten.

Sr.Nr.	Sammlungstyp & Zuordnungsbeschreibung
1	java.util.Set Dies wird mit einem <set> -Element zugeordnet und mit java.util.HashSet initialisiert
2	java.util.SortedSet Dies wird mit einem <set> -Element zugeordnet und mit java.util.TreeSet initialisiert. Dassort Das Attribut kann entweder auf einen Komparator oder auf eine natürliche Reihenfolge gesetzt werden.
3	java.util.List Dies wird mit einem <list> -Element zugeordnet und mit java.util.ArrayList initialisiert
4	java.util.Collection Dies wird mit einem <bag> - oder <ibag> -Element zugeordnet und mit java.util.ArrayList initialisiert
5	java.util.Map Dies wird mit einem <map> -Element zugeordnet und mit java.util.HashMap initialisiert
6	java.util.SortedMap Dies wird mit einem <map> -Element zugeordnet und mit java.util.TreeMap initialisiert. Dassort Das Attribut kann entweder auf einen Komparator oder auf eine natürliche Reihenfolge gesetzt werden.

Arrays werden von Hibernate mit <primitive-array> für primitive Java-Werttypen und <array> für alles andere unterstützt. Sie werden jedoch selten verwendet, daher werde ich sie in diesem Tutorial nicht behandeln.

Wenn Sie benutzerdefinierte Sammlungsschnittstellen zuordnen möchten, die von Hibernate nicht direkt unterstützt werden, müssen Sie Hibernate über die Semantik Ihrer benutzerdefinierten Sammlungen informieren, was nicht sehr einfach ist und nicht empfohlen wird.

Assoziationszuordnungen

Die Zuordnung von Assoziationen zwischen Entitätsklassen und den Beziehungen zwischen Tabellen ist die Seele von ORM. Es folgen die vier Möglichkeiten, wie die Kardinalität der Beziehung zwischen den Objekten ausgedrückt werden kann. Eine Zuordnungszuordnung kann sowohl unidirektional als auch bidirektional sein.

Sr.Nr.	Zuordnungstyp & Beschreibung
1	Viele zu Eins Zuordnung einer Viele-zu-Eins-Beziehung mithilfe des Ruhezustands
2	Eins zu eins Zuordnung einer Eins-zu-Eins-Beziehung mithilfe des Ruhezustands
3	Eins zu viele Zuordnung einer Eins-zu-Viele-Beziehung mithilfe des Ruhezustands
4	Viel zu viel Zuordnen einer Viele-zu-Viele-Beziehung mithilfe des Ruhezustands

Komponentenzuordnungen

Es ist sehr wahrscheinlich, dass eine Entitätsklasse als Mitgliedsvariable auf eine andere Klasse verweist. Wenn die referenzierte Klasse keinen eigenen Lebenszyklus hat und vollständig vom Lebenszyklus der besitzenden Entitätsklasse abhängt, wird die referenzierte Klasse daher als bezeichnetComponent class.

Die Zuordnung der Komponentensammlung ist auf ähnliche Weise möglich wie die Zuordnung regulärer Sammlungen mit geringfügigen Konfigurationsunterschieden. Wir werden diese beiden Zuordnungen anhand von Beispielen im Detail sehen.

Sr.Nr.	Zuordnungstyp & Beschreibung
1	Komponentenzuordnungen Zuordnung für eine Klasse mit einem Verweis auf eine andere Klasse als Mitgliedsvariable.

Bisher haben Sie gesehen, wie Hibernate eine XML-Zuordnungsdatei für die Umwandlung von Daten von POJO in Datenbanktabellen und umgekehrt verwendet. Anmerkungen im Ruhezustand sind die neueste Methode zum Definieren von Zuordnungen ohne Verwendung einer XML-Datei. Sie können Anmerkungen zusätzlich zu oder als Ersatz für XML-Zuordnungsmetadaten verwenden.

Annotationen im Ruhezustand sind die leistungsstarke Methode, um die Metadaten für die Zuordnung von Objekten und relationalen Tabellen bereitzustellen. Alle Metadaten werden zusammen mit dem Code in die POJO-Java-Datei eingebettet. Dies hilft dem Benutzer, die Tabellenstruktur und POJO gleichzeitig während der Entwicklung zu verstehen.

Wenn Sie Ihre Anwendung auf andere EJB 3-kompatible ORM-Anwendungen portierbar machen möchten, müssen Sie Anmerkungen verwenden, um die Zuordnungsinformationen darzustellen. Wenn Sie jedoch eine größere Flexibilität wünschen, sollten Sie XML-basierte Zuordnungen verwenden.

Umgebungssetup für Annotation im Ruhezustand

Zunächst müssten Sie sicherstellen, dass Sie JDK 5.0 verwenden. Andernfalls müssen Sie Ihr JDK auf JDK 5.0 aktualisieren, um die native Unterstützung für Anmerkungen nutzen zu können.

Zweitens müssen Sie das Verteilungspaket für Hibernate 3.x-Annotationen installieren, das bei sourceforge erhältlich ist: ( Hibernate Annotation herunterladen ) und kopierenhibernate-annotations.jar, lib/hibernate-comons-annotations.jar und lib/ejb3-persistence.jar von der Hibernate Annotations-Distribution zu Ihrem CLASSPATH.

Beispiel für eine kommentierte Klasse

Wie oben erwähnt, werden bei der Arbeit mit Hibernate Annotation alle Metadaten zusammen mit dem Code in die POJO-Java-Datei eingebettet. Dies hilft dem Benutzer, die Tabellenstruktur und POJO gleichzeitig während der Entwicklung zu verstehen.

Bedenken Sie, dass wir die folgende EMPLOYEE-Tabelle zum Speichern unserer Objekte verwenden werden -

create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

Es folgt die Zuordnung der Employee-Klasse mit Anmerkungen zum Zuordnen von Objekten mit der definierten EMPLOYEE-Tabelle.

import javax.persistence.*;

@Entity
@Table(name = "EMPLOYEE")
public class Employee {
   @Id @GeneratedValue
   @Column(name = "id")
   private int id;

   @Column(name = "first_name")
   private String firstName;

   @Column(name = "last_name")
   private String lastName;

   @Column(name = "salary")
   private int salary;  

   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() {
      return salary;
   }
   
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Der Ruhezustand erkennt, dass sich die Annotation @Id in einem Feld befindet, und geht davon aus, dass sie zur Laufzeit direkt über Felder auf Eigenschaften eines Objekts zugreifen soll. Wenn Sie die Annotation @Id in die Methode getId () einfügen, aktivieren Sie standardmäßig den Zugriff auf Eigenschaften über die Methoden getter und setter. Daher werden alle anderen Anmerkungen gemäß der ausgewählten Strategie auch entweder auf Feldern oder auf Getter-Methoden platziert.

Im folgenden Abschnitt werden die in der obigen Klasse verwendeten Anmerkungen erläutert.

@Entity Annotation

Die EJB 3-Standardanmerkungen sind in der enthalten javax.persistencePaket, also importieren wir dieses Paket als ersten Schritt. Zweitens haben wir die verwendet@Entity Annotation zur Employee-Klasse, die diese Klasse als Entity-Bean kennzeichnet. Daher muss ein Konstruktor ohne Argumente vorhanden sein, der zumindest mit einem geschützten Bereich sichtbar ist.

@Table Annotation

Mit der Annotation @Table können Sie die Details der Tabelle angeben, mit denen die Entität in der Datenbank beibehalten wird.

Die Annotation @Table bietet vier Attribute, mit denen Sie den Namen der Tabelle, ihren Katalog und ihr Schema überschreiben und eindeutige Einschränkungen für Spalten in der Tabelle erzwingen können. Im Moment verwenden wir nur den Tabellennamen EMPLOYEE.

Anmerkungen zu @Id und @GeneratedValue

Jede Entity-Bean verfügt über einen Primärschlüssel, den Sie mit dem mit der Klasse versehen @IdAnmerkung. Der Primärschlüssel kann je nach Tabellenstruktur ein einzelnes Feld oder eine Kombination mehrerer Felder sein.

Standardmäßig bestimmt die @ ID-Annotation automatisch die am besten geeignete Strategie zur Generierung von Primärschlüsseln. Sie können diese jedoch überschreiben, indem Sie die anwenden @GeneratedValue Annotation, die zwei Parameter akzeptiert strategy und generatorDas werde ich hier nicht diskutieren. Verwenden wir also nur die Standardstrategie zur Schlüsselgenerierung. Wenn Sie den Ruhezustand bestimmen lassen, welcher Generatortyp verwendet werden soll, kann Ihr Code zwischen verschiedenen Datenbanken portiert werden.

@ Spaltenanmerkung

Die Annotation @Column wird verwendet, um die Details der Spalte anzugeben, der ein Feld oder eine Eigenschaft zugeordnet werden soll. Sie können Spaltenanmerkungen mit den folgenden am häufigsten verwendeten Attributen verwenden:

name Mit dem Attribut kann der Name der Spalte explizit angegeben werden.
length Das Attribut erlaubt die Größe der Spalte, die zum Zuordnen eines Werts verwendet wird, insbesondere für einen String-Wert.
nullable Mit dem Attribut kann die Spalte beim Generieren des Schemas als NICHT NULL markiert werden.
unique Mit dem Attribut kann die Spalte so markiert werden, dass sie nur eindeutige Werte enthält.

Anwendungsklasse erstellen

import 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;
import org.hibernate.cfg.Configuration;

public class ManageEmployee {
   private static SessionFactory factory; 
   public static void main(String[] args) {
      
      try {
         factory = new AnnotationConfiguration().
                   configure().
                   //addPackage("com.xyz") //add package if used.
                   addAnnotatedClass(Employee.class).
                   buildSessionFactory();
      } catch (Throwable ex) { 
         System.err.println("Failed to create sessionFactory object." + ex);
         throw new ExceptionInInitializerError(ex); 
      }
      
      ManageEmployee ME = new ManageEmployee();

      /* Add few employee records in database */
      Integer empID1 = ME.addEmployee("Zara", "Ali", 1000);
      Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
      Integer empID3 = ME.addEmployee("John", "Paul", 10000);

      /* List down all the employees */
      ME.listEmployees();

      /* Update employee's records */
      ME.updateEmployee(empID1, 5000);

      /* Delete an employee from the database */
      ME.deleteEmployee(empID2);

      /* List down new list of the employees */
      ME.listEmployees();
   }
   
   /* Method to CREATE an employee in the database */
   public Integer addEmployee(String fname, String lname, int salary){
      Session session = factory.openSession();
      Transaction tx = null;
      Integer employeeID = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = new Employee();
         employee.setFirstName(fname);
         employee.setLastName(lname);
         employee.setSalary(salary);
         employeeID = (Integer) session.save(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
      return employeeID;
   }
   
   /* Method to  READ all the employees */
   public void listEmployees( ){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         List employees = session.createQuery("FROM Employee").list(); 
         for (Iterator iterator = employees.iterator(); iterator.hasNext();){
            Employee employee = (Employee) iterator.next(); 
            System.out.print("First Name: " + employee.getFirstName()); 
            System.out.print("  Last Name: " + employee.getLastName()); 
            System.out.println("  Salary: " + employee.getSalary()); 
         }
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
   
   /* Method to UPDATE salary for an employee */
   public void updateEmployee(Integer EmployeeID, int salary ){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = (Employee)session.get(Employee.class, EmployeeID); 
         employee.setSalary( salary );
		 session.update(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
   
   /* Method to DELETE an employee from the records */
   public void deleteEmployee(Integer EmployeeID){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = (Employee)session.get(Employee.class, EmployeeID); 
         session.delete(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
}

Datenbankkonfiguration

Lassen Sie uns jetzt erstellen hibernate.cfg.xml Konfigurationsdatei zum Definieren datenbankbezogener Parameter.

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM 
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>
   
      <property name = "hibernate.dialect">
         org.hibernate.dialect.MySQLDialect
      </property>
   
      <property name = "hibernate.connection.driver_class">
         com.mysql.jdbc.Driver
      </property>

      <!-- Assume students is the database name -->
   
      <property name = "hibernate.connection.url">
         jdbc:mysql://localhost/test
      </property>
   
      <property name = "hibernate.connection.username">
         root
      </property>
   
      <property name = "hibernate.connection.password">
         cohondob
      </property>

   </session-factory>
</hibernate-configuration>

Zusammenstellung und Ausführung

Löschen Sie die Zuordnungsdatei Employee.hbm.xml aus dem Pfad.
Erstellen Sie die Employee.java-Quelldatei wie oben gezeigt und kompilieren Sie sie.
Erstellen Sie die Quelldatei ManageEmployee.java wie oben gezeigt und kompilieren Sie sie.
Führen Sie die ManageEmployee-Binärdatei aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten und Datensätze würden in der Tabelle EMPLOYEE erstellt.

$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........

First Name: Zara  Last Name: Ali  Salary: 1000
First Name: Daisy  Last Name: Das  Salary: 5000
First Name: John  Last Name: Paul  Salary: 10000
First Name: Zara  Last Name: Ali  Salary: 5000
First Name: John  Last Name: Paul  Salary: 10000

Wenn Sie Ihre EMPLOYEE-Tabelle überprüfen, sollte sie die folgenden Datensätze enthalten:

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 29 | Zara       | Ali       |   5000 |
| 31 | John       | Paul      |  10000 |
+----+------------+-----------+--------+
2 rows in set (0.00 sec

mysql>

Hibernate Query Language (HQL) ist eine objektorientierte Abfragesprache, ähnlich wie SQL, aber anstatt Tabellen und Spalten zu bearbeiten, arbeitet HQL mit persistenten Objekten und ihren Eigenschaften. HQL-Abfragen werden von Hibernate in herkömmliche SQL-Abfragen übersetzt, die wiederum Aktionen für die Datenbank ausführen.

Sie können SQL-Anweisungen zwar direkt mit Hibernate unter Verwendung von Native SQL verwenden, ich würde jedoch empfehlen, HQL nach Möglichkeit zu verwenden, um Probleme mit der Datenbankportabilität zu vermeiden und die SQL-Generierungs- und Caching-Strategien von Hibernate zu nutzen.

Bei Schlüsselwörtern wie SELECT, FROM und WHERE usw. wird nicht zwischen Groß- und Kleinschreibung unterschieden, bei Eigenschaften wie Tabellen- und Spaltennamen wird in HQL zwischen Groß- und Kleinschreibung unterschieden.

FROM-Klausel

Du wirst benutzen FROMKlausel, wenn Sie vollständige persistente Objekte in den Speicher laden möchten. Es folgt die einfache Syntax der Verwendung der FROM-Klausel:

String hql = "FROM Employee";
Query query = session.createQuery(hql);
List results = query.list();

Wenn Sie einen Klassennamen in HQL vollständig qualifizieren müssen, geben Sie einfach den Paket- und Klassennamen wie folgt an:

String hql = "FROM com.hibernatebook.criteria.Employee";
Query query = session.createQuery(hql);
List results = query.list();

AS-Klausel

Das ASKlausel kann verwendet werden, um den Klassen in Ihren HQL-Abfragen Aliase zuzuweisen, insbesondere wenn Sie lange Abfragen haben. Zum Beispiel wäre unser vorheriges einfaches Beispiel das Folgende:

String hql = "FROM Employee AS E";
Query query = session.createQuery(hql);
List results = query.list();

Das AS Das Schlüsselwort ist optional und Sie können den Alias auch direkt nach dem Klassennamen wie folgt angeben:

String hql = "FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

SELECT-Klausel

Das SELECTKlausel bietet mehr Kontrolle über die Ergebnismenge als die from-Klausel. Wenn Sie anstelle des vollständigen Objekts nur wenige Eigenschaften von Objekten erhalten möchten, verwenden Sie die SELECT-Klausel. Es folgt die einfache Syntax der Verwendung der SELECT-Klausel, um nur das Feld first_name des Employee-Objekts abzurufen.

String hql = "SELECT E.firstName FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

Es ist hier bemerkenswert, dass Employee.firstName ist eine Eigenschaft des Employee-Objekts und kein Feld der EMPLOYEE-Tabelle.

WO-Klausel

Wenn Sie die spezifischen Objekte eingrenzen möchten, die aus dem Speicher zurückgegeben werden, verwenden Sie die WHERE-Klausel. Es folgt die einfache Syntax der Verwendung der WHERE-Klausel:

String hql = "FROM Employee E WHERE E.id = 10";
Query query = session.createQuery(hql);
List results = query.list();

ORDER BY-Klausel

Um die Ergebnisse Ihrer HQL-Abfrage zu sortieren, müssen Sie die verwenden ORDER BYKlausel. Sie können die Ergebnisse nach einer beliebigen Eigenschaft für die Objekte in der Ergebnismenge sortieren, entweder aufsteigend (ASC) oder absteigend (DESC). Es folgt die einfache Syntax der Verwendung der ORDER BY-Klausel:

String hql = "FROM Employee E WHERE E.id > 10 ORDER BY E.salary DESC";
Query query = session.createQuery(hql);
List results = query.list();

Wenn Sie nach mehr als einer Eigenschaft sortieren möchten, fügen Sie einfach die zusätzlichen Eigenschaften am Ende der order by-Klausel hinzu, die wie folgt durch Kommas getrennt sind:

String hql = "FROM Employee E WHERE E.id > 10 " +
             "ORDER BY E.firstName DESC, E.salary DESC ";
Query query = session.createQuery(hql);
List results = query.list();

GROUP BY-Klausel

Mit dieser Klausel kann Hibernate Informationen aus der Datenbank abrufen und basierend auf einem Wert eines Attributs gruppieren und das Ergebnis normalerweise verwenden, um einen Gesamtwert einzuschließen. Es folgt die einfache Syntax der Verwendung der GROUP BY-Klausel:

String hql = "SELECT SUM(E.salary), E.firtName FROM Employee E " +
             "GROUP BY E.firstName";
Query query = session.createQuery(hql);
List results = query.list();

Benannte Parameter verwenden

Hibernate unterstützt benannte Parameter in seinen HQL-Abfragen. Dies erleichtert das Schreiben von HQL-Abfragen, die Eingaben des Benutzers akzeptieren, und Sie müssen sich nicht gegen SQL-Injection-Angriffe verteidigen. Es folgt die einfache Syntax zur Verwendung benannter Parameter:

String hql = "FROM Employee E WHERE E.id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("employee_id",10);
List results = query.list();

UPDATE-Klausel

Massenaktualisierungen sind für HQL mit Hibernate 3 neu und löschen die Arbeit in Hibernate 3 anders als in Hibernate 2. Die Abfrageoberfläche enthält jetzt eine Methode namens executeUpdate () zum Ausführen von HQL UPDATE- oder DELETE-Anweisungen.

Das UPDATEKlausel kann verwendet werden, um eine oder mehrere Eigenschaften eines oder mehrerer Objekte zu aktualisieren. Es folgt die einfache Syntax der Verwendung der UPDATE-Klausel:

String hql = "UPDATE Employee set salary = :salary "  + 
             "WHERE id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("salary", 1000);
query.setParameter("employee_id", 10);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

DELETE-Klausel

Das DELETEKlausel kann verwendet werden, um ein oder mehrere Objekte zu löschen. Es folgt die einfache Syntax der Verwendung der DELETE-Klausel:

String hql = "DELETE FROM Employee "  + 
             "WHERE id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("employee_id", 10);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

INSERT-Klausel

HQL unterstützt INSERT INTOKlausel nur, wenn Datensätze von einem Objekt in ein anderes Objekt eingefügt werden können. Es folgt die einfache Syntax der Verwendung der INSERT INTO-Klausel:

String hql = "INSERT INTO Employee(firstName, lastName, salary)"  + 
             "SELECT firstName, lastName, salary FROM old_employee";
Query query = session.createQuery(hql);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

Aggregierte Methoden

HQL unterstützt eine Reihe von Aggregatmethoden, ähnlich wie SQL. Sie funktionieren in HQL genauso wie in SQL. Im Folgenden finden Sie eine Liste der verfügbaren Funktionen:

Sr.Nr.	Funktionen & Beschreibung
1	avg(property name) Der Durchschnitt des Wertes einer Immobilie
2	*count(property name or )** Die Häufigkeit, mit der eine Eigenschaft in den Ergebnissen vorkommt
3	max(property name) Der Maximalwert der Eigenschaftswerte
4	min(property name) Der Mindestwert der Eigenschaftswerte
5	sum(property name) Die Gesamtsumme der Eigenschaftswerte

Das distinctDas Schlüsselwort zählt nur die eindeutigen Werte im Zeilensatz. Die folgende Abfrage gibt nur eine eindeutige Anzahl zurück -

String hql = "SELECT count(distinct E.firstName) FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

Paginierung mit Abfrage

Es gibt zwei Methoden der Abfrageschnittstelle für die Paginierung.

Sr.Nr.	Methode & Beschreibung
1	Query setFirstResult(int startPosition) Diese Methode verwendet eine Ganzzahl, die die erste Zeile in Ihrer Ergebnismenge darstellt, beginnend mit Zeile 0.
2	Query setMaxResults(int maxResult) Diese Methode weist Hibernate an, eine feste Nummer abzurufen maxResults von Objekten.

Mit den beiden oben genannten Methoden können wir eine Paging-Komponente in unserer Web- oder Swing-Anwendung erstellen. Das folgende Beispiel können Sie erweitern, um 10 Zeilen gleichzeitig abzurufen.

String hql = "FROM Employee";
Query query = session.createQuery(hql);
query.setFirstResult(1);
query.setMaxResults(10);
List results = query.list();

Der Ruhezustand bietet alternative Möglichkeiten zum Bearbeiten von Objekten und Daten, die in RDBMS-Tabellen verfügbar sind. Eine der Methoden ist die Kriterien-API, mit der Sie programmgesteuert ein Kriterienabfrageobjekt erstellen können, in dem Sie Filterregeln und logische Bedingungen anwenden können.

Der Winterschlaf Session Schnittstelle bietet createCriteria() Methode, mit der eine erstellt werden kann Criteria Objekt, das Instanzen der Klasse des Persistenzobjekts zurückgibt, wenn Ihre Anwendung eine Kriterienabfrage ausführt.

Das einfachste Beispiel für eine Kriterienabfrage ist eines, bei dem einfach jedes Objekt zurückgegeben wird, das der Employee-Klasse entspricht.

Criteria cr = session.createCriteria(Employee.class);
List results = cr.list();

Einschränkungen mit Kriterien

Sie können verwenden add() Methode verfügbar für CriteriaObjekt zum Hinzufügen einer Einschränkung für eine Kriterienabfrage. Das folgende Beispiel fügt eine Einschränkung hinzu, um die Datensätze mit einem Gehalt von 2000 zurückzugeben.

Criteria cr = session.createCriteria(Employee.class);
cr.add(Restrictions.eq("salary", 2000));
List results = cr.list();

Im Folgenden finden Sie einige weitere Beispiele für verschiedene Szenarien, die je nach Anforderung verwendet werden können.

Criteria cr = session.createCriteria(Employee.class);

// To get records having salary more than 2000
cr.add(Restrictions.gt("salary", 2000));

// To get records having salary less than 2000
cr.add(Restrictions.lt("salary", 2000));

// To get records having fistName starting with zara
cr.add(Restrictions.like("firstName", "zara%"));

// Case sensitive form of the above restriction.
cr.add(Restrictions.ilike("firstName", "zara%"));

// To get records having salary in between 1000 and 2000
cr.add(Restrictions.between("salary", 1000, 2000));

// To check if the given property is null
cr.add(Restrictions.isNull("salary"));

// To check if the given property is not null
cr.add(Restrictions.isNotNull("salary"));

// To check if the given property is empty
cr.add(Restrictions.isEmpty("salary"));

// To check if the given property is not empty
cr.add(Restrictions.isNotEmpty("salary"));

Sie können UND- oder ODER-Bedingungen mithilfe der LogicalExpression-Einschränkungen wie folgt erstellen:

Criteria cr = session.createCriteria(Employee.class);

Criterion salary = Restrictions.gt("salary", 2000);
Criterion name = Restrictions.ilike("firstNname","zara%");

// To get records matching with OR conditions
LogicalExpression orExp = Restrictions.or(salary, name);
cr.add( orExp );

// To get records matching with AND conditions
LogicalExpression andExp = Restrictions.and(salary, name);
cr.add( andExp );

List results = cr.list();

Alle oben genannten Bedingungen können jedoch direkt mit HQL verwendet werden, wie im vorherigen Lernprogramm erläutert.

Paginierung anhand von Kriterien

Es gibt zwei Methoden der Kriterienschnittstelle für die Paginierung.

Sr.Nr.	Methode & Beschreibung
1	public Criteria setFirstResult(int firstResult) Diese Methode verwendet eine Ganzzahl, die die erste Zeile in Ihrer Ergebnismenge darstellt, beginnend mit Zeile 0.
2	public Criteria setMaxResults(int maxResults) Diese Methode weist Hibernate an, eine feste Nummer abzurufen maxResults von Objekten.

Criteria cr = session.createCriteria(Employee.class);
cr.setFirstResult(1);
cr.setMaxResults(10);
List results = cr.list();

Ergebnisse sortieren

Die Kriterien-API bietet die org.hibernate.criterion.OrderKlasse, um Ihre Ergebnismenge in aufsteigender oder absteigender Reihenfolge nach einer der Eigenschaften Ihres Objekts zu sortieren. Dieses Beispiel zeigt, wie Sie die Order-Klasse zum Sortieren der Ergebnismenge verwenden würden -

Criteria cr = session.createCriteria(Employee.class);

// To get records having salary more than 2000
cr.add(Restrictions.gt("salary", 2000));

// To sort records in descening order
cr.addOrder(Order.desc("salary"));

// To sort records in ascending order
cr.addOrder(Order.asc("salary"));

List results = cr.list();

Projektionen & Aggregationen

Die Kriterien-API bietet die org.hibernate.criterion.ProjectionsKlasse, die verwendet werden kann, um den Durchschnitt, das Maximum oder das Minimum der Eigenschaftswerte abzurufen. Die Projections-Klasse ähnelt der Restrictions-Klasse, da sie mehrere statische Factory-Methoden zum Abrufen bereitstelltProjection Instanzen.

Im Folgenden finden Sie einige Beispiele für verschiedene Szenarien, die je nach Anforderung verwendet werden können.

Criteria cr = session.createCriteria(Employee.class);

// To get total row count.
cr.setProjection(Projections.rowCount());

// To get average of a property.
cr.setProjection(Projections.avg("salary"));

// To get distinct count of a property.
cr.setProjection(Projections.countDistinct("firstName"));

// To get maximum of a property.
cr.setProjection(Projections.max("salary"));

// To get minimum of a property.
cr.setProjection(Projections.min("salary"));

// To get sum of a property.
cr.setProjection(Projections.sum("salary"));

Beispiel für Kriterienabfragen

Betrachten Sie die folgende POJO-Klasse -

public class Employee {
   private int id;
   private String firstName; 
   private String lastName;   
   private int salary;  

   public Employee() {}
   
   public Employee(String fname, String lname, int salary) {
      this.firstName = fname;
      this.lastName = lname;
      this.salary = salary;
   }
   
   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() {
      return salary;
   }
   
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Erstellen wir die folgende EMPLOYEE-Tabelle zum Speichern von Mitarbeiterobjekten:

create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

Es folgt die Zuordnungsdatei.

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 

<hibernate-mapping>
   <class name = "Employee" table = "EMPLOYEE">
      
      <meta attribute = "class-description">
         This class contains the employee detail. 
      </meta>
      
      <id name = "id" type = "int" column = "id">
         <generator class="native"/>
      </id>
      
      <property name = "firstName" column = "first_name" type = "string"/>
      <property name = "lastName" column = "last_name" type = "string"/>
      <property name = "salary" column = "salary" type = "int"/>
      
   </class>
</hibernate-mapping>

Schließlich erstellen wir unsere Anwendungsklasse mit der main () -Methode, um die Anwendung dort auszuführen, wo wir sie verwenden werden Criteria Anfragen -

import 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.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
import org.hibernate.criterion.Projections;
import org.hibernate.cfg.Configuration;

public class ManageEmployee {
   private static SessionFactory factory; 
   public static void main(String[] args) {
      
      try {
         factory = new Configuration().configure().buildSessionFactory();
      } catch (Throwable ex) { 
         System.err.println("Failed to create sessionFactory object." + ex);
         throw new ExceptionInInitializerError(ex); 
      }
      
      ManageEmployee ME = new ManageEmployee();

      /* Add few employee records in database */
      Integer empID1 = ME.addEmployee("Zara", "Ali", 2000);
      Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
      Integer empID3 = ME.addEmployee("John", "Paul", 5000);
      Integer empID4 = ME.addEmployee("Mohd", "Yasee", 3000);

      /* List down all the employees */
      ME.listEmployees();

      /* Print Total employee's count */
      ME.countEmployee();

      /* Print Total salary */
      ME.totalSalary();
   }
   
   /* Method to CREATE an employee in the database */
   public Integer addEmployee(String fname, String lname, int salary){
      Session session = factory.openSession();
      Transaction tx = null;
      Integer employeeID = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = new Employee(fname, lname, salary);
         employeeID = (Integer) session.save(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
      return employeeID;
   }

   /* Method to  READ all the employees having salary more than 2000 */
   public void listEmployees( ) {
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Criteria cr = session.createCriteria(Employee.class);
         // Add restriction.
         cr.add(Restrictions.gt("salary", 2000));
         List employees = cr.list();

         for (Iterator iterator = employees.iterator(); iterator.hasNext();){
            Employee employee = (Employee) iterator.next(); 
            System.out.print("First Name: " + employee.getFirstName()); 
            System.out.print("  Last Name: " + employee.getLastName()); 
            System.out.println("  Salary: " + employee.getSalary()); 
         }
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
   
   /* Method to print total number of records */
   public void countEmployee(){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Criteria cr = session.createCriteria(Employee.class);

         // To get total row count.
         cr.setProjection(Projections.rowCount());
         List rowCount = cr.list();

         System.out.println("Total Coint: " + rowCount.get(0) );
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
  
   /* Method to print sum of salaries */
   public void totalSalary(){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Criteria cr = session.createCriteria(Employee.class);

         // To get total salary.
         cr.setProjection(Projections.sum("salary"));
         List totalSalary = cr.list();

         System.out.println("Total Salary: " + totalSalary.get(0) );
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
}

Zusammenstellung und Ausführung

Erstellen Sie die Konfigurationsdatei hibernate.cfg.xml wie im Konfigurationskapitel erläutert.
Erstellen Sie die Zuordnungsdatei Employee.hbm.xml wie oben gezeigt.
Erstellen Sie die Employee.java-Quelldatei wie oben gezeigt und kompilieren Sie sie.
Erstellen Sie die Quelldatei ManageEmployee.java wie oben gezeigt und kompilieren Sie sie.
Führen Sie die ManageEmployee-Binärdatei aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten und Datensätze in der Tabelle EMPLOYEE erstellt.

$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........

First Name: Daisy  Last Name: Das  Salary: 5000
First Name: John  Last Name: Paul  Salary: 5000
First Name: Mohd  Last Name: Yasee  Salary: 3000
Total Coint: 4
Total Salary: 15000

Wenn Sie Ihre EMPLOYEE-Tabelle überprüfen, sollte sie die folgenden Datensätze enthalten

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 14 | Zara       | Ali       |   2000 |
| 15 | Daisy      | Das       |   5000 |
| 16 | John       | Paul      |   5000 |
| 17 | Mohd       | Yasee     |   3000 |
+----+------------+-----------+--------+
4 rows in set (0.00 sec)
mysql>

Sie können natives SQL verwenden, um Datenbankabfragen auszudrücken, wenn Sie datenbankspezifische Funktionen wie Abfragehinweise oder das Schlüsselwort CONNECT in Oracle verwenden möchten. In Hibernate 3.x können Sie handgeschriebenes SQL einschließlich gespeicherter Prozeduren für alle Vorgänge zum Erstellen, Aktualisieren, Löschen und Laden angeben.

Ihre Anwendung erstellt eine native SQL-Abfrage aus der Sitzung mit dem createSQLQuery() Methode auf der Sitzungsschnittstelle -

public SQLQuery createSQLQuery(String sqlString) throws HibernateException

Nachdem Sie eine Zeichenfolge mit der SQL-Abfrage an die Methode createSQLQuery () übergeben haben, können Sie das SQL-Ergebnis mithilfe der Methoden addEntity (), addJoin () und addScalar () entweder einer vorhandenen Hibernate-Entität, einem Join oder einem skalaren Ergebnis zuordnen beziehungsweise.

Skalare Abfragen

Die grundlegendste SQL-Abfrage besteht darin, eine Liste von Skalaren (Werten) aus einer oder mehreren Tabellen abzurufen. Im Folgenden finden Sie die Syntax für die Verwendung von nativem SQL für skalare Werte:

String sql = "SELECT first_name, salary FROM EMPLOYEE";
SQLQuery query = session.createSQLQuery(sql);
query.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP);
List results = query.list();

Entitätsabfragen

Bei den obigen Abfragen ging es ausschließlich um die Rückgabe von Skalarwerten, im Grunde genommen um die Rückgabe der "rohen" Werte aus der Ergebnismenge. Im Folgenden finden Sie die Syntax zum Abrufen von Entitätsobjekten als Ganzes aus einer nativen SQL-Abfrage über addEntity ().

String sql = "SELECT * FROM EMPLOYEE";
SQLQuery query = session.createSQLQuery(sql);
query.addEntity(Employee.class);
List results = query.list();

Benannte SQL-Abfragen

Im Folgenden finden Sie die Syntax zum Abrufen von Entitätsobjekten aus einer nativen SQL-Abfrage über addEntity () und unter Verwendung einer benannten SQL-Abfrage.

String sql = "SELECT * FROM EMPLOYEE WHERE id = :employee_id";
SQLQuery query = session.createSQLQuery(sql);
query.addEntity(Employee.class);
query.setParameter("employee_id", 10);
List results = query.list();

Native SQL-Beispiel

Betrachten Sie die folgende POJO-Klasse -

public class Employee {
   private int id;
   private String firstName; 
   private String lastName;   
   private int salary;  

   public Employee() {}
   
   public Employee(String fname, String lname, int salary) {
      this.firstName = fname;
      this.lastName = lname;
      this.salary = salary;
   }
   
   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() {
      return salary;
   }
   
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Erstellen wir die folgende EMPLOYEE-Tabelle zum Speichern von Mitarbeiterobjekten:

create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

Es folgt eine Zuordnungsdatei -

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 

<hibernate-mapping>
   <class name = "Employee" table = "EMPLOYEE">
      
      <meta attribute = "class-description">
         This class contains the employee detail. 
      </meta>
      
      <id name = "id" type = "int" column = "id">
         <generator class="native"/>
      </id>
      
      <property name = "firstName" column = "first_name" type = "string"/>
      <property name = "lastName" column = "last_name" type = "string"/>
      <property name = "salary" column = "salary" type = "int"/>
      
   </class>
</hibernate-mapping>

Schließlich erstellen wir unsere Anwendungsklasse mit der main () -Methode, um die Anwendung dort auszuführen, wo wir sie verwenden werden Native SQL Anfragen -

import java.util.*; 
 
import org.hibernate.HibernateException; 
import org.hibernate.Session; 
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.SQLQuery;
import org.hibernate.Criteria;
import org.hibernate.Hibernate;
import org.hibernate.cfg.Configuration;

public class ManageEmployee {
   private static SessionFactory factory; 
   public static void main(String[] args) {
      
      try {
         factory = new Configuration().configure().buildSessionFactory();
      } catch (Throwable ex) { 
         System.err.println("Failed to create sessionFactory object." + ex);
         throw new ExceptionInInitializerError(ex); 
      }
      
      ManageEmployee ME = new ManageEmployee();

      /* Add few employee records in database */
      Integer empID1 = ME.addEmployee("Zara", "Ali", 2000);
      Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
      Integer empID3 = ME.addEmployee("John", "Paul", 5000);
      Integer empID4 = ME.addEmployee("Mohd", "Yasee", 3000);

      /* List down employees and their salary using Scalar Query */
      ME.listEmployeesScalar();

      /* List down complete employees information using Entity Query */
      ME.listEmployeesEntity();
   }
   
   /* Method to CREATE an employee in the database */
   public Integer addEmployee(String fname, String lname, int salary){
      Session session = factory.openSession();
      Transaction tx = null;
      Integer employeeID = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = new Employee(fname, lname, salary);
         employeeID = (Integer) session.save(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
      return employeeID;
   }

   /* Method to  READ all the employees using Scalar Query */
   public void listEmployeesScalar( ){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         String sql = "SELECT first_name, salary FROM EMPLOYEE";
         SQLQuery query = session.createSQLQuery(sql);
         query.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP);
         List data = query.list();

         for(Object object : data) {
            Map row = (Map)object;
            System.out.print("First Name: " + row.get("first_name")); 
            System.out.println(", Salary: " + row.get("salary")); 
         }
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }

   /* Method to READ all the employees using Entity Query */
   public void listEmployeesEntity( ){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         String sql = "SELECT * FROM EMPLOYEE";
         SQLQuery query = session.createSQLQuery(sql);
         query.addEntity(Employee.class);
         List employees = query.list();

         for (Iterator iterator = employees.iterator(); iterator.hasNext();){
            Employee employee = (Employee) iterator.next(); 
            System.out.print("First Name: " + employee.getFirstName()); 
            System.out.print("  Last Name: " + employee.getLastName()); 
            System.out.println("  Salary: " + employee.getSalary()); 
         }
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
}

Zusammenstellung und Ausführung

Erstellen Sie die Konfigurationsdatei hibernate.cfg.xml wie im Konfigurationskapitel erläutert.
Erstellen Sie die Zuordnungsdatei Employee.hbm.xml wie oben gezeigt.
Erstellen Sie die Employee.java-Quelldatei wie oben gezeigt und kompilieren Sie sie.
Erstellen Sie die Quelldatei ManageEmployee.java wie oben gezeigt und kompilieren Sie sie.
Führen Sie die ManageEmployee-Binärdatei aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten und Datensätze in der Tabelle EMPLOYEE erstellt.

$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........

First Name: Zara, Salary: 2000
First Name: Daisy, Salary: 5000
First Name: John, Salary: 5000
First Name: Mohd, Salary: 3000
First Name: Zara  Last Name: Ali  Salary: 2000
First Name: Daisy  Last Name: Das  Salary: 5000
First Name: John  Last Name: Paul  Salary: 5000
First Name: Mohd  Last Name: Yasee  Salary: 3000

Wenn Sie Ihre EMPLOYEE-Tabelle überprüfen, sollte sie die folgenden Datensätze enthalten:

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 26 | Zara       | Ali       |   2000 |
| 27 | Daisy      | Das       |   5000 |
| 28 | John       | Paul      |   5000 |
| 29 | Mohd       | Yasee     |   3000 |
+----+------------+-----------+--------+
4 rows in set (0.00 sec)
mysql>

Caching ist ein Mechanismus zur Verbesserung der Leistung eines Systems. Es ist ein Pufferspeicher, der zwischen der Anwendung und der Datenbank liegt. Der Cache-Speicher speichert kürzlich verwendete Datenelemente, um die Anzahl der Datenbanktreffer so weit wie möglich zu reduzieren.

Das Zwischenspeichern ist auch für den Ruhezustand wichtig. Es verwendet ein mehrstufiges Caching-Schema, wie unten erläutert -

Cache der ersten Ebene

Der Cache der ersten Ebene ist der Sitzungscache und ein obligatorischer Cache, durch den alle Anforderungen geleitet werden müssen. Das Session-Objekt behält ein Objekt aus eigener Kraft, bevor es in die Datenbank übernommen wird.

Wenn Sie mehrere Aktualisierungen für ein Objekt ausgeben, versucht Hibernate, die Aktualisierung so lange wie möglich zu verzögern, um die Anzahl der ausgegebenen SQL-Aktualisierungsanweisungen zu verringern. Wenn Sie die Sitzung schließen, gehen alle zwischengespeicherten Objekte verloren und werden entweder beibehalten oder in der Datenbank aktualisiert.

Cache der zweiten Ebene

Der Cache der zweiten Ebene ist ein optionaler Cache, und der Cache der ersten Ebene wird immer konsultiert, bevor versucht wird, ein Objekt im Cache der zweiten Ebene zu lokalisieren. Der Cache der zweiten Ebene kann pro Klasse und Sammlung konfiguriert werden und ist hauptsächlich für das Zwischenspeichern von Objekten über Sitzungen hinweg verantwortlich.

Jeder Cache eines Drittanbieters kann mit Hibernate verwendet werden. Einorg.hibernate.cache.CacheProvider Es wird eine Schnittstelle bereitgestellt, die implementiert werden muss, um Hibernate ein Handle für die Cache-Implementierung bereitzustellen.

Cache auf Abfrageebene

Hibernate implementiert auch einen Cache für Abfrageergebnismengen, der eng in den Cache der zweiten Ebene integriert ist.

Dies ist eine optionale Funktion und erfordert zwei zusätzliche physische Cache-Bereiche, die die zwischengespeicherten Abfrageergebnisse und die Zeitstempel enthalten, als eine Tabelle zuletzt aktualisiert wurde. Dies ist nur für Abfragen nützlich, die häufig mit denselben Parametern ausgeführt werden.

Der Cache der zweiten Ebene

Der Ruhezustand verwendet standardmäßig den Cache der ersten Ebene, und Sie haben nichts zu tun, um den Cache der ersten Ebene zu verwenden. Gehen wir direkt zum optionalen Cache der zweiten Ebene. Nicht alle Klassen profitieren vom Caching, daher ist es wichtig, den Cache der zweiten Ebene deaktivieren zu können.

Der Cache der zweiten Ebene im Ruhezustand wird in zwei Schritten eingerichtet. Zunächst müssen Sie entscheiden, welche Parallelitätsstrategie verwendet werden soll. Danach konfigurieren Sie den Cache-Ablauf und die physischen Cache-Attribute mithilfe des Cache-Anbieters.

Parallelitätsstrategien

Eine Parallelitätsstrategie ist ein Mediator, der dafür verantwortlich ist, Datenelemente im Cache zu speichern und aus dem Cache abzurufen. Wenn Sie einen Cache der zweiten Ebene aktivieren möchten, müssen Sie für jede persistente Klasse und Sammlung festlegen, welche Cache-Parallelitätsstrategie verwendet werden soll.

Transactional - Verwenden Sie diese Strategie für meistgelesene Daten, bei denen es im seltenen Fall eines Updates wichtig ist, veraltete Daten bei gleichzeitigen Transaktionen zu vermeiden.
Read-write - Verwenden Sie diese Strategie erneut für meistgelesene Daten, bei denen es im seltenen Fall einer Aktualisierung wichtig ist, veraltete Daten bei gleichzeitigen Transaktionen zu vermeiden.
Nonstrict-read-write- Diese Strategie übernimmt keine Garantie für die Konsistenz zwischen Cache und Datenbank. Verwenden Sie diese Strategie, wenn sich Daten kaum ändern und eine geringe Wahrscheinlichkeit veralteter Daten nicht von entscheidender Bedeutung ist.
Read-only- Eine für Daten geeignete Parallelitätsstrategie, die sich nie ändert. Verwenden Sie es nur als Referenzdaten.

Wenn wir das Caching der zweiten Ebene für unsere verwenden wollen Employee Klasse, fügen wir das Zuordnungselement hinzu, das erforderlich ist, um Hibernate anzuweisen, Mitarbeiterinstanzen mithilfe der Lese- / Schreibstrategie zwischenzuspeichern.

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 
<hibernate-mapping>
   <class name = "Employee" table = "EMPLOYEE">
      
      <meta attribute = "class-description">
         This class contains the employee detail. 
      </meta>
      
      <cache usage = "read-write"/>
      
      <id name = "id" type = "int" column = "id">
         <generator class="native"/>
      </id>
      
      <property name = "firstName" column = "first_name" type = "string"/>
      <property name = "lastName" column = "last_name" type = "string"/>
      <property name = "salary" column = "salary" type = "int"/>
      
   </class>
</hibernate-mapping>

Das Attribut usage = "read-write" weist Hibernate an, eine Lese- / Schreib-Parallelitätsstrategie für den definierten Cache zu verwenden.

Cache-Anbieter

In Ihrem nächsten Schritt, nachdem Sie die Parallelitätsstrategien berücksichtigt haben, verwenden Sie Ihre Cache-Kandidatenklassen, um einen Cache-Anbieter auszuwählen. Im Ruhezustand müssen Sie einen einzelnen Cache-Anbieter für die gesamte Anwendung auswählen.

Sr.Nr.	Cache Name & Beschreibung
1	EHCache Es kann im Speicher oder auf der Festplatte und im Cluster-Cache zwischengespeichert werden und unterstützt den optionalen Hachenate-Abfrageergebnis-Cache.
2	OSCache Unterstützt das Caching auf Speicher und Festplatte in einer einzelnen JVM mit einer Vielzahl von Ablaufrichtlinien und Unterstützung für den Abfrage-Cache.
3	warmCache Ein auf JGroups basierender Cluster-Cache. Es verwendet die Clustered Invalidierung, unterstützt jedoch nicht den Hibernate-Abfragecache.
4	JBoss Cache Ein vollständig transaktionsreplizierter Cluster-Cache, der ebenfalls auf der JGroups-Multicast-Bibliothek basiert. Es unterstützt Replikation oder Invalidierung, synchrone oder asynchrone Kommunikation sowie optimistisches und pessimistisches Sperren. Der Hibernate-Abfragecache wird unterstützt.

Jeder Cache-Anbieter ist nicht mit jeder Parallelitätsstrategie kompatibel. Die folgende Kompatibilitätsmatrix hilft Ihnen bei der Auswahl einer geeigneten Kombination.

Strategie / Anbieter	Schreibgeschützt	Nonstrictread-write	Lesen Schreiben	Transaktion
EHCache	X.	X.	X.
OSCache	X.	X.	X.
SwarmCache	X.	X.
JBoss Cache	X.			X.

Sie geben einen Cache-Anbieter in der Konfigurationsdatei hibernate.cfg.xml an. Wir wählen EHCache als unseren Cache-Anbieter der zweiten Ebene -

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM 
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
   <session-factory>
   
      <property name = "hibernate.dialect">
         org.hibernate.dialect.MySQLDialect
      </property>
   
      <property name = "hibernate.connection.driver_class">
         com.mysql.jdbc.Driver
      </property>
   
      <!-- Assume students is the database name -->
   
      <property name = "hibernate.connection.url">
         jdbc:mysql://localhost/test
      </property>
   
      <property name = "hibernate.connection.username">
         root
      </property>
   
      <property name = "hibernate.connection.password">
         root123
      </property>
   
      <property name = "hibernate.cache.provider_class">
         org.hibernate.cache.EhCacheProvider
      </property>
   
      <!-- List of XML mapping files -->
      <mapping resource = "Employee.hbm.xml"/>
   
   </session-factory>
</hibernate-configuration>

Jetzt müssen Sie die Eigenschaften der Cache-Regionen angeben. EHCache hat eine eigene Konfigurationsdatei,ehcache.xml, die im KLASSENPFAD der Anwendung stehen sollte. Eine Cache-Konfiguration in ehcache.xml für die Employee-Klasse könnte folgendermaßen aussehen:

<diskStore path="java.io.tmpdir"/>

<defaultCache
maxElementsInMemory = "1000"
eternal = "false"
timeToIdleSeconds = "120"
timeToLiveSeconds = "120"
overflowToDisk = "true"
/>

<cache name = "Employee"
maxElementsInMemory = "500"
eternal = "true"
timeToIdleSeconds = "0"
timeToLiveSeconds = "0"
overflowToDisk = "false"
/>

Das war's, jetzt haben wir das Caching der zweiten Ebene für die Employee-Klasse aktiviert und Hibernate trifft jetzt den Cache der zweiten Ebene, wenn Sie zu einem Employee navigieren oder wenn Sie einen Employee anhand einer Kennung laden.

Sie sollten alle Klassen analysieren und für jede Klasse eine geeignete Caching-Strategie auswählen. Manchmal kann das Caching der zweiten Ebene die Leistung der Anwendung beeinträchtigen. Es wird daher empfohlen, zuerst Ihre Anwendung zu bewerten, ohne das Caching zu aktivieren, und später das gut geeignete Caching zu aktivieren und die Leistung zu überprüfen. Wenn das Caching die Systemleistung nicht verbessert, macht es keinen Sinn, irgendeine Art von Caching zu aktivieren.

Der Cache auf Abfrageebene

Um den Abfragecache zu verwenden, müssen Sie ihn zuerst mit dem aktivieren hibernate.cache.use_query_cache="true"Eigenschaft in der Konfigurationsdatei. Wenn Sie diese Eigenschaft auf true setzen, erstellen Sie im Ruhezustand die erforderlichen Caches im Speicher, um die Abfrage- und Bezeichnersätze aufzunehmen.

Um den Abfragecache zu verwenden, verwenden Sie als Nächstes die Methode setCacheable (Boolean) der Query-Klasse. Zum Beispiel -

Session session = SessionFactory.openSession();
Query query = session.createQuery("FROM EMPLOYEE");
query.setCacheable(true);
List users = query.list();
SessionFactory.closeSession();

Der Ruhezustand unterstützt auch eine sehr fein abgestimmte Cache-Unterstützung durch das Konzept einer Cache-Region. Eine Cache-Region ist Teil des Caches, dem ein Name zugewiesen wurde.

Session session = SessionFactory.openSession();
Query query = session.createQuery("FROM EMPLOYEE");
query.setCacheable(true);
query.setCacheRegion("employee");
List users = query.list();
SessionFactory.closeSession();

Dieser Code verwendet die Methode, um Hibernate anzuweisen, die Abfrage im Mitarbeiterbereich des Caches zu speichern und zu suchen.

Stellen Sie sich eine Situation vor, in der Sie mithilfe des Ruhezustands eine große Anzahl von Datensätzen in Ihre Datenbank hochladen müssen. Im Folgenden finden Sie das Code-Snippet, um dies mit Hibernate zu erreichen.

Session session = SessionFactory.openSession();
Transaction tx = session.beginTransaction();
for ( int i=0; i<100000; i++ ) {
   Employee employee = new Employee(.....);
   session.save(employee);
}
tx.commit();
session.close();

Standardmäßig speichert der Ruhezustand alle persistierten Objekte im Cache auf Sitzungsebene zwischen, und letztendlich würde Ihre Anwendung mit einem umfallen OutOfMemoryExceptionirgendwo um die 50.000ste Reihe. Sie können dieses Problem beheben, wenn Sie verwendenbatch processing mit Ruhezustand.

Um die Stapelverarbeitungsfunktion zu verwenden, legen Sie zuerst fest hibernate.jdbc.batch_sizeals Stapelgröße auf eine Zahl bei 20 oder 50, abhängig von der Objektgröße. Dadurch wird dem Ruhezustandscontainer mitgeteilt, dass alle X Zeilen als Stapel eingefügt werden sollen. Um dies in Ihrem Code zu implementieren, müssten wir wie folgt nur wenige Änderungen vornehmen:

Session session = SessionFactory.openSession();
Transaction tx = session.beginTransaction();
for ( int i=0; i<100000; i++ ) {
   Employee employee = new Employee(.....);
   session.save(employee);
   if( i % 50 == 0 ) { // Same as the JDBC batch size
      //flush a batch of inserts and release memory:
      session.flush();
      session.clear();
   }
}
tx.commit();
session.close();

Der obige Code funktioniert gut für die INSERT-Operation. Wenn Sie jedoch bereit sind, eine UPDATE-Operation durchzuführen, können Sie den folgenden Code verwenden:

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

ScrollableResults employeeCursor = session.createQuery("FROM EMPLOYEE").scroll();
int count = 0;

while ( employeeCursor.next() ) {
   Employee employee = (Employee) employeeCursor.get(0);
   employee.updateEmployee();
   seession.update(employee); 
   if ( ++count % 50 == 0 ) {
      session.flush();
      session.clear();
   }
}
tx.commit();
session.close();

Beispiel für die Stapelverarbeitung

Lassen Sie uns die hinzuzufügende Konfigurationsdatei ändern hibernate.jdbc.batch_size Eigentum -

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM 
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
   <session-factory>
   
      <property name = "hibernate.dialect">
         org.hibernate.dialect.MySQLDialect
      </property>
   
      <property name = "hibernate.connection.driver_class">
         com.mysql.jdbc.Driver
      </property>

      <!-- Assume students is the database name -->
   
      <property name = "hibernate.connection.url">
         jdbc:mysql://localhost/test
      </property>
   
      <property name = "hibernate.connection.username">
         root
      </property>
   
      <property name = "hibernate.connection.password">
         root123
      </property>
   
      <property name = "hibernate.jdbc.batch_size">
         50
      </property>

      <!-- List of XML mapping files -->
      <mapping resource = "Employee.hbm.xml"/>

   </session-factory>
</hibernate-configuration>

Betrachten Sie die folgende POJO-Mitarbeiterklasse -

public class Employee {
   private int id;
   private String firstName; 
   private String lastName;   
   private int salary;  

   public Employee() {}
   
   public Employee(String fname, String lname, int salary) {
      this.firstName = fname;
      this.lastName = lname;
      this.salary = salary;
   }
   
   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() {
      return salary;
   }
   
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Lassen Sie uns die folgende EMPLOYEE-Tabelle erstellen, um die Employee-Objekte zu speichern:

create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

Im Folgenden finden Sie die Zuordnungsdatei zum Zuordnen der Mitarbeiterobjekte mit der Tabelle EMPLOYEE.

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 

<hibernate-mapping>
   <class name = "Employee" table = "EMPLOYEE">
      
      <meta attribute = "class-description">
         This class contains the employee detail. 
      </meta>
      
      <id name = "id" type = "int" column = "id">
         <generator class="native"/>
      </id>
      
      <property name = "firstName" column = "first_name" type = "string"/>
      <property name = "lastName" column = "last_name" type = "string"/>
      <property name = "salary" column = "salary" type = "int"/>
      
   </class>
</hibernate-mapping>

Schließlich erstellen wir unsere Anwendungsklasse mit der main () -Methode, um die Anwendung dort auszuführen, wo wir sie verwenden werden flush() und clear() Mit dem Sitzungsobjekt verfügbare Methoden, damit Hibernate diese Datensätze weiterhin in die Datenbank schreibt, anstatt sie im Speicher zwischenzuspeichern.

import java.util.*; 
 
import org.hibernate.HibernateException; 
import org.hibernate.Session; 
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class ManageEmployee {
   private static SessionFactory factory; 
   public static void main(String[] args) {
      
      try {
         factory = new Configuration().configure().buildSessionFactory();
      } catch (Throwable ex) { 
         System.err.println("Failed to create sessionFactory object." + ex);
         throw new ExceptionInInitializerError(ex); 
      }
      ManageEmployee ME = new ManageEmployee();

      /* Add employee records in batches */
      ME.addEmployees( );
   }
   
   /* Method to create employee records in batches */
   public void addEmployees( ){
      Session session = factory.openSession();
      Transaction tx = null;
      Integer employeeID = null;
      
      try {
         tx = session.beginTransaction();
         for ( int i=0; i<100000; i++ ) {
            String fname = "First Name " + i;
            String lname = "Last Name " + i;
            Integer salary = i;
            Employee employee = new Employee(fname, lname, salary);
            session.save(employee);
         	if( i % 50 == 0 ) {
               session.flush();
               session.clear();
            }
         }
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
      return ;
   }
}

Zusammenstellung und Ausführung

Erstellen Sie die Konfigurationsdatei hibernate.cfg.xml wie oben erläutert.
Erstellen Sie die Zuordnungsdatei Employee.hbm.xml wie oben gezeigt.
Erstellen Sie die Employee.java-Quelldatei wie oben gezeigt und kompilieren Sie sie.
Erstellen Sie die Quelldatei ManageEmployee.java wie oben gezeigt und kompilieren Sie sie.
Führen Sie die ManageEmployee-Binärdatei aus, um das Programm auszuführen, mit dem 100000 Datensätze in der Tabelle EMPLOYEE erstellt werden.

Wie Sie erfahren haben, wird im Ruhezustand ein Objekt erstellt und beibehalten. Sobald das Objekt geändert wurde, muss es wieder in der Datenbank gespeichert werden. Dieser Vorgang wird fortgesetzt, bis das Objekt das nächste Mal benötigt wird, und es wird aus dem persistenten Speicher geladen.

Somit durchläuft ein Objekt verschiedene Phasen seines Lebenszyklus und Interceptor Interfacebietet Methoden, die in verschiedenen Phasen aufgerufen werden können, um einige erforderliche Aufgaben auszuführen. Diese Methoden sind Rückrufe von der Sitzung an die Anwendung, mit denen die Anwendung die Eigenschaften eines persistenten Objekts überprüfen und / oder bearbeiten kann, bevor es gespeichert, aktualisiert, gelöscht oder geladen wird. Im Folgenden finden Sie eine Liste aller in der Interceptor-Schnittstelle verfügbaren Methoden:

Sr.Nr.	Methode & Beschreibung
1	findDirty() Diese Methode wird aufgerufen, wenn die flush() Methode wird für ein Sitzungsobjekt aufgerufen.
2	instantiate() Diese Methode wird aufgerufen, wenn eine persistierte Klasse instanziiert wird.
3	isUnsaved() Diese Methode wird aufgerufen, wenn ein Objekt an die übergeben wird saveOrUpdate() Methode/
4	onDelete() Diese Methode wird aufgerufen, bevor ein Objekt gelöscht wird.
5	onFlushDirty() Diese Methode wird aufgerufen, wenn der Ruhezustand feststellt, dass ein Objekt während eines Flush-Vorgangs, dh eines Aktualisierungsvorgangs, verschmutzt ist (dh geändert wurde).
6	onLoad() Diese Methode wird aufgerufen, bevor ein Objekt initialisiert wird.
7	onSave() Diese Methode wird aufgerufen, bevor ein Objekt gespeichert wird.
8	postFlush() Diese Methode wird aufgerufen, nachdem ein Flush aufgetreten ist und ein Objekt im Speicher aktualisiert wurde.
9	preFlush() Diese Methode wird vor einem Flush aufgerufen.

Mit Hibernate Interceptor haben wir die vollständige Kontrolle darüber, wie ein Objekt sowohl für die Anwendung als auch für die Datenbank aussehen wird.

Wie benutzt man Interceptors?

Um einen Interceptor zu erstellen, können Sie entweder implementieren Interceptor Klasse direkt oder erweitern EmptyInterceptorKlasse. Im Folgenden werden die einfachen Schritte zur Verwendung der Hibernate Interceptor-Funktionalität beschrieben.

Erstellen Sie Interceptors

Wir werden EmptyInterceptor in unserem Beispiel erweitern, in dem die Interceptor-Methode automatisch aufgerufen wird, wenn EmployeeObjekt wird erstellt und aktualisiert. Sie können je nach Ihren Anforderungen weitere Methoden implementieren.

import java.io.Serializable;
import java.util.Date;
import java.util.Iterator;

import org.hibernate.EmptyInterceptor;
import org.hibernate.Transaction;
import org.hibernate.type.Type;

public class MyInterceptor extends EmptyInterceptor {
   private int updates;
   private int creates;
   private int loads;

   public void onDelete(Object entity, Serializable id,
      Object[] state, String[] propertyNames, Type[] types) {
       // do nothing
   }

   // This method is called when Employee object gets updated.
   public boolean onFlushDirty(Object entity, Serializable id,
      Object[] currentState, Object[] previousState, String[] propertyNames,
      Type[] types) {
         if ( entity instanceof Employee ) {
            System.out.println("Update Operation");
            return true; 
         }
         return false;
   }
	
   public boolean onLoad(Object entity, Serializable id,
      Object[] state, String[] propertyNames, Type[] types) {
         // do nothing
         return true;
   }
   
   // This method is called when Employee object gets created.
   public boolean onSave(Object entity, Serializable id,
      Object[] state, String[] propertyNames, Type[] types) {
         if ( entity instanceof Employee ) {
            System.out.println("Create Operation");
            return true; 
         }
         return false;
   }
   
   //called before commit into database
   public void preFlush(Iterator iterator) {
      System.out.println("preFlush");
   }
   
   //called after committed into database
   public void postFlush(Iterator iterator) {
      System.out.println("postFlush");
   }
}

Erstellen Sie POJO-Klassen

Lassen Sie uns nun unser erstes Beispiel ein wenig ändern, in dem wir die EMPLOYEE-Tabelle und die Employee-Klasse verwendet haben, um mit - zu spielen.

public class Employee {
   private int id;
   private String firstName; 
   private String lastName;   
   private int salary;  

   public Employee() {}
   
   public Employee(String fname, String lname, int salary) {
      this.firstName = fname;
      this.lastName = lname;
      this.salary = salary;
   }
   
   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() {
      return salary;
   }
   
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}

Erstellen Sie Datenbanktabellen

Der zweite Schritt wäre das Erstellen von Tabellen in Ihrer Datenbank. Es würde eine Tabelle geben, die jedem Objekt entspricht. Sie sind bereit, Persistenz bereitzustellen. Betrachten Sie die oben erläuterten Objekte, die gespeichert und in der folgenden RDBMS-Tabelle abgerufen werden müssen -

create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);

Erstellen Sie eine Zuordnungskonfigurationsdatei

In diesem Schritt wird eine Zuordnungsdatei erstellt, die den Ruhezustand anweist - wie die definierte Klasse oder die definierten Klassen den Datenbanktabellen zugeordnet werden.

<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 

<hibernate-mapping>
   <class name = "Employee" table = "EMPLOYEE">
      
      <meta attribute = "class-description">
         This class contains the employee detail. 
      </meta>
      
      <id name = "id" type = "int" column = "id">
         <generator class="native"/>
      </id>
      
      <property name = "firstName" column = "first_name" type = "string"/>
      <property name = "lastName" column = "last_name" type = "string"/>
      <property name = "salary" column = "salary" type = "int"/>
      
   </class>
</hibernate-mapping>

Anwendungsklasse erstellen

Schließlich erstellen wir unsere Anwendungsklasse mit der main () -Methode, um die Anwendung auszuführen. Hierbei ist zu beachten, dass wir beim Erstellen des Sitzungsobjekts unsere Interceptor-Klasse als Argument verwendet haben.

import 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.SessionFactory;
import org.hibernate.cfg.Configuration;

public class ManageEmployee {
   private static SessionFactory factory; 
   public static void main(String[] args) {
      
      try {
         factory = new Configuration().configure().buildSessionFactory();
      } catch (Throwable ex) { 
         System.err.println("Failed to create sessionFactory object." + ex);
         throw new ExceptionInInitializerError(ex); 
      }

      ManageEmployee ME = new ManageEmployee();

      /* Add few employee records in database */
      Integer empID1 = ME.addEmployee("Zara", "Ali", 1000);
      Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
      Integer empID3 = ME.addEmployee("John", "Paul", 10000);

      /* List down all the employees */
      ME.listEmployees();

      /* Update employee's records */
      ME.updateEmployee(empID1, 5000);

      /* Delete an employee from the database */
      ME.deleteEmployee(empID2);

      /* List down new list of the employees */
      ME.listEmployees();
   }
   
   /* Method to CREATE an employee in the database */
   public Integer addEmployee(String fname, String lname, int salary){
      Session session = factory.openSession( new MyInterceptor() );
      Transaction tx = null;
      Integer employeeID = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = new Employee(fname, lname, salary);
         employeeID = (Integer) session.save(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
      return employeeID;
   }
   
   /* Method to  READ all the employees */
   public void listEmployees( ){
      Session session = factory.openSession( new MyInterceptor() );
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         List employees = session.createQuery("FROM Employee").list(); 
         for (Iterator iterator = employees.iterator(); iterator.hasNext();){
            Employee employee = (Employee) iterator.next(); 
            System.out.print("First Name: " + employee.getFirstName()); 
            System.out.print("  Last Name: " + employee.getLastName()); 
            System.out.println("  Salary: " + employee.getSalary()); 
         }
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
   
   /* Method to UPDATE salary for an employee */
   public void updateEmployee(Integer EmployeeID, int salary ){
      Session session = factory.openSession( new MyInterceptor() );
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = (Employee)session.get(Employee.class, EmployeeID); 
         employee.setSalary( salary );
		 session.update(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
   
   /* Method to DELETE an employee from the records */
   public void deleteEmployee(Integer EmployeeID){
      Session session = factory.openSession( new MyInterceptor() );
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Employee employee = (Employee)session.get(Employee.class, EmployeeID); 
         session.delete(employee); 
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
}

Zusammenstellung und Ausführung

Erstellen Sie die Konfigurationsdatei hibernate.cfg.xml wie im Konfigurationskapitel erläutert.
Erstellen Sie die Zuordnungsdatei Employee.hbm.xml wie oben gezeigt.
Erstellen Sie die Employee.java-Quelldatei wie oben gezeigt und kompilieren Sie sie.
Erstellen Sie die Quelldatei MyInterceptor.java wie oben gezeigt und kompilieren Sie sie.
Erstellen Sie die Quelldatei ManageEmployee.java wie oben gezeigt und kompilieren Sie sie.
Führen Sie die ManageEmployee-Binärdatei aus, um das Programm auszuführen.

Sie würden das folgende Ergebnis erhalten und Datensätze in der Tabelle EMPLOYEE erstellt.

$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........

Create Operation
preFlush
postFlush
Create Operation
preFlush
postFlush
Create Operation
preFlush
postFlush
First Name: Zara  Last Name: Ali  Salary: 1000
First Name: Daisy  Last Name: Das  Salary: 5000
First Name: John  Last Name: Paul  Salary: 10000
preFlush
postFlush
preFlush
Update Operation
postFlush
preFlush
postFlush
First Name: Zara  Last Name: Ali  Salary: 5000
First Name: John  Last Name: Paul  Salary: 10000
preFlush
postFlush

Wenn Sie Ihre EMPLOYEE-Tabelle überprüfen, sollte sie die folgenden Datensätze enthalten:

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 29 | Zara       | Ali       |   5000 |
| 31 | John       | Paul      |  10000 |
+----+------------+-----------+--------+
2 rows in set (0.00 sec
mysql>