Bienvenido al tutorial de Hibernate para principiantes. Hibernate es una de las herramientas Java ORM más utilizadas. La mayoría de las aplicaciones utilizan bases de datos relacionales para almacenar información de la aplicación, y a nivel bajo utilizamos JDBC API para conectarnos a las bases de datos y realizar operaciones CRUD.
Tutorial de Hibernate para principiantes
Si observas el código JDBC, hay mucho código de plantilla y existen posibilidades de fugas de recursos e inconsistencia de datos porque todo el trabajo debe ser realizado por el desarrollador. Aquí es donde resulta útil una herramienta ORM. La asignación objeto-relacional o ORM es la técnica de programación para mapear objetos del modelo de dominio de la aplicación a tablas de base de datos relacionales. Hibernate es una herramienta ORM basada en Java que proporciona un marco de trabajo para mapear objetos del dominio de la aplicación a tablas de base de datos relacionales y viceversa. Algunos de los beneficios de usar Hibernate como herramienta ORM son:
- Hibernate admite la asignación de clases Java a tablas de base de datos y viceversa. Proporciona características para realizar operaciones CRUD en todas las principales bases de datos relacionales.
- Hibernate elimina todo el código redundante que viene con JDBC y se encarga de gestionar los recursos, para que podamos centrarnos en casos de uso empresariales en lugar de asegurarnos de que las operaciones de la base de datos no están causando pérdidas de recursos.
- Hibernate admite la gestión de transacciones y se asegura de que no haya datos inconsistentes en el sistema.
- Dado que utilizamos XML, archivos de propiedades o anotaciones para mapear clases Java a tablas de base de datos, proporciona una capa de abstracción entre la aplicación y la base de datos.
- Hibernate nos ayuda a mapear uniones, colecciones, objetos de herencia y podemos visualizar fácilmente cómo nuestras clases de modelo representan las tablas de la base de datos.
- Hibernate proporciona un poderoso lenguaje de consulta (HQL) que es similar a SQL. Sin embargo, HQL es completamente orientado a objetos y comprende conceptos como la herencia, la polimorfia y la asociación.
- Hibernate también ofrece integración con algunos módulos externos. Por ejemplo, Hibernate Validator es la implementación de referencia de Bean Validation (JSR 303).
- Hibernate es un proyecto de código abierto de la comunidad de Red Hat y se utiliza en todo el mundo. Esto lo convierte en una mejor opción que otros porque la curva de aprendizaje es pequeña y hay toneladas de documentación en línea, y la ayuda está fácilmente disponible en los foros.
- Hibernate es fácil de integrar con otros marcos de Java EE, es tan popular que Spring Framework proporciona soporte integrado para la integración de Hibernate con aplicaciones Spring.
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.
Arquitectura de Hibernate
A continuación se muestra la arquitectura de Hibernate y cómo funciona como una capa de abstracción entre las clases de la aplicación y las API de JDBC/JTA para operaciones de base de datos. Es claro que Hibernate se construye sobre las API de JDBC y JTA. 
Veamos los componentes principales de la arquitectura de Hibernate uno por uno.
- SessionFactory (org.hibernate.SessionFactory): SessionFactory es una caché inmutable y segura para subprocesos de mapeos compilados para una sola base de datos. Podemos obtener una instancia de
org.hibernate.SessionusandoSessionFactory. - Session (org.hibernate.Session): Session es un objeto de corta duración y de un solo hilo que representa una conversación entre la aplicación y la tienda persistente. Envuelve
java.sql.Connectionde JDBC y funciona como una fábrica paraorg.hibernate.Transaction. - Objetos Persistentes: Los objetos persistentes son objetos de corta duración y de un solo hilo que contienen estado persistente y funciones comerciales. Estos pueden ser JavaBeans/POJOs ordinarios. Están asociados con exactamente una
org.hibernate.Session. - Objetos transitorios: Los objetos transitorios son instancias de clases persistentes que actualmente no están asociadas con una
org.hibernate.Session. Pueden haber sido instanciados por la aplicación y aún no persistidos, o pueden haber sido instanciados por unaorg.hibernate.Sessioncerrada. - Transacción (org.hibernate.Transaction): La transacción es un objeto de corta duración y de un solo hilo utilizado por la aplicación para especificar unidades de trabajo atómicas. Abstrae a la aplicación de la transacción subyacente de JDBC o JTA. Una
org.hibernate.Sessionpuede abarcar múltiplesorg.hibernate.Transactionen algunos casos. - ConnectionProvider (org.hibernate.connection.ConnectionProvider): ConnectionProvider es una fábrica de conexiones JDBC. Proporciona abstracción entre la aplicación y el
javax.sql.DataSourceojava.sql.DriverManagersubyacente. No se expone a la aplicación, pero puede ser extendido por el desarrollador. - TransactionFactory (org.hibernate.TransactionFactory): Una fábrica para instancias de
org.hibernate.Transaction.
Hibernate y Java Persistence API (JPA)
Hibernate proporciona la implementación de la Java Persistence API, por lo que podemos utilizar anotaciones JPA con beans de modelo y Hibernate se encargará de configurarlo para su uso en operaciones CRUD. Vamos a analizar esto con un ejemplo de anotaciones.
Ejemplo de Hibernate
Al desarrollar aplicaciones con Hibernate, debemos proporcionar dos conjuntos de configuraciones. El primer conjunto de configuraciones contiene propiedades específicas de la base de datos que se utilizarán para crear la conexión a la base de datos y los objetos de sesión. El segundo conjunto de configuraciones contiene el mapeo entre las clases de modelo y las tablas de la base de datos. Podemos utilizar configuraciones basadas en XML o basadas en propiedades para las configuraciones relacionadas con la conexión a la base de datos. Podemos utilizar configuraciones basadas en XML o anotaciones para proporcionar el mapeo entre las clases de modelo y las tablas de la base de datos. Utilizaremos las anotaciones JPA de javax.persistence para los mapeos basados en anotaciones. Nuestro proyecto final se verá como en la siguiente imagen. 
Crea un proyecto Maven en Eclipse o en tu IDE favorito, puedes elegir cualquier nombre que desees. Antes de pasar a los diferentes componentes del proyecto, tendremos que configurar la base de datos.
Configuración de la Tabla de la Base de Datos
Para mi ejemplo, estoy utilizando la base de datos MySQL y el siguiente script se utiliza para crear la tabla necesaria.
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;
Observa que la columna “id” de la tabla Employee se genera automáticamente por MySQL, por lo que no es necesario insertarla.
Dependencias del Proyecto Hibernate
Nuestro archivo pom.xml final se ve así.
<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 contiene todas las clases principales de Hibernate, por lo que obtendremos todas las funciones necesarias al incluirlas en el proyecto. Ten en cuenta que estoy utilizando la última versión de Hibernate (4.3.5.Final) para mi proyecto de ejemplo, y Hibernate sigue evolucionando; he observado que muchas clases principales cambian en cada versión principal. Por lo tanto, si estás utilizando otra versión, existe una pequeña posibilidad de que debas modificar las configuraciones de Hibernate para que funcione. Sin embargo, estoy seguro de que funcionará bien para todas las versiones 4.x.x. Hibernate 4 utiliza el registro de JBoss, pero las versiones antiguas utilizan slf4j con fines de registro, así que he incluido slf4j-simple en mi proyecto, aunque no es necesario porque estoy usando Hibernate 4. mysql-connector-java es el controlador de MySQL para conectarse a bases de datos MySQL; si estás utilizando otra base de datos, agrega el controlador correspondiente.
Clases del Modelo de Dominio
Como se puede observar en la imagen anterior, tenemos dos clases de modelo, Employee y Employee1. Employee es una clase simple de Java Bean y utilizaremos una configuración basada en XML para proporcionar detalles de su asignación. Employee1 es un Java Bean donde los campos están anotados con anotaciones JPA, por lo que no es necesario proporcionar una asignación en un archivo XML separado.
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;
}
}
La clase Employee es un Java Bean simple, no hay nada específico que discutir aquí.
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;
}
}
Se utiliza la anotación javax.persistence.Entity para marcar una clase como un Java Bean de entidad que puede ser persistido por Hibernate, ya que Hibernate proporciona la implementación de JPA. La anotación javax.persistence.Table se utiliza para definir la asignación de la tabla y las restricciones únicas para las columnas. La anotación javax.persistence.Id se utiliza para definir la clave primaria de la tabla. javax.persistence.GeneratedValue se utiliza para indicar que el campo se generará automáticamente y se utiliza la estrategia GenerationType.IDENTITY para que el valor generado “id” se mapee al bean y se pueda recuperar en el programa Java. javax.persistence.Column se utiliza para asignar el campo con la columna de la tabla; también podemos especificar la longitud, nulabilidad y unicidad para las propiedades del bean.
Configuración XML de Mapeo de Hibernate
Como se indicó anteriormente, utilizaremos una configuración basada en XML para el mapeo de la clase Employee. Podemos elegir cualquier nombre, pero es bueno elegir un nombre relacionado con la tabla o el bean de Java para mayor claridad. Nuestro archivo de mapeo de Hibernate para el bean Employee se ve así. 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>
La configuración XML es simple y hace lo mismo que la configuración basada en anotaciones.
Archivos de Configuración de Hibernate
Crearemos dos archivos XML de configuración de Hibernate: uno para la configuración basada en XML y otro para la configuración basada en anotaciones. 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>
La mayoría de las propiedades están relacionadas con la configuración de la base de datos; otros detalles de propiedades se proporcionan en el comentario. Observa la configuración para el archivo de mapeo de Hibernate, podemos definir varios archivos de mapeo de Hibernate y configurarlos aquí. También ten en cuenta que el mapeo es específico para la fábrica de sesiones. 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>
La mayoría de la configuración es la misma que la configuración basada en XML, la única diferencia es la configuración de mapeo. Podemos proporcionar configuración de mapeo para clases y paquetes.
SessionFactory de Hibernate
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 {
//Configuración basada en XML
private static SessionFactory sessionFactory;
//Configuración basada en anotaciones
private static SessionFactory sessionAnnotationFactory;
//Configuración basada en propiedades
private static SessionFactory sessionJavaConfigFactory;
private static SessionFactory buildSessionFactory() {
try {
//Crear la SessionFactory desde 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) {
//Asegúrese de registrar la excepción, ya que podría ser omitida
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
private static SessionFactory buildSessionAnnotationFactory() {
try {
//Crear la SessionFactory desde 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) {
//Asegúrese de registrar la excepción, ya que podría ser omitida
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
private static SessionFactory buildSessionJavaConfigFactory() {
try {
Configuration configuration = new Configuration();
//Crear propiedades, también se pueden leer desde archivos de propiedades
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);
//Podemos establecer el archivo de mapeo o la clase con anotaciones
//addClass(Employee1.class) buscará el recurso
//com/journaldev/hibernate/model/Employee1.hbm.xml (no es bueno)
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;
}
}
Crear un SessionFactory para configuración basada en XML es igual ya sea que el mapeo esté basado en XML o en anotaciones. Para basado en propiedades, necesitamos establecer las propiedades en el objeto Configuration y agregar clases de anotaciones antes de crear el SessionFactory. En general, crear una SessionFactory incluye los siguientes pasos:
- Crear un objeto
Configurationy configurarlo - Crear un objeto
ServiceRegistryy aplicar configuraciones. - Usar
configuration.buildSessionFactory()pasando el objetoServiceRegistrycomo argumento para obtener el objetoSessionFactory.
Nuestra aplicación está casi lista ahora, escribamos algunos programas de prueba y ejecutémoslos.
Prueba de Configuración XML de Hibernate
Nuestro programa de prueba se ve así.
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());
//Obtener Sesión
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
//Iniciar transacción
session.beginTransaction();
//Guardar el objeto del modelo
session.save(emp);
//Confirmar transacción
session.getTransaction().commit();
System.out.println("Employee ID="+emp.getId());
//Finalizar fábrica de sesiones, de lo contrario el programa no terminará
HibernateUtil.getSessionFactory().close();
}
}
El programa se comprende por sí mismo, cuando ejecutamos el programa de prueba, obtenemos la siguiente salida.
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]
Observa que está imprimiendo el ID de empleado generado, puedes verificarlo en la tabla de la base de datos para confirmarlo.
Prueba de Configuración de Anotaciones de Hibernate
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());
//Obtener Sesión
SessionFactory sessionFactory = HibernateUtil.getSessionAnnotationFactory();
Session session = sessionFactory.getCurrentSession();
//Iniciar transacción
session.beginTransaction();
//Guardar el objeto del modelo
session.save(emp);
//Confirmar transacción
session.getTransaction().commit();
System.out.println("Employee ID="+emp.getId());
//Finalizar fábrica de sesiones, de lo contrario el programa no terminará
sessionFactory.close();
}
}
Cuando ejecutamos el programa anterior, obtenemos la siguiente salida.
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]
Échale un vistazo a la salida y compárala con la salida de la configuración basada en XML, notarás algunas diferencias. Por ejemplo, no estamos estableciendo el tamaño del pool de conexiones para la configuración basada en anotaciones, por lo que se establece en el valor predeterminado 20.
Prueba de configuración de Hibernate en Java
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());
// Obtener Sesión
SessionFactory sessionFactory = HibernateUtil.getSessionJavaConfigFactory();
Session session = sessionFactory.getCurrentSession();
// Iniciar transacción
session.beginTransaction();
// Guardar el objeto del modelo
session.save(emp);
// Confirmar transacción
session.getTransaction().commit();
System.out.println("Employee ID="+emp.getId());
// Terminar la fábrica de sesiones, de lo contrario, el programa no terminará
sessionFactory.close();
}
}
La salida del programa de prueba anterior es:
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]
Eso es todo para el tutorial de hibernate para principiantes, espero que sea suficiente para que empieces. Investigaremos diferentes características del framework de Hibernate en futuros tutoriales. Descarga el proyecto completo desde el siguiente enlace y juega con él para aprender más.
Source:
https://www.digitalocean.com/community/tutorials/hibernate-tutorial-for-beginners