Este tutorial se basa en el mapeo de una base de datos en Postgresql, utilizando eclipse y el Hibernate Tools.
Primero crearemos el usuario y la base de datos a utilizar
$ createuser -P -U postgres mundo
Enter password for new role:
Enter it again:
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) y
Shall the new role be allowed to create more new roles? (y/n) n
CREATE ROLE
$ createdb -U mundo -W mundo
Password:
CREATE DATABASE
$
Ahora con el siguiente script, creamos la estructura de la base de datos
mundo.sql
SET client_encoding = 'UTF8';
SET check_function_bodies = false;
SET client_min_messages = warning;
-- Table: continente
CREATE TABLE continente
(
codcontinente serial NOT NULL,
nombre character varying(50) NOT NULL,
CONSTRAINT pk_continente PRIMARY KEY (codcontinente)
)
WITH (OIDS=FALSE);
ALTER TABLE continente OWNER TO mundo;
-- Table: pais
CREATE TABLE pais
(
codpais serial NOT NULL,
valor character varying(50) NOT NULL,
codcontinente integer NOT NULL,
CONSTRAINT pk_pais PRIMARY KEY (codpais),
CONSTRAINT fk_continente FOREIGN KEY (codcontinente)
REFERENCES continente (codcontinente) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
)
WITH (OIDS=FALSE);
ALTER TABLE pais OWNER TO mundo;
-- Index: fki_pais_continente
CREATE INDEX fki_pais_continente
ON pais
USING btree
(codcontinente);
$ psql -U mundo -W -f mundo.sql
Password for user mundo:
SET
SET
SET
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE INDEX
$
Ahora crearemos la aplicación que utilizará estas dos tablas.
Primero creamos un "Java Proyect"
Le agregamos las librerías necesarias para Hibernate y el driver jdbc para Postgresql
Una vez creado el proyecto, agregamos el archivo de configuración de Hibernate
Lo dejamos en la raíz del directorio de recursos.
Definimos los parámetros de conexión con la base de datos.
Creamos el "Hibernate Console Configuration", este es el perfil que define todas las características del proyecto con Hibernate.
Una vez creado el "Console Configuration", podemos ir a la vista de Hibernate y ejecutar el generador de código.
Creamos un nuevo perfil.
Le indicamos las caracteristicas de nuestro proyecto.
Le idicamos que genere los archivos de configuración de Hibernate y las clases POJO. Y ejecutamos.
Aquí podemos ver el código generado.
Luego agregamos hibernate.revenge.xml, el archivo de filtro para la ingeniería inversa.
Le indicamos que se guarde en el directorio de recursos del proyecto.
Podemos agregar algún retoque, por ejemplo, que los campos INTEGER de la base de datos, sean mapeados como java.lang.Integer.
Retocamos las claves primarias, para que utilicen la secuencia definida en la base de datos.
Lo mismo con la otra tabla.
Ahora agregagemos un par de clases de servicio, que nos ayudaran con las operaciónes CRUD.
SessionFactory.java : como su nombre lo indica es una fábrica de sesiones.
package test;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;
/**
* Configures and provides access to Hibernate sessions, tied to the
* current thread of execution. Follows the Thread Local Session
* pattern, see {@link http://hibernate.org/42.html }.
*/
public class SessionFactory {
/**
* Location of hibernate.cfg.xml file.
* Location should be on the classpath as Hibernate uses
* #resourceAsStream style lookup for its configuration file.
* The default classpath location of the hibernate config file is
* in the default package. Use #setConfigFile() to update
* the location of the configuration file for the current session.
*/
private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
private static final ThreadLocal threadLocal = new ThreadLocal();
private static Configuration configuration = new Configuration();
private static org.hibernate.SessionFactory sessionFactory;
private static String configFile = CONFIG_FILE_LOCATION;
private SessionFactory() {
}
/**
* Returns the ThreadLocal Session instance. Lazy initialize
* the SessionFactory if needed.
*
* @return Session
* @throws HibernateException
*/
public static Session getSession() throws HibernateException {
Session session = (Session) threadLocal.get();
if (session == null || !session.isOpen()) {
System.out.println("<<<<<<<<<>>>>>>>");
if (sessionFactory == null) {
rebuildSessionFactory();
}
session = (sessionFactory != null) ? sessionFactory.openSession()
: null;
threadLocal.set(session);
}
return session;
}
/**
* Rebuild hibernate session factory
*
*/
public static void rebuildSessionFactory() {
try {
configuration.configure(configFile);
sessionFactory = configuration.buildSessionFactory();
} catch (Exception e) {
System.err
.println("%%%% Error Creating SessionFactory %%%%");
e.printStackTrace();
}
}
/**
* Close the single hibernate session instance.
*
* @throws HibernateException
*/
public static void closeSession() throws HibernateException {
Session session = (Session) threadLocal.get();
threadLocal.set(null);
if (session != null) {
session.close();
}
}
/**
* return session factory
*
*/
public static org.hibernate.SessionFactory getSessionFactory() {
return sessionFactory;
}
/**
* return session factory
*
* session factory will be rebuilded in the next call
*/
public static void setConfigFile(String configFile) {
SessionFactory.configFile = configFile;
sessionFactory = null;
}
/**
* return hibernate configuration
*
*/
public static Configuration getConfiguration() {
return configuration;
}
}
ControlHibernate.java
package test;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
public class ControlHibernate {
private static Logger log = Logger.getLogger(ControlHibernate.class);
public static List getObjetos(String hql) throws HibernateException {
List items = new ArrayList();
Session session = null;
Transaction tx = null;
session = SessionFactory.getSession();
try {
tx = session.beginTransaction();
items = session.createQuery(hql).list();
tx.commit();
} catch (HibernateException e) {
if (tx != null)
tx.rollback();
throw e;
} finally {
session.close();
}
return items;
}
public static void guardarObjeto(Object objeto, Integer codigo)
throws HibernateException {
Session session = null;
Transaction tx = null;
session = SessionFactory.getSession();
try {
tx = session.beginTransaction();
// modifica objeto
if ((codigo != null) && (codigo.intValue() != 0)) {
log.info("va a hacer 'merge' de objeto");
session.saveOrUpdate(objeto);
session.flush();
} else { // inserta objeto
log.info("va a hacer 'save' de objeto");
session.save(objeto);
}
tx.commit();
} catch (HibernateException e) {
if (tx != null)
tx.rollback();
throw e;
} finally {
session.close();
}
}
}
Como prueba final de este tutorial, Creamos una clase Prueba.java , que crea un objeto Pais, con un objeto Continente anidado y los almacena en la base de datos.
Aquí podemos observer que los datos se ingresaron correctamente.
También podemos utilizar el editor de sentencias HQL, para realizar pruebas.
Si tienes una crítica o aporte, no dudes en comentarla.
:wq
