Willkommen zum Hibernate Tutorial für Anfänger. Hibernate ist eines der am häufigsten verwendeten Java ORM Werkzeuge. Die meisten Anwendungen verwenden relationale Datenbanken zur Speicherung von Anwendungsinformationen und auf niedriger Ebene verwenden wir die JDBC API zur Verbindung mit Datenbanken und zur Durchführung von CRUD-Operationen.
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 durchgeführt werden müssen. Hier kommt ein ORM-Tool ins Spiel. Objekt-relationales Mapping oder ORM ist die Programmierungstechnik, Anwendungsdomänenmodell-Objekte auf die relationalen Datenbanktabellen abzubilden. Hibernate ist ein auf Java basierendes ORM-Tool, das einen Rahmen für das Mapping von Anwendungsdomänen-Objekten auf die relationalen Datenbanktabellen und umgekehrt bereitstellt. Einige der Vorteile der Verwendung von Hibernate als ORM-Tool sind:
- Hibernate unterstützt das Mapping von Java-Klassen zu Datenbanktabellen und umgekehrt. Es bietet Funktionen zur Durchführung von CRUD-Operationen über alle wichtigen relationalen Datenbanken hinweg.
- Hibernate eliminiert den gesamten Standardcode, der mit JDBC einhergeht, und kümmert sich um die Ressourcenverwaltung, sodass wir uns auf Geschäftsanwendungsfälle konzentrieren können, anstatt sicherzustellen, dass Datenbankoperationen keine Ressourcenlecks verursachen.
- Hibernate unterstützt die Transaktionsverwaltung und stellt sicher, dass im System keine inkonsistenten Daten vorhanden sind.
- Da wir XML, Eigenschaftsdateien oder Annotationen zur Zuordnung von Java-Klassen zu Datenbanktabellen verwenden, bietet es eine Abstraktionsschicht zwischen Anwendung und Datenbank.
- Hibernate hilft uns beim Zuordnen von Joins, Sammlungen, Vererbungsobjekten und wir können leicht visualisieren, wie unsere Modellklassen Datenbanktabellen darstellen.
- Hibernate bietet eine leistungsstarke Abfragesprache (HQL), die SQL ähnelt. HQL ist jedoch vollständig objektorientiert und versteht Konzepte wie Vererbung, Polymorphismus und Assoziation.
- Hibernate bietet auch Integration mit einigen externen Modulen an. Zum Beispiel ist Hibernate Validator die Referenzimplementierung der Bean-Validierung (JSR 303).
- Hibernate ist ein Open-Source-Projekt der Red Hat Community und wird weltweit eingesetzt. Dies macht es zu einer besseren Wahl als andere, da die Lernkurve gering ist und es Tonnen von Online-Dokumentationen gibt und Hilfe in Foren leicht verfügbar ist.
- Hibernate lässt sich leicht in andere Java-EE-Frameworks integrieren, es ist so beliebt, dass das Spring Framework eine integrierte Unterstützung für die Integration von Hibernate mit Spring-Anwendungen bietet.
I hope all the above benefits will convince you that Hibernate is the best choice for your application object-relational mapping requirements. Let’s look at the Hibernate Framework architecture now and then we will jump into sample project where we will look into different ways to configure Hibernate in standalone java application and use it.
Hibernate-Architektur
Das folgende Bild zeigt die Hibernate-Architektur und wie sie als Abstraktionsschicht zwischen Anwendungsklassen und JDBC/JTA-APIs für Datenbankoperationen fungiert. Es ist deutlich, dass Hibernate auf den JDBC- und JTA-APIs aufbaut. 
Schauen wir uns die Kernkomponenten der Hibernate-Architektur einzeln an.
- SessionFactory (org.hibernate.SessionFactory): Die SessionFactory ist ein unveränderlicher, thread-sicherer Cache von kompilierten Zuordnungen für eine einzige Datenbank. Wir können eine Instanz von
org.hibernate.SessionüberSessionFactoryerhalten. - Session (org.hibernate.Session): Die Session ist ein Thread-sicheres, kurzlebiges Objekt, das eine Kommunikation zwischen der Anwendung und dem persistenten Speicher repräsentiert. Sie umhüllt
java.sql.Connectionund fungiert als Fabrik fürorg.hibernate.Transaction. - Persistente Objekte: Persistente Objekte sind kurzlebige, single-threaded Objekte, die persistenten Zustand und Geschäftsfunktionen enthalten. Dies können gewöhnliche JavaBeans/POJOs sein. Sie sind mit genau einer
org.hibernate.Sessionverbunden. - Transiente Objekte: Transiente Objekte sind Instanzen von persistierenden Klassen, die derzeit nicht mit einer
org.hibernate.Sessionverknüpft sind. Sie können von der Anwendung instanziiert und noch nicht persistiert worden sein oder von einer geschlossenenorg.hibernate.Sessioninstanziiert worden sein. - Transaktion (org.hibernate.Transaction): Eine Transaktion ist ein eingleisiges, kurzlebiges Objekt, das von der Anwendung verwendet wird, um atomare Arbeitsgruppen anzugeben. Sie 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): Der ConnectionProvider ist eine Fabrik für JDBC-Verbindungen. Er stellt eine Abstraktion zwischen der Anwendung und der zugrunde liegenden
javax.sql.DataSourceoderjava.sql.DriverManagerbereit. Er wird der Anwendung nicht offenbart, kann jedoch vom Entwickler erweitert werden. - TransactionFactory (org.hibernate.TransactionFactory): Eine Fabrik für
org.hibernate.Transaction-Instanzen.
Hibernate und Java Persistence API (JPA)
Hibernate bietet eine Implementierung der Java Persistence API, sodass wir JPA-Annotationen mit Modell-Beans verwenden können, und Hibernate kümmert sich um die Konfiguration, damit sie in CRUD-Operationen verwendet werden kann. Wir werden dies anhand eines Beispiel für Annotationen genauer betrachten.
Hibernate-Beispiel
Bei der Entwicklung von Hibernate-Anwendungen müssen wir zwei Konfigurationssätze bereitstellen. Der erste Satz von Konfigurationen enthält datenbankspezifische Eigenschaften, die zur Erstellung von Datenbankverbindungs- und Sessionobjekten verwendet werden. Der zweite Satz von Konfigurationen enthält die Zuordnung zwischen Modellklassen und Datenbanktabellen. Wir können XML-basierte oder eigenschaftenbasierte Konfigurationen für datenbankverbindungsspezifische Konfigurationen verwenden. Für die Bereitstellung von Modellklassen und Datenbanktabellenzuordnungen können wir XML-basierte oder annotationsbasierte Konfigurationen verwenden. Wir werden JPA-Annotationen aus javax.persistence für annotationsbasierte Zuordnungen verwenden. Unser abschließendes Projekt wird wie das unten stehende Bild aussehen. 
Erstellen Sie ein Maven-Projekt in Eclipse oder Ihrem bevorzugten IDE, Sie können einen beliebigen Namen wählen. Bevor wir zu den verschiedenen Komponenten des Projekts übergehen, müssen wir die Datenbank einrichten.
Datenbanktabelleneinrichtung
Für mein Beispiel verwende ich die MySQL-Datenbank, und das folgende Skript wird verwendet, 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, sodass wir sie nicht einfügen müssen.
Abhängigkeiten des Hibernate-Projekts
Unsere finale 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>
hibernate-core Das Artefakt enthält alle Kern-Hibernate-Klassen, sodass wir alle erforderlichen Funktionen erhalten, indem wir es in das Projekt aufnehmen. Beachten Sie, dass ich die neueste Hibernate-Version (4.3.5.Final) für mein Beispielprojekt verwende und Hibernate sich immer noch entwickelt und ich gesehen habe, dass sich viele Kernklassen zwischen jeder Hauptversion ändern. Wenn Sie also eine andere Version verwenden, besteht eine geringe Chance, dass Sie die Hibernate-Konfigurationen anpassen müssen, damit sie funktionieren. Ich bin jedoch sicher, dass es für alle 4.x.x-Versionen gut funktionieren wird. Hibernate 4 verwendet JBoss-Protokollierung, aber ältere Versionen verwenden slf4j für Protokollierungszwecke, daher habe ich das slf4j-simple-Artefakt in mein Projekt aufgenommen, obwohl es nicht erforderlich ist, weil ich Hibernate 4 verwende. mysql-connector-java ist der MySQL-Treiber zum Verbinden mit MySQL-Datenbanken. Wenn Sie eine andere Datenbank verwenden, fügen Sie das entsprechende Treiberartefakt hinzu.
Domänenmodellklassen
Wie Sie im obigen Bild sehen können, haben wir zwei Modellklassen, Employee und Employee1. Employee ist eine einfache Java-Bean-Klasse, für die wir eine XML-basierte Konfiguration verwenden, um ihre Zuordnungsdetails bereitzustellen. Employee1 ist eine Java-Bean, bei der die Felder mit JPA-Annotationen versehen sind, sodass wir keine separate XML-Datei für die Zuordnung 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 Employee-Klasse ist eine einfache Java-Bean, es gibt hier nichts Besonderes zu diskutieren.
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 javax.persistence.Entity wird verwendet, um eine Klasse als Entity-Bean zu markieren, die von Hibernate persistent gemacht werden kann, da Hibernate eine JPA-Implementierung bereitstellt. Die Annotation javax.persistence.Table wird verwendet, um die Tabellenzuordnung und eindeutige Einschränkungen für die Spalten zu definieren. Die Annotation javax.persistence.Id wird verwendet, um den Primärschlüssel für die Tabelle zu definieren. javax.persistence.GeneratedValue wird verwendet, um zu definieren, dass das Feld automatisch generiert wird, und die Strategie GenerationType.IDENTITY wird verwendet, damit der generierte „id“-Wert dem Bean zugeordnet und im Java-Programm abgerufen werden kann. javax.persistence.Column wird verwendet, um das Feld mit der Tabellenspalte zu verbinden. Wir können auch die Länge, Nullbarkeit und Eindeutigkeit für die Bean-Eigenschaften angeben.
Hibernate Mapping XML-Konfiguration
Wie oben angegeben, verwenden wir eine XML-basierte Konfiguration für die Abbildung der Employee-Klasse. Wir können jeden Namen wählen, aber es ist gut, einen Namen mit Tabellen- oder Java-Bean-Namen für Klarheit zu wählen. Unsere Hibernate-Mapping-Datei für das Employee-Bean sieht wie folgt aus. employee.hbm.xml
<?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 macht dasselbe wie die annotationsbasierte Konfiguration.
Hibernate-Konfigurationsdateien
Wir werden zwei Hibernate-Konfigurations-XML-Dateien erstellen – eine für die XML-basierte Konfiguration und eine andere für die annotationsbasierte 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 sind mit Datenbankkonfigurationen verbunden, weitere Eigenschaftsdetails sind im Kommentar angegeben. Beachten Sie die Konfiguration für die Hibernate-Mapping-Datei, wir können mehrere Hibernate-Mapping-Dateien definieren und diese hier konfigurieren. Beachten Sie auch, dass die Zuordnung spezifisch für die Session-Fabrik 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>
Die meisten Konfigurationen sind dieselben wie bei der XML-basierten Konfiguration, der einzige Unterschied besteht in der Zuordnungskonfiguration. Wir können Zuordnungskonfigurationen für Klassen sowie Pakete bereitstellen.
Hibernate SessionFactory
I have created a utility class where I am creating SessionFactory from XML based configuration as well as property based configuration. For property based configuration, we could have a property file and read it in the class, but for simplicity I am creating Properties instance in the class itself.
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;
//Eigenschaftsbasierte Konfiguration
private static SessionFactory sessionJavaConfigFactory;
private static SessionFactory buildSessionFactory() {
try {
// Erstellen Sie die SessionFactory aus hibernate.cfg.xml
Configuration configuration = new Configuration();
configuration.configure("hibernate.cfg.xml");
System.out.println("Hibernate Configuration loaded");
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
System.out.println("Hibernate serviceRegistry created");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
}
catch (Throwable ex) {
// Achten Sie darauf, die Ausnahme zu protokollieren, da sie verschluckt werden kann
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
private static SessionFactory buildSessionAnnotationFactory() {
try {
// Erstellen Sie die SessionFactory aus hibernate.cfg.xml
Configuration configuration = new Configuration();
configuration.configure("hibernate-annotation.cfg.xml");
System.out.println("Hibernate Annotation Configuration loaded");
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
System.out.println("Hibernate Annotation serviceRegistry created");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
}
catch (Throwable ex) {
// Achten Sie darauf, die Ausnahme zu protokollieren, da sie verschluckt werden kann
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
private static SessionFactory buildSessionJavaConfigFactory() {
try {
Configuration configuration = new Configuration();
//Erstellen Sie Eigenschaften, die auch aus Eigenschaftsdateien gelesen werden können
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", "pankaj");
props.put("hibernate.connection.password", "pankaj123");
props.put("hibernate.current_session_context_class", "thread");
configuration.setProperties(props);
//Wir können Mapping-Datei oder Klasse mit Annotation setzen
//addClass(Employee1.class) sucht nach Ressourcen
// com/journaldev/hibernate/model/Employee1.hbm.xml (nicht empfehlenswert)
configuration.addAnnotatedClass(Employee1.class);
ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();
System.out.println("Hibernate Java Config serviceRegistry created");
SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);
return sessionFactory;
}
catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + 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 die XML-basierte Konfiguration ist unabhängig davon, ob das Mapping auf XML oder Annotation basiert. Für eigenschaftsbasierte Konfiguration müssen wir die Eigenschaften im Configuration-Objekt setzen und die Annotationsklassen hinzufügen, bevor wir die SessionFactory erstellen. Die Erstellung der SessionFactory umfasst insgesamt folgende Schritte:
- Erstellen Sie ein
Configuration-Objekt und konfigurieren Sie es - Erstellen Sie ein
ServiceRegistry-Objekt und wenden Sie Konfigurationseinstellungen an. - Verwenden Sie
configuration.buildSessionFactory(), indem Sie dasServiceRegistry-Objekt als Argument übergeben, um dasSessionFactory-Objekt zu erhalten.
Unsere Anwendung ist jetzt fast bereit. Lassen Sie uns einige Testprogramme schreiben und ausführen.
Hibernate XML-Konfigurationstest
Unser Testprogramm sieht wie folgt aus.
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("Pankaj");
emp.setRole("CEO");
emp.setInsertTime(new Date());
// Session abrufen
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
// Transaktion starten
session.beginTransaction();
// Das Model-Objekt speichern
session.save(emp);
// Transaktion bestätigen
session.getTransaction().commit();
System.out.println("Employee ID="+emp.getId());
// Session Factory beenden, sonst endet das Programm nicht
HibernateUtil.getSessionFactory().close();
}
}
Das Programm ist selbsterklärend. Bei der Ausführung des Testprogramms erhalten wir folgende Ausgabe.
May 06, 2014 12:40:06 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
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 <clinit>
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 <init>
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 <init>
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]
Beachten Sie, dass die generierte Mitarbeiter-ID gedruckt wird. Sie können die Datenbanktabelle überprüfen, um dies zu bestätigen.
Hibernate-Annotierungskonfigurationstest
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 HibernateAnnotationMain {
public static void main(String[] args) {
Employee1 emp = new Employee1();
emp.setName("David");
emp.setRole("Developer");
emp.setInsertTime(new Date());
// Session abrufen
SessionFactory sessionFactory = HibernateUtil.getSessionAnnotationFactory();
Session session = sessionFactory.getCurrentSession();
// Transaktion starten
session.beginTransaction();
// Das Model-Objekt speichern
session.save(emp);
// Transaktion bestätigen
session.getTransaction().commit();
System.out.println("Employee ID="+emp.getId());
// Session Factory beenden, sonst endet das Programm nicht
sessionFactory.close();
}
}
Bei der Ausführung des obigen Programms erhalten wir folgende Ausgabe.
May 06, 2014 12:42:22 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final}
May 06, 2014 12:42:22 AM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {4.3.5.Final}
May 06, 2014 12:42:22 AM org.hibernate.cfg.Environment <clinit>
INFO: HHH000206: hibernate.properties not found
May 06, 2014 12:42:22 AM org.hibernate.cfg.Environment buildBytecodeProvider
INFO: HHH000021: Bytecode provider name : javassist
May 06, 2014 12:42:22 AM org.hibernate.cfg.Configuration configure
INFO: HHH000043: Configuring from resource: hibernate-annotation.cfg.xml
May 06, 2014 12:42:22 AM org.hibernate.cfg.Configuration getConfigurationInputStream
INFO: HHH000040: Configuration resource: hibernate-annotation.cfg.xml
May 06, 2014 12:42:23 AM org.hibernate.cfg.Configuration doConfigure
INFO: HHH000041: Configured SessionFactory: null
Hibernate Annotation Configuration loaded
Hibernate Annotation serviceRegistry created
May 06, 2014 12:42:23 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:42:23 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:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000046: Connection properties: {user=pankaj, password=****}
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator
INFO: HHH000006: Autocommit mode: false
May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure
INFO: HHH000115: Hibernate connection pool size: 20 (min=1)
May 06, 2014 12:42:23 AM org.hibernate.dialect.Dialect <init>
INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQL5Dialect
May 06, 2014 12:42:23 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:42:23 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService
INFO: HHH000399: Using default transaction strategy (direct JDBC transactions)
May 06, 2014 12:42:23 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory <init>
INFO: HHH000397: Using ASTQueryTranslatorFactory
Employee ID=20
May 06, 2014 12:42:23 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 aus der XML-basierten Konfiguration, Sie werden einige Unterschiede feststellen. Zum Beispiel setzen wir die Verbindungs-Pool-Größe für die Annotations-basierte Konfiguration nicht fest, daher wird sie auf den Standardwert 20 gesetzt.
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());
//Session erhalten
SessionFactory sessionFactory = HibernateUtil.getSessionJavaConfigFactory();
Session session = sessionFactory.getCurrentSession();
//Transaktion starten
session.beginTransaction();
//Model-Objekt speichern
session.save(emp);
//Transaktion bestätigen
session.getTransaction().commit();
System.out.println("Employee ID="+emp.getId());
//SessionFactory beenden, sonst endet das Programm nicht
sessionFactory.close();
}
}
Die Ausgabe des obigen Testprogramms ist:
May 06, 2014 12:45:09 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager <clinit>
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 <clinit>
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 <init>
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 <init>
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 alles für das Hibernate-Tutorial für Anfänger, ich hoffe, es reicht, um Ihnen den Einstieg zu erleichtern. In zukünftigen Tutorials werden wir uns mit verschiedenen Funktionen des Hibernate-Frameworks beschäftigen. Laden Sie das komplette Projekt über den untenstehenden Link herunter und probieren Sie es aus, um mehr zu lernen.
Source:
https://www.digitalocean.com/community/tutorials/hibernate-tutorial-for-beginners