Introduccion y Configuracion de Hibernate

hibernate

Hibernate.

“Hibernate es una herramienta de Mapeo objeto-relacional (ORM) para la plataforma Java (y disponible también para .Net con el nombre de NHibernate) que facilita el mapeo de atributos entre una base de datos relacional tradicional y el modelo de objetos de una aplicación, mediante archivos declarativos (XML) o anotaciones en los beans de las entidades que permiten establecer estas relaciones. Hibernate es software libre, distribuido bajo los términos de la licencia GNU LGPL. “ – Wikipedia.

Hibernate es un framework que agiliza la relación entre la aplicación y la base de datos. De todos los frameworks ORM que he utilizado, sin dudas es el más completo.
Para aprender Hibernte es necesario tener los conocimientos mínimos de SQL y Java. Conocer JDBC es recomendable. Se puede bajar (en principio con bajar Hibernate Core alcanza) de www.hibernate.org

lite

Si no las tenemos, instalamos las Hibernate Tools (Help -> Eclipse Marketplace -> Hibernate Tools for Indigo)

Creamos el fichero de configuración hibernate.cfg.xml. Para ello nos situamos en nuestro proyecto y con el botón derecho New -> Other -> Hibernate -> Hibernate Configuration File (cfg.xml). Escogemos su situación (normalmente en resources, siguiendo la lógica de Maven) y ponemos los datos de la conexión a la base de datos.

Creamos la consola de configuración de Hibernate (que le servirá al plugin entre otras cosas para generar código) (No veremos que Eclipse haya añadido nada, ya que se trata de una herramienta interna del plugin de Hibernate Tools).

Creamos el fichero reveng.xml, que nos permitirá la ingeniería inversa) New -> Other -> Hibernate -> Hibernate Reverse Engineering File (reveng.xml). Nos situamos sobre el directorio resorces, ratificamos y en la página de configuración escogemos la consola que yahemos creado, le damos a Refresh para ver las bbdd e incluimos las tablas a mapear.

Generamos el código poniéndonos sobre el iconos de las Hibernate Tools y seleccionamos Hibernate Code Generations Configurations…

  Llenamos los datos e indicamos qué queremos generar. Es buena idea volver a generar el fichero de configuración, pues en él se incluirá el mapeo de los ficheros hmb.xml.

Si creamos las clases nosotros, sí podemos crear los hmb.xml mediante las Hibernate Tools y luego cambiar algunas cosillas. Para ello New -> Other -> Hibernate -> Hibernate Mapping file (hbm.xml), añadimos el package donde hemos creado las clases, nos aseguramos de que so las clases crradas, y las generamos. Es buena idea tenerlas en el directorio resources, junto con los otros ficheros de configuración y mapeo.

Aqui os dejo un enlace que detalla la instalacion en modo visual.

Configuración.

Vamos a hacer un paso a paso para dejar todo listo. Primero vamos a colocar los jars en el proyecto. Aqui van los de hibernate (que vienen en la carpeta lib de la distribución), más el del driver correspondiente a la base de datos que esten utilizando. Yo voy a utilizar DB2. A continuació voy a colocar los jars necesarios. He colocado los de Hibernate + DB2 + MySQL por si alguno la usa.

Luego vamos a crear una sencilla tabla en la base de datos:
Para MySQL:

CREATE TABLE `autos` (
`IDAUTO` int(10) unsigned NOT NULL auto_increment,
`MARCA` varchar(255) NOT NULL default ”,
`MODELO` varchar(255) NOT NULL default ”,
PRIMARY KEY (`IDAUTO`)
)

Para DB2:

CREATE TABLE hib.AUTOS (
IDAUTO BIGINT NOT NULL,
MARCA VARCHAR(255),
MODELO VARCHAR(255)
);
CREATE UNIQUE INDEX SQL1108120858221120 ON hib.AUTOS (IDAUTO ASC);
ALTER TABLE hib.AUTOS ADD CONSTRAINT SQL1108128085281980 PRIMARY KEY (IDAUTO);

El siguiente paso es configurar un SessionManager que me permite obtener sesiones y transacciones para trabajar con la base de datos. En este caso haremos uno sencillo, que no sirve para trabajar en producción, pero que nos permite realizar nuestros ejemplos.
Aca les dejo la clase, comentada para que se entienda de donde salen todos los datos.

package configuracion;

import java.util.Properties;

import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

public abstract class SessionManager {

public static Session getSession() throws HibernateException{
// Instancia un objeto del tipo Configuration
Configuration config = new Configuration();

// Registra las clases a mapear en la configuracion
registerMappers(config);

// Establece las propiedades de configuracion
config.setProperties(getHibernateProperties() );

// Retorna una sesion de trabajo
return config.buildSessionFactory().openSession();
}

private static Properties getHibernateProperties(){
// Instancia un objeto del tipo Properties.
Properties props = new Properties();

// Establece el driver de conexion dependiente del RDBMS.
//para MySQL seria:  props.put(“hibernate.connection.driver_class”, “com.mysql.jdbc.Driver”);
props.put(“hibernate.connection.driver_class”, “com.ibm.db2.jcc.DB2Driver”);

// Establece la url de conexion, donde al final va el nombre de la BD
//para MySQL  props.put(“hibernate.connection.url”, “jdbc:mysql://localhost/testHibernate”);
props.put(“hibernate.connection.url”, “jdbc:db2://localhost:50000/sample”);

// Establece el usuario.
props.put(“hibernate.connection.username”, “db2admin”);

// Establece la clave.
props.put(“hibernate.connection.password”, “db2admin”);

// Establece el dialecto a utilizar. Es necesario determinarlo ya que la implementación
// de SQL puede variar con cada motor de base de datos.
// Para MySQL sería: props.put(“hibernate.dialect”, “org.hibernate.dialect.MySQLDialect”);
props.put(“hibernate.dialect”, “org.hibernate.dialect.DB2Dialect”);

// Retorna las propiedades
return props;

}

// Cada clase mapeada deberá aparecer aca.
private static void registerMappers(Configuration config) throws MappingException
{
config.addResource(“negocio/Auto.hbm.xml”);
}
}

Como verán, he configurado el SessionManager de manera programática. Obviamente lo ideal para un proyecto laboral es hacerlo con archivos de configuracion. Aca hay un ejemplo:http://docs.jboss.org/hibernate/core/3.3/reference/en/html/session-configuration.html

Hasta aquí hemos terminado de confgurar Hibernate. Ahora podemos comenzar a utilizarlo. Para ello, haremos la clase Auto y su correspondiente archivo xml

Y, ahora veremos el archivo auto.hbm.xml. La extensión hbm.xml es por conveción. Este archivo representa la forma de relacionar una clase con una tabla. Existirá un hbm.xml por cada clase que desee mapear. Por lo general, se acostumbra dejar el archivo xml en el mismo paquete de la clase mapeada.

<?xml version=”1.0″?>
<!DOCTYPE hibernate-mapping PUBLIC “-//Hibernate/Hibernate Mapping DTD//EN” “http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd”&gt;
<hibernate-mapping>
<class  name=”negocio.Auto” table=”autos”>
<id name=”id” column=”idauto”>
<generator class=”increment” />
</id>
<property name=”marca” />
<property name=”modelo” />
</class>
</hibernate-mapping>

Listo, ya tenemos todo para realizar las primeras pruebas. Pero antes voy a explicar que es cada cosa en el xml:

  1. hibernate-mapping es la raíz del documento y, por ende, todos los tags quedan contenidos dentro de este tag.
  2. El tag class es general: nombra la clase y la tabla.
  3. El tag id representa el atributo que se relaciona con la clave primaria. Su atributo name hace referencia a como se llama el id en la clase (en nuestro caso da la casualidad que se llama id) y el atributo column representa la columna en la base de datos.
  4. El tag property es utilizado para los atributos que no son clave primaria. Sus atributos más importantes son name y column. Si el nombre del atributo coincide con la columna, no es necesario especificar a ambos. Con especificar name es suficiente.
  5. El tag generator esta contenido dentro de id y representa la forma de generar la clase primaria al insertar un nuevo registro. Puede tomar diversos valores pero los más comunes son:
  • increment: para las claves autoincrementales.
  • sequence: para los secuenciadores.
  • assign: para los casos donde la BD no generá la clave primaria, sino que el objeto es quién la determina.

A probar!

Hemos insertado un auto. Tan sencillo como eso, ejecutar el método save.

Vamos a actualizarlo: ahora lo convertiremos en C4:

Y, por último, eliminaremos el registro:

Algunas últimas aclaraciones:

  • No he hecho consultas mediante Hibernate porque habría que profundizar un poco más y prefiero dejarlo para más adelante.
  • Para actualizar un registro es necesario colocarle el id a la clase. En este caso era un Long, por lo que tuve que hacer setId(1L).
  • Hibernate elimina por id de manera automática. Por ello, con solo colocarle el id al objeto auto es suficiente. Para eliminaciones más complejas hay que tirar un poco más de código.

Aqui os dejo un video tutorial como dicen que vale mas un video que mil palabras .

http://migranitodejava.blogspot.com.es/2011/08/introduccion-hibernate.html

http://informaticamedicajava.blogspot.com.es/2011/11/hibernate-y-eclipse.html

Anuncios

Publicado el 9 enero, 2015 en Acceso a Datos en Java. Añade a favoritos el enlace permanente. Comentarios desactivados en Introduccion y Configuracion de Hibernate.

Los comentarios están cerrados.

A %d blogueros les gusta esto: