Luis Gómez Caballero Desarrollo de software

Hibernate es una herramienta que implementa la especificación JPA usando metadatos para mapear clases Java con objetos de base de datos.

Tabla de base de datos

Vamos a usar una tabla en una base de datos de tipo MySQL. Instalamos XAMPP y vamos a phpMyAdmin a crear una base de datos llamada “mydatabase” y ahí introducimos (en la pestaña SQL) el siguiente código:

mytable.sql

CREATE TABLE `mytable` (
  `myId` int(11) NOT NULL,
  `myString` varchar(32) NOT NULL,
  `myDate` date NOT NULL,
  `myFloat` float(10,2) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

ALTER TABLE `mytable`
  ADD PRIMARY KEY (`myId`);

ALTER TABLE `mytable`
  MODIFY `myId` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=9;
COMMIT;

Clase Java

Mapearemos la tabla con la siguiente clase Java (que crearemos posteriormente en el proyecto después de generarlo).

MyTable.java

package com.luisgomezcaballero.data.entity;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "mytable")
public class MyTable {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer myId;
	private String myString;
	private Date myDate;
	private Float myFloat;

	public Integer getMyId() {
		return myId;
	}

	public void setMyId(Integer myId) {
		this.myId = myId;
	}

	public String getMyString() {
		return myString;
	}

	public void setMyString(String myString) {
		this.myString = myString;
	}

	public Date getMyDate() {
		return myDate;
	}

	public void setMyDate(Date myDate) {
		this.myDate = myDate;
	}

	public Float getMyFloat() {
		return myFloat;
	}

	public void setMyFloat(Float myFloat) {
		this.myFloat = myFloat;
	}

}

Creación del projecto

Creamos un nuevo proyecto de tipo Maven, para así poder gestionar mejor las dependencias, y creamos la clase Java anterior.

Dependencias

Ahora abrimos el fichero pom.xml e introducimos estas cuatro dependencias:

  <dependencies>
  	<dependency>
  		<groupId>org.hibernate</groupId>
  		<artifactId>hibernate-core</artifactId>
  		<version>5.3.0.Beta2</version>
  	</dependency>
  	<dependency>
  		<groupId>org.hibernate</groupId>
  		<artifactId>hibernate-annotations</artifactId>
  		<version>3.5.6-Final</version>
  	</dependency>
  	<dependency>
  		<groupId>org.slf4j</groupId>
  		<artifactId>slf4j-api</artifactId>
  		<version>1.8.0-beta1</version>
  	</dependency>
  	<dependency>
  		<groupId>org.slf4j</groupId>
  		<artifactId>slf4j-log4j12</artifactId>
  		<version>1.8.0-beta1</version>
  	</dependency>
  </dependencies>

Además, como vamos a usar MySQL, necesitamos el conector Java, que incluimos dentro de las dependencias:

  	<dependency>
  		<groupId>mysql</groupId>
  		<artifactId>mysql-connector-java</artifactId>
  		<version>8.0.9-rc</version>
  	</dependency>

Esperamos a que se descarguen.

Configuración

Vamos a configurar el proyecto de tal forma que tengamos un elemento sesión único. Para esto usaremos un patrón Singleton y una clase adicional llamada Util.java. Es importante especificar correctamente las propiedades de acuerdo a nuestra configuración de base de datos. En este caso usamos un objeto Properties pero es más común usar una configuración XML mediante un fichero llamado hibernate.cfg.xml.

Util.java

package com.luisgomezcaballero.data;

import java.util.Properties;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;

import com.luisgomezcaballero.data.entity.MyTable;

public class Util {
	private static final SessionFactory sessionFactory = buildSessionFactory();

	private static SessionFactory buildSessionFactory() {
		Configuration configuration = new Configuration();

		configuration.addAnnotatedClass(MyTable.class);
		
		Properties properties = new Properties();
		properties.put("hibernate.connection.username", "root");
		properties.put("hibernate.connection.password", "");
		properties.put("hibernate.connection.driver_class", "com.mysql.cj.jdbc.Driver");
		properties.put("hibernate.connection.url", "jdbc:mysql://localhost:3306/myDatabase");
		
		configuration.setProperties(properties);
		
		return configuration.buildSessionFactory(new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build());
	}

	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}
}

Método main()

Creamos una clase con un método main donde crearemos la sesión, iniciaremos una transacción, crearemos un objeto de tipo MyTable, rellenando sus propiedades, y finalmente lo persistiremos.

HibernateDemo.java

package com.luisgomezcaballero.data;

import java.util.Date;

import org.hibernate.Session;

import com.luisgomezcaballero.data.entity.MyTable;

public class HibernateDemo {

	public static void main(String[] args) {

		Session session = Util.getSessionFactory().openSession();
		session.getTransaction().begin();

		MyTable myTable = new MyTable();
		myTable.setMyString("test1");
		myTable.setMyDate(new Date());
		myTable.setMyFloat(new Float("1.25"));
		
		session.save(myTable);
		session.getTransaction().commit();
		session.close();
	}

}

Ejemplo de uso

Clic derecho sobre HibernateDemo, Run As Java Application. Por consola veremos (si no hay ningún error de configuración que se mostrará en color rojo) que se muestra el objeto que hemos creado con los valores que hemos especificado. Si abrimos phpMyAdmin para revisar el contenido de la tabla, veremos que los datos se han introducido correctamente.

Repositorio

Este proyecto de demostración puede encontrarse en https://github.com/luisgomezcaballero/hibernate-demo.

Luis Gómez Caballero