Home‎ > ‎Apuntes‎ > ‎

Levantar Hibernate desde Cero con Maven

Para comenzar con un proyecto que utilice Hibernate nos encontramos con la dificultad de determinar qué dependencias serán necesarias para que la aplicación pueda levantar el framework, y dónde colocar los archivos de configuración necesarios. La presente guía parte de un proyecto Maven nuevo y añade paso a paso lo necesario para poder levantar una aplicación que utilice el framework.

Construcción del proyecto

Podríamos partir de un archetype y obtener un proyecto listo para comenzar a utilizar, pero si nos encontramos con un proyecto Maven ya comenzado deberemos indicar manualmente las dependencias.
Utilizaremos el plugin de Maven para eclipse (m2Eclipse) para visualizar mejor el proceso de construcción. Los mismos pasos pueden realizarse por línea de comandos.
Para todos aquellos que deseen hacer manualmente, recuerden que hay una guía con los pasos inciales para contruir un artefacto básico.

En primer lugar, crearemos un proyecto Maven nuevo. Para ello iremos a:



En el wizard, le indicaremos que saltee la elección de archetypes, tildando la primera opción en la primera pantalla.
A continuación le indicaremos el groupId, el artifactId y la version. Este es un paso común a cualquier proyecto Maven que llevemos a cabo.
El resultado será un proyecto como este:


Esta es la estructura básica de un proyecto Maven.
  • En src/main/java colocaremos los fuentes de nuestra aplicación, a ser compilados.
  • En src/main/resources colocaremos nuestros archivos de configuración y demás recursos de los que se valen los fuentes indicados anteriormente.
  • En src/test/java colocaremos los fuentes de los test cases.
  • En src/test/resources colocaremos los recursos de soporte exlcusivo para los tests.
Dependencias

Como sabemos, con Maven trabajamos las dependencias en forma declarativa. Indicamos solamente el nombre del artefacto y su versión, sin preocuparnos por las dependencias que estos artefactos pueden tener con otros (a estas se las denomina transitivas).
Como veremos luego esta es una gran ventaja a la hora de construir un proyecto ya que manejar manualmente las dependencias transitivas es un proceso costoso en tiempo y propenso a errores.

El plugin de Eclipse nos permite añadir las dependencias de una forma sencilla. Para acceder a esta funcionalidad, seleccionamos el archivo pom.xml, y en la solapa dependencies encontraremos un menú desde el cual agregar las dependencias (desde el icono con el frasquito).


Todo esto puede realizarse manualmente editando el archivo pom.xml y adjuntando las dependencias necesarias una por una como elementos del xml. Se adjunta el pom.xml para quienes deseen visualizar el resultado final.

Las dependencias que agregamos en la captura anterior son todas las necesarias para trabajar con Hibernate en su versión de annotations. A continuación se describe la función de cada una:

hsqldb: HSQLDB es una base de datos que resulta bastante útil a fines de desarrollo y testeo de aplicaciones. Esta dependencia incluye el driver para conectarnos a la base de datos, el dialecto necesario para Hibernate y ciertas utilidades para levantar nuestra base y administrarla desde un analizador de consultas. En caso de querer utilizar otro motor (por ej. Oracle, SQLServer, etc), esta dependencia no sería necesaria, y debería incluirse la que corresponda al motor en cuestión.

hibernate: El core del framework de persitencia que utilizaremos.

hibernate-annotations: La extensión al framework para soportar annotations para realizar el mapeo de las clases.

javax.persistence: La especificación de JEE para ORMs (JPA). La utilizaremos en aquellos casos en que no necesitemos una funcionalidad específica del framework y nos alcance con las que define la especificación.

c3P0: Es una librería que nos facilita algunas funciones comunes a toda aplicación que dialoga con la BD. Entre ellas, la de manejar el pool de conexiones.

Junit: El framework de cabecera para realizar testeo unitario en Java.

javax.transaction: Esta dependencia es un caso particular. Es utilizada por Hibernate, por lo que uno podría esperar que se agregue a nuestro proyecto con sólo indicar dependencia correspondiente al framework (la segunda que listamos). Sin embargo, JTA (Java Transaction API, nombre que recibe esta especificación), requiere aceptar una licencia para poder ser descargada, lo que impide que pueda ser obtenida como dependencia transitiva de Hibernate. Por esta razón la indicamos como una dependencia aparte. El plugin se encarga de descargarla sin requerir ninguna otra intervención nuestra.

Para los que utilicen línea de comandos, esta dependencia debe descargarse manualmente. Los pasos son:

1) Bajar el Class Files 1.0.1B desde
http://java.sun.com/javaee/technologies/jta/index.jsp

2) Por línea de comandos, añadir la dependencia a nuestro repositorio local:

mvn install:install-file -Dfile=jta-1_0_1B-classes.zip -
DgroupId=javax.transaction -DartifactId=jta -Dversion=1.0.1B -
Dpackaging=jar

Como se ve, sólo debimos indicar 7 dependencias en nuestro pom, de las cuales sólo cuatro (hibernate, hibernate-annotations, javax.persistence, javax.transaction) son obligatorias para el uso del framework. Esto reduce considerablemente los artefactos a considerar a la hora de construir el proyecto.

En caso de realizar el proyecto sin Maven, de forma manual, tendríamos que haber tenido en cuenta más artefactos y añadir uno por uno al classpath de nuestro proyecto. A continuación puede verse el grafo completo de dependencias que construyó Maven. Tener en cuenta que en el pom sólo indicamos 7 de los 17 artefactos que aparecen que se agregaron automáticamente.

En proyectos que combinen varios frameworks y librerías, esta funcionalidad de Maven reduce notablemente los tiempos por la gran combinatoria de artefactos a utilizar.


Con esto finaliza la etapa de construcción del proyecto, a continuación se agregarán los archivos de configuración correspondientes.

Configuración

El archivo de configuración que lee por default Hibernate es hibernate.cfg.xml. Este archivo contiene los datos de conexión a la BD, la configuración del pool de conexiones, la registración de las clases persistentes, y otras preferencias que deseemos setear.
Mucha de esta información puede agregarse programáticamente al objeto Configuration al momento de instanciar la SessionFactory, pero colocarla en este archivo suele ser una buena opción cuando se trate de información estática, no susceptible a modificarse en tiempo de ejecución.

Para que Hiberante lo levante en el startup, lo debemos colocar en el root del classpath de nuestro proyecto.
Por convención, colocamos los archivos como este en el folder src/main/resources de nuestro proyecto, y allí puede ser obtenido por el framework:


Se adjunta también un ejemplo de dicho archivo de configuración.

Levantar Base de Datos HSQLDB

Esta base puede utilizarse como server, en memoria, o levantarse a partir de un archivo, entre otras opciones.

    Server: para levantarla como server, podemos utilizar la utilidad Server de hsqldb. Se ejecuta de la siguiente forma:

            public static void main(String[] args) {
                 org.hsqldb.Server.main(args);
            }

    En el hibernate.cfg.xml el String de conexión correspondiente se vería de esta forma:

    <property name="hibernate.connection.url">jdbc:hsqldb:hsql://localhost</property>


   Desde Archivo (Standalone): Para levantarla desde archivo,
no necesitamos correr un script paralelamente, ya que la base será levantada       por Hibernate en el momento de instanciar la SessionFactory.

    En el hibernate.cfg.xml el String de conexión se verá de esta manera:
    
    <property name="hibernate.connection.url">jdbc:hsqldb:file:«database/path?»;shutdown=true</property>


Por último es interesante la utilidad que provee hsqldb para browsear la base de datos creada.
Es parte de la dependencia agregada anteriormente, y puede ejecutarse de la siguiente forma:

    public static void main(String[] args) {
        DatabaseManager.main(args);
    }

Nos ofrece un cliente de SQL sencillo, para poder observar las tablas creadas y realizar queries y modificaciones. Existen aplicaciones open source que soportan esta funcionalidad, como Squirrel. Recomendamos que las prueben para familiarizarse con herramientas útiles en los ambientes de desarrollo.

Con esto ya podremos comenzar a utilizar Hibernate en su versión de annotations.
En la sección de Ejemplos podemos encontrar un proyecto Maven construido de la forma que aquí se menciona, con un mapeo de clases básico para comenzar a probar.
Comments