Hibernate-Tutorial für Anfänger
Hibernate ist eines der am weitesten verbreiteten Java ORM-Werkzeuge. Die meisten Anwendungen verwenden relationale Datenbanken, um Anwendungsinformationen zu speichern. Auf niedriger Ebene verwenden wir die JDBC-API, um eine Verbindung zu Datenbanken herzustellen und CRUD-Operationen durchzuführen.
Hibernate-Tutorial für Anfänger
Wenn Sie sich den JDBC-Code ansehen, gibt es so viel Boilerplate-Code, und es besteht die Gefahr von Ressourcenlecks und Dateninkonsistenzen, da alle Arbeiten vom Entwickler erledigt werden müssen. Hier kommt ein ORM-Werkzeug ins Spiel. Objekt-Relational Mapping (ORM) ist die Programmiertechnik, um Anwendungsdomänenmodellobjekte mit den relationalen Datenbanktabellen zu verknüpfen. Hibernate ist ein Java-basiertes ORM-Werkzeug, das ein Framework bereitstellt, um Anwendungsdomänenobjekte mit den relationalen Datenbanktabellen zu verknüpfen und umgekehrt. Einige Vorteile hat Hibernate als ORM-Werkzeug:
Vorteile:
- Hibernate unterstützt die Zuordnung von Java-Klassen zu Datenbanktabellen und umgekehrt. Es bietet Funktionen, um CRUD-Operationen über alle wichtigen relationalen Datenbanken durchzuführen.
- Es eliminiert den gesamten Boilerplate-Code, der mit JDBC einhergeht, und kümmert sich um das Ressourcenmanagement, sodass wir uns auf geschäftliche Anwendungsfälle konzentrieren können, anstatt sicherzustellen, dass Datenbankoperationen keine Ressourcenlecks verursachen.
- Und unterstützt das Transaktionsmanagement und stellt sicher, dass keine inkonsistenten Daten im System vorhanden sind.
- Da wir XML, Property-Dateien oder Annotationen verwenden, um Java-Klassen mit Datenbanktabellen zu verknüpfen, bietet es eine Abstraktionsschicht zwischen Anwendung und Datenbank.
- Hibernate hilft uns bei der Zuordnung von Joins, Sammlungen, Vererbungsobjekten und wir können leicht visualisieren, wie unsere Modellklassen die Datenbanktabellen darstellen.
- Es bietet eine leistungsstarke Abfragesprache (HQL), die SQL ähnelt. HQL ist jedoch vollständig objektorientiert und versteht Konzepte wie Vererbung, Polymorphismus und Assoziationen.
- Hibernate bietet auch die Integration mit einigen externen Modulen. Zum Beispiel ist Hibernate Validator die Referenzimplementierung der Bean Validation (JSR 303).
- Hibernate ist ein Open-Source-Projekt der Red Hat Community und wird weltweit verwendet. Dies macht es zu einer besseren Wahl als andere, da die Lernkurve gering ist und es eine Menge Online-Dokumentation sowie leicht zugängliche Hilfe in Foren gibt.
- Es lässt sich leicht in andere Java EE-Frameworks integrieren. Es ist so beliebt, dass das Spring Framework integrierte Unterstützung für die Integration von Hibernate in Spring-Anwendungen bietet.
Ich hoffe, alle oben genannten Vorteile überzeugen Sie davon, dass Hibernate die beste Wahl für Ihre Anforderungen an das Objekt-Relational Mapping in Anwendungen ist. Schauen wir uns jetzt die Architektur des Hibernate-Frameworks an, bevor wir in ein Beispielprojekt eintauchen, in dem wir verschiedene Möglichkeiten zur Konfiguration von Hibernate in eigenständigen Java-Anwendungen untersuchen und nutzen werden.
Hibernate-Architektur
Das folgende Bild zeigt die Hibernate-Architektur und wie es als Abstraktionsschicht zwischen Anwendungs-Klassen und JDBC/JTA-APIs für Datenbankoperationen fungiert. Es ist klar, dass Hibernate auf JDBC- und JTA-APIs aufgebaut ist.
Werfen wir einen Blick auf die Kernkomponenten der Hibernate-Architektur:
- SessionFactory (org.hibernate.SessionFactory): SessionFactory ist ein unveränderlicher, threadsicherer Cache von kompilierten Zuordnungen für eine einzige Datenbank. Wir können eine Instanz von
org.hibernate.Sessionmit SessionFactory erhalten. - Session (org.hibernate.Session): Session ist ein einzelnes, kurzlebiges Objekt, das ein Gespräch zwischen der Anwendung und dem persistenten Speicher darstellt. Es umschließt JDBC
java.sql.Connectionund dient als Fabrik fürorg.hibernate.Transaction. - Persistente Objekte: Persistente Objekte sind kurzlebige, einzel-threadige Objekte, die persistente Zustände und Geschäftslogik enthalten. Sie können einfache JavaBeans/POJOs sein und sind genau einer
org.hibernate.Sessionzugeordnet. - Transiente Objekte: Transiente Objekte sind Instanzen persistenter Klassen, die derzeit nicht mit einer
org.hibernate.Sessionverbunden sind. Sie wurden möglicherweise von der Anwendung instanziiert und noch nicht gespeichert oder von einer geschlossenenorg.hibernate.Sessionerstellt. - Transaction (org.hibernate.Transaction): Transaction ist ein einzel-threadiges, kurzlebiges Objekt, das von der Anwendung verwendet wird, um atomare Arbeitseinheiten zu definieren. Es abstrahiert die Anwendung von der zugrunde liegenden JDBC- oder JTA-Transaktion. Eine
org.hibernate.Sessionkann in einigen Fällen mehrereorg.hibernate.Transactionumfassen. - ConnectionProvider (org.hibernate.connection.ConnectionProvider): ConnectionProvider ist eine Fabrik für JDBC-Verbindungen. Es bietet eine Abstraktion zwischen der Anwendung und der zugrunde liegenden
javax.sql.DataSourceoderjava.sql.DriverManager. Es wird nicht der Anwendung ausgesetzt, kann jedoch vom Entwickler erweitert werden. - TransactionFactory (org.hibernate.TransactionFactory): Eine Fabrik für Instanzen von
org.hibernate.Transaction.
Hibernate und Java Persistence API (JPA)
Hibernate bietet eine Implementierung der Java Persistence API. So können wir JPA-Annotationen mit Modell-Beans verwenden, und Hibernate kümmert sich um die Konfiguration, um sie in CRUD-Operationen zu verwenden. Dies werden wir an einem Beispiel mit Annotationen untersuchen.
Hibernate-Beispiel
Bei der Entwicklung von Hibernate-Anwendungen müssen wir zwei Konfigurationssätze bereitstellen. Der erste Satz enthält datenbankspezifische Eigenschaften, die zum Erstellen einer Datenbankverbindung und von Sitzungsobjekten verwendet werden. Der zweite Satz enthält Zuordnungen zwischen Modellklassen und Datenbanktabellen. Wir können XML-basierte oder eigenschaftsbasierte Konfigurationen für datenbankbezogene Einstellungen verwenden. Für die Zuordnung von Modellklassen und Datenbanktabellen können wir XML-basierte oder annotierte Konfigurationen verwenden. Wir werden JPA-Annotationen von javax.persistence für annotierte Zuordnungen verwenden.
Unser finales Projekt wird wie folgt aussehen:
Erstellen Sie ein Maven-Projekt in Eclipse oder Ihrer bevorzugten IDE. Sie können einen beliebigen Namen Ihrer Wahl verwenden. Bevor wir zu den einzelnen Komponenten des Projekts übergehen, müssen wir die Datenbank einrichten.
Datenbanktabellen-Einrichtung
Für mein Beispiel verwende ich eine MySQL-Datenbank und das folgende Skript, um die erforderliche Tabelle zu erstellen:
CREATE TABLE `Employee` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(20) DEFAULT NULL,
`role` varchar(20) DEFAULT NULL,
`insert_time` datetime DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8;
Beachten Sie, dass die Spalte id der Employee-Tabelle automatisch von MySQL generiert wird. Daher müssen wir sie nicht einfügen.
Hibernate-Projektabhängigkeiten
Unsere endgültige pom.xml-Datei sieht wie folgt aus:
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev.hibernate</groupId>
<artifactId>HibernateExample</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>HibernateExample</name>
<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.3.5.Final</version>
</dependency>
<!-- Hibernate 4 uses Jboss logging, but older versions slf4j for logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>1.7.5</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.0.5</version>
</dependency>
</dependencies>
<build>
<finalName>${project.artifactId}</finalName>
</build>
</project>
Das hibernate-core-Artefakt enthält alle Kernklassen von Hibernate, sodass wir durch das Hinzufügen dieses Artefakts zum Projekt alle notwendigen Funktionen erhalten. Beachten Sie, dass ich die neueste Hibernate-Version (4.3.5.Final) für mein Beispielprojekt verwende. Hibernate entwickelt sich weiterhin weiter, und ich habe beobachtet, dass sich viele Kernklassen zwischen Hauptversionen ändern. Wenn Sie eine andere Version verwenden, müssen Sie möglicherweise die Hibernate-Konfiguration geringfügig anpassen, damit sie funktioniert. Hibernate 4 verwendet JBoss-Logging, während ältere Versionen slf4j für die Protokollierung verwenden. Daher habe ich das slf4j-simple-Artefakt in mein Projekt aufgenommen, obwohl es nicht erforderlich ist, da ich Hibernate 4 verwende. Das mysql-connector-java-Artefakt ist der MySQL-Treiber für die Verbindung zu MySQL-Datenbanken. Wenn Sie eine andere Datenbank verwenden, fügen Sie das entsprechende Treiber-Artefakt hinzu.
Domänenmodell-Klassen
Wie Sie im folgenden Code sehen können, haben wir zwei Modellklassen: Employee und Employee1. Employee ist eine einfache Java-Bean-Klasse, und wir verwenden XML-basierte Konfigurationen, um ihre Zuordnungsdetails bereitzustellen. Employee1 ist eine Java-Bean, deren Felder mit JPA-Annotationen versehen sind, sodass wir keine Zuordnung in einer separaten XML-Datei bereitstellen müssen.
package com.journaldev.hibernate.model;
import java.util.Date;
public class Employee {
private int id;
private String name;
private String role;
private Date insertTime;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
public Date getInsertTime() {
return insertTime;
}
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
}
Die Klasse Employee ist eine einfache Java-Bean-Klasse. Es gibt hier nichts Besonderes zu besprechen.
package com.journaldev.hibernate.model;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;
@Entity
@Table(name="Employee",
uniqueConstraints={@UniqueConstraint(columnNames={"ID"})})
public class Employee1 {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="ID", nullable=false, unique=true, length=11)
private int id;
@Column(name="NAME", length=20, nullable=true)
private String name;
@Column(name="ROLE", length=20, nullable=true)
private String role;
@Column(name="insert_time", nullable=true)
private Date insertTime;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getRole() {
return role;
}
public void setRole(String role) {
this.role = role;
}
public Date getInsertTime() {
return insertTime;
}
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
}
Die Annotation @Entity wird verwendet, um eine Klasse als persistierbare Entitäts-Bean zu kennzeichnen, die von Hibernate verarbeitet werden kann. Da Hibernate eine JPA-Implementierung bietet, verwenden wir @Entity. @Table wird verwendet, um die Tabellenzuordnung und eindeutige Einschränkungen für die Spalten zu definieren. Die Annotation @Id definiert den Primärschlüssel für die Tabelle. Die Annotation @GeneratedValue gibt an, dass das Feld automatisch generiert wird, und die Strategie GenerationType.IDENTITY wird verwendet, um den generierten ID-Wert der Bean zuzuordnen und ihn im Java-Programm abzurufen. @Column ordnet das Feld der Tabellenspalte zu und ermöglicht das Festlegen von Länge, Nullwerten und Eindeutigkeit für die Bean-Eigenschaften.
Hibernate-Mapping-XML-Konfiguration
Wie oben erwähnt, werden wir die XML-basierte Konfiguration für die Zuordnung der Klasse Employee verwenden. Wir können einen beliebigen Namen für die Zuordnungsdatei wählen, aber es ist ratsam, den Tabellen- oder Java-Bean-Namen für Klarheit zu verwenden. Unsere Hibernate-Mapping-Datei für die Bean Employee sieht wie folgt aus:
<?xml version=“1.0″?>
<!DOCTYPE hibernate-mapping PUBLIC „-//Hibernate/Hibernate Mapping DTD 3.0//EN“
„https://hibernate.org/dtd/hibernate-mapping-3.0.dtd“>
<hibernate-mapping>
<class name=“com.journaldev.hibernate.model.Employee“ table=“EMPLOYEE“>
<id name=“id“ type=“int“>
<column name=“ID“ />
<generator class=“increment“ />
</id>
<property name=“name“ type=“java.lang.String“>
<column name=“NAME“ />
</property>
<property name=“role“ type=“java.lang.String“>
<column name=“ROLE“ />
</property>
<property name=“insertTime“ type=“timestamp“>
<column name=“insert_time“ />
</property>
</class>
</hibernate-mapping>
Die XML-Konfiguration ist einfach und erfüllt denselben Zweck wie die auf Annotationen basierende Konfiguration.
Hibernate-Konfigurationsdateien
Wir werden zwei Hibernate-Konfigurations-XML-Dateien erstellen: eine für die XML-basierte Konfiguration und eine für die auf Annotationen basierende Konfiguration.
hibernate.cfg.xml
<?xml version=“1.0″ encoding=“UTF-8″?>
<!DOCTYPE hibernate-configuration PUBLIC
„-//Hibernate/Hibernate Configuration DTD 3.0//EN“
„https://hibernate.org/dtd/hibernate-configuration-3.0.dtd“>
<hibernate-configuration>
<session-factory>
<!– Database connection properties – Driver, URL, user, password –>
<property name=“hibernate.connection.driver_class“>com.mysql.jdbc.Driver</property>
<property name=“hibernate.connection.url“>jdbc:mysql://localhost/TestDB</property>
<property name=“hibernate.connection.username“>pankaj</property>
<property name=“hibernate.connection.password“>pankaj123</property>
<!– Connection Pool Size –>
<property name=“hibernate.connection.pool_size“>1</property>
<!– org.hibernate.HibernateException: No CurrentSessionContext configured! –>
<property name=“hibernate.current_session_context_class“>thread</property>
<!– Outputs the SQL queries, should be disabled in Production –>
<property name=“hibernate.show_sql“>true</property>
<!– Dialect is required to let Hibernate know the Database Type, MySQL, Oracle etc
Hibernate 4 automatically figure out Dialect from Database Connection Metadata –>
<property name=“hibernate.dialect“>org.hibernate.dialect.MySQLDialect</property>
<!– mapping file, we can use Bean annotations too –>
<mapping resource=“employee.hbm.xml“ />
</session-factory>
</hibernate-configuration>
Die meisten Eigenschaften beziehen sich auf die Datenbankkonfigurationen. Beachten Sie die Konfiguration für die Hibernate-Mapping-Datei. Wir können mehrere Hibernate-Mapping-Dateien definieren und sie hier konfigurieren. Beachten Sie auch, dass die Zuordnung spezifisch für die SessionFactory ist.
hibernate-annotation.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection properties - Driver, URL, user, password -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
<property name="hibernate.connection.username">pankaj</property>
<property name="hibernate.connection.password">pankaj123</property>
<!-- org.hibernate.HibernateException: No CurrentSessionContext configured! -->
<property name="hibernate.current_session_context_class">thread</property>
<!-- Mapping with model class containing annotations -->
<mapping class="com.journaldev.hibernate.model.Employee1"/>
</session-factory>
</hibernate-configuration>
Diese Konfiguration ähnelt der XML-basierten Konfiguration. Der einzige Unterschied liegt in der Zuordnungsmethode, die hier über eine annotierte Klasse erfolgt.
Hibernate SessionFactory
Hier ist eine Dienstprogrammklasse, die eine SessionFactory für verschiedene Konfigurationen erstellt: XML-basiert, Annotation-basiert und Java-basiert.
package com.journaldev.hibernate.util;
import java.util.Properties;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import com.journaldev.hibernate.model.Employee1;
public class HibernateUtil {
// XML-basierte Konfiguration
private static SessionFactory sessionFactory;
// Annotation-basierte Konfiguration
private static SessionFactory sessionAnnotationFactory;
// Java-basierte Konfiguration
private static SessionFactory sessionJavaConfigFactory;
private static SessionFactory buildSessionFactory() {
try {
Configuration configuration = new Configuration();
configuration.configure("hibernate.cfg.xml");
System.out.println("Hibernate-Konfiguration geladen");
ServiceRegistry serviceRegistry =
new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
System.out.println("Hibernate ServiceRegistry erstellt");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
} catch (Throwable ex) {
System.err.println("Fehler bei der Erstellung der SessionFactory: " + ex);
throw new ExceptionInInitializerError(ex);
}
}
private static SessionFactory buildSessionAnnotationFactory() {
try {
Configuration configuration = new Configuration();
configuration.configure("hibernate-annotation.cfg.xml");
System.out.println("Hibernate-Annotation-Konfiguration geladen");
ServiceRegistry serviceRegistry =
new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
System.out.println("Hibernate Annotation ServiceRegistry erstellt");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
} catch (Throwable ex) {
System.err.println("Fehler bei der Erstellung der SessionAnnotationFactory: " + ex);
throw new ExceptionInInitializerError(ex);
}
}
private static SessionFactory buildSessionJavaConfigFactory() {
try {
Configuration configuration = new Configuration();
// Eigenschaften hinzufügen, kann auch aus einer Property-Datei gelesen werden
Properties props = new Properties();
props.put("hibernate.connection.driver_class", "com.mysql.jdbc.Driver");
props.put("hibernate.connection.url", "jdbc:mysql://localhost/TestDB");
props.put("hibernate.connection.username", "username");
props.put("hibernate.connection.password", "password");
props.put("hibernate.current_session_context_class", "thread");
configuration.setProperties(props);
// Annotierte Klasse hinzufügen
configuration.addAnnotatedClass(Employee1.class);
ServiceRegistry serviceRegistry =
new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
System.out.println("Hibernate JavaConfig ServiceRegistry erstellt");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
} catch (Throwable ex) {
System.err.println("Fehler bei der Erstellung der SessionJavaConfigFactory: " + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
if (sessionFactory == null) sessionFactory = buildSessionFactory();
return sessionFactory;
}
public static SessionFactory getSessionAnnotationFactory() {
if (sessionAnnotationFactory == null) sessionAnnotationFactory = buildSessionAnnotationFactory();
return sessionAnnotationFactory;
}
public static SessionFactory getSessionJavaConfigFactory() {
if (sessionJavaConfigFactory == null) sessionJavaConfigFactory = buildSessionJavaConfigFactory();
return sessionJavaConfigFactory;
}
}
Die Erstellung einer SessionFactory für XML-basierte Konfigurationen ist gleich, unabhängig davon, ob die Zuordnung XML-basiert oder auf Annotationen basiert. Für eigenschaftsbasierte Konfigurationen müssen wir die Eigenschaften im Configuration-Objekt festlegen und Annotationsklassen hinzufügen, bevor die SessionFactory erstellt wird. Insgesamt umfasst die Erstellung einer SessionFactory folgende Schritte:
- Erstellung eines
Configuration-Objekts und Konfiguration desselben. - Erstellung eines
ServiceRegistry-Objekts und Anwendung der Konfigurationseinstellungen. - Verwendung von
configuration.buildSessionFactory(), wobei dasServiceRegistry-Objekt als Argument übergeben wird, um die SessionFactory zu erhalten.
Unsere Anwendung ist fast bereit, jetzt schreiben wir einige Testprogramme und führen sie aus.
Hibernate XML-Konfigurationstest
Hier ist ein Testprogramm, das die XML-basierte Konfiguration verwendet:
package com.journaldev.hibernate.main;
import java.util.Date;
import org.hibernate.Session;
import com.journaldev.hibernate.model.Employee;
import com.journaldev.hibernate.util.HibernateUtil;
public class HibernateMain {
public static void main(String[] args) {
Employee emp = new Employee();
emp.setName("John");
emp.setRole("Manager");
emp.setInsertTime(new Date());
// Session abrufen
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
// Transaktion starten
session.beginTransaction();
// Model-Objekt speichern
session.save(emp);
// Transaktion abschließen
session.getTransaction().commit();
System.out.println("Employee ID=" + emp.getId());
// SessionFactory beenden, damit das Programm endet
HibernateUtil.getSessionFactory().close();
}
}
Das Programm ist selbsterklärend. Wenn wir das Testprogramm ausführen, erhalten wir folgende Ausgabe:
May 06, 2014 12:40:06 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager
INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final}
May 06, 2014 12:40:06 AM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {4.3.5.Final}
May 06, 2014 12:40:06 AM org.hibernate.cfg.Environment
INFO: HHH000206: hibernate.properties not found
May 06, 2014 12:40:06 AM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
May 06, 2014 12:40:06 AM org.hibernate.cfg.Configuration configure
INFO: HHH000043: Configuring from resource: hibernate.cfg.xml
May 06, 2014 12:40:06 AM org.hibernate.cfg.Configuration getConfigurationInputStream
INFO: HHH000040: Configuration resource: hibernate.cfg.xml
May 06, 2014 12:40:07 AM org.hibernate.cfg.Configuration addResource
INFO: HHH000221: Reading mappings from resource: employee.hbm.xml
May 06, 2014 12:40:08 AM org.hibernate.cfg.Configuration doConfigure
INFO: HHH000041: Configured SessionFactory: null
Hibernate Configuration loaded
Hibernate serviceRegistry created
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!)
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB]
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000046: Connection properties: {user=pankaj, password=****}
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000006: Autocommit mode: false
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
INFO: HHH000115: Hibernate connection pool size: 1 (min=1)
May 06, 2014 12:40:08 AM org.hibernate.dialect.Dialect
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQLDialect
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation
INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4
May 06, 2014 12:40:08 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService
INFO: HHH000399: Using default transaction strategy (direct JDBC transactions)
May 06, 2014 12:40:08 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory
INFO: HHH000397: Using ASTQueryTranslatorFactory
Hibernate: select max(ID) from EMPLOYEE
Hibernate: insert into EMPLOYEE (NAME, ROLE, insert_time, ID) values (?, ?, ?, ?)
Employee ID=19
May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]
Werfen Sie einen Blick auf die Ausgabe und vergleichen Sie sie mit der Ausgabe der XML-basierten Konfiguration. Sie werden einige Unterschiede feststellen. Zum Beispiel legen wir keine Verbindungspoolgröße für die Annotation-basierte Konfiguration fest, daher wird der Standardwert 20 verwendet.
Hibernate Java-Konfigurationstest
package com.journaldev.hibernate.main;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import com.journaldev.hibernate.model.Employee1;
import com.journaldev.hibernate.util.HibernateUtil;
public class HibernateJavaConfigMain {
public static void main(String[] args) {
Employee1 emp = new Employee1();
emp.setName("Lisa");
emp.setRole("Manager");
emp.setInsertTime(new Date());
//Get Session
SessionFactory sessionFactory = HibernateUtil.getSessionJavaConfigFactory();
Session session = sessionFactory.getCurrentSession();
//start transaction
session.beginTransaction();
//Save the Model object
session.save(emp);
//Commit transaction
session.getTransaction().commit();
System.out.println("Employee ID="+emp.getId());
//terminate session factory, otherwise program won't end
sessionFactory.close();
}
}
Folgender Output kommt dann raus:
May 06, 2014 12:45:09 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager
INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final}
May 06, 2014 12:45:09 AM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {4.3.5.Final}
May 06, 2014 12:45:09 AM org.hibernate.cfg.Environment
INFO: HHH000206: hibernate.properties not found
May 06, 2014 12:45:09 AM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
Hibernate Java Config serviceRegistry created
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!)
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB]
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000046: Connection properties: {user=pankaj, password=****}
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000006: Autocommit mode: false
May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
INFO: HHH000115: Hibernate connection pool size: 20 (min=1)
May 06, 2014 12:45:10 AM org.hibernate.dialect.Dialect
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQL5Dialect
May 06, 2014 12:45:10 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation
INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4
May 06, 2014 12:45:10 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService
INFO: HHH000399: Using default transaction strategy (direct JDBC transactions)
May 06, 2014 12:45:10 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory
INFO: HHH000397: Using ASTQueryTranslatorFactory
Employee ID=21
May 06, 2014 12:45:10 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]
Das war das Hibernate-Tutorial für Anfänger, ich hoffe, es reicht aus, um Ihnen den Einstieg zu erleichtern. Wir haben die Grundlagen von Hibernate, seine Vorteile und die Konfiguration mit XML, Annotationen und Java-basierter Konfiguration behandelt. Außerdem haben wir gezeigt, wie man SessionFactory-Instanzen erstellt und Testprogramme ausführt, um mit einer Datenbank zu interagieren. Mit diesem Fundament sind Sie bereit, fortgeschrittene Themen wie Abfrageoptimierung, Caching und die Integration mit Frameworks wie Spring zu erkunden. Viel Erfolg beim Programmieren!
