Enumerados

En este tema vamos a ver cómo persistir los tipo enumerados.

Hibernate no soporta directamente el persistir los enumerados pero, gracias a sus potentes mecanismos de extensión, es muy sencillo persistir un enumerado.

Clases Java

Antes de entrar en cómo se implementa en Hibernate , veamos las clases Java que vamos a usar:

  • Clase Profesor
  • Enumerado TipoFuncionario
 1: public enum TipoFuncionario {
 2:     Carrera,
 3:     Practicas,
 4:     Interino
 5: }
 6:
 7: public class Profesor implements Serializable  {
 8:
 9:     private int id;
10:     private String nombre;
11:     private String ape1;
12:     private String ape2;
13:     private TipoFuncionario tipoFuncionario;
14:
15:     public Profesor(){
16:     }
17:
18:     public Profesor(int id, String nombre, String ape1, String ape2, TipoFuncionario tipoFuncionario) {
19:         this.id = id;
20:         this.nombre = nombre;
21:         this.ape1 = ape1;
22:         this.ape2 = ape2;
23:         this.tipoFuncionario = tipoFuncionario;
24:     }
25: }

En las líneas de la 1 a la 5 se ha creado el enumerado TipoFuncionario y en la línea 13 la propiedad tipoFuncionario es del tipo TipoFuncionario.

En la clase Java Profesor no se han incluido los métodos get/set de cada propiedad para facilitar la lectura pero deben estar en la clase Java.

En el siguiente diagrama UML se ve la relación entre Profesor y TipoFuncionario.

PlantUML Graph

Tablas

La tablas de base de datos quedarían de la siguiente forma:

PlantUML Graph

Podemos apreciar que en el diseño de la tabla de la base de datos se ha añadido una columna de tipo INTEGER llamada tipoFuncionario para guardar el valor del enumerado.

Fichero de mapeo ''.hbm.xml''

Al persistir la clase será necesario un único fichero de persistencia:

  • Profesor.hbm.xml

Profesor.hbm.xml

El fichero Profesor.hbm.xml quedará de la siguiente forma:

 1: <?xml version="1.0" encoding="UTF-8"?>
 2: <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 3: <hibernate-mapping>
 4:     <class name="ejemplo06.Profesor" >
 5:         <id column="Id" name="id" type="integer"/>
 6:         <property name="nombre" />
 7:         <property name="ape1" />
 8:         <property name="ape2" />
 9:
10:         <property name="tipoFuncionario" >
11:             <type name="org.hibernate.type.EnumType">
12:                 <param name="enumClass">ejemplo06.TipoFuncionario</param>
13:                 <param name="type">4</param>
14:             </type>
15:         </property>
16:     </class>
17: </hibernate-mapping>

Fichero Profesor.hbm.xml

El fichero incluye el nuevo tag type en la línea 11.

Tag type

El tag <type> debe estar dentro de un tag property y se utiliza para definir una forma personalizada de persistir una propiedad Java.

Atributos
  • name:Este atributo contiene la FQCN de una clase Java que sabe cómo persistir una propiedad Java.Es decir, que como Hibernate no soporta persistir Enumerados, es necesaria una clase Java que se encargará de persistir los enumerados. Por suerte, dicha clase se incluye dentro del propio código de Hibernate, así que no es necesario crearla. Por lo tanto, el valor de name siempre deberá ser org.hibernate.type.EnumType en caso de persistir enumerados.
Tag anidados
  • param: Este tag se usa para indicarle a la clase Java org.hibernate.type.EnumType el enumerado a persistir y el tipo de la columna de base de datos que hemos usado. Los posibles parámetros son:
    • enumClass: El valor del <param> con name=“enumClass” debe ser la FQCN del enumerado a persistir. En nuestro ejemplo es ejemplo06.TipoFuncionario.
    • type: El valor del <param> con name=“enumClass” debe ser un número correspondiente a los valores de la clase Java java.sql.Types.

¿Qué significa que en el parámetro type se debe poner el número de java.sql.Types? La clase Java java.sql.Types define una serie de tipos de SQL mediante propiedades estáticas de tipo int, es decir que cada tipo SQL corresponde a un valor numérico.

En la siguiente tabla podemos ver los tipos SQL que soportan el parámetro type de Hibernate y su valor numérico.

Valor numérico Tipo SQL Forma de persistencia
4 Types.INTEGER Se almacena el ordinal del enumerado
2 Types.NUMERIC Se almacena el ordinal del enumerado
5 Types.SMALLINT Se almacena el ordinal del enumerado
-6 Types.TINYINT Se almacena el ordinal del enumerado
-5 Types.BIGINT Se almacena el ordinal del enumerado
3 Types.DECIMAL Se almacena el ordinal del enumerado
8 Types.DOUBLE Se almacena el ordinal del enumerado
6 Types.FLOAT Se almacena el ordinal del enumerado
1 Types.CHAR Se almacena el nombre del enumerado
-16 Types.LONGVARCHAR Se almacena el nombre del enumerado
12 Types.VARCHAR Se almacena el nombre del enumerado

Es decir, que si usamos una columna de tipo numérica como por ejemplo TINYINT deberemos poner el valor -6

<param name="type">-6</param>

En ese caso el valor que se guardará es un número correspondiente al orden que ocupa el valor del enumerado al definirlo. En nuestro ejemplo el enumerado se guardará de la siguiente manera:

Valor del Enumerado Valor guardado en la base de datos
Carrera 0
Practicas 1
Interino 2

Mientras que si usamos una columna de tipo alfanumérico como por ejemplo VARCHAR deberemos poner el valor 12

<param name="type">12</param>

En ese caso el valor que se guardará es el nombre del propio enumerado. En nuestro ejemplo el enumerado se guardará de la siguiente manera:

Valor del Enumerado Valor guardado en la base de datos
Carrera Carrera
Practicas Practicas
Interino Interino

Anotaciones

Para usar anotaciones deberemos modificar el código fuente de las clases Java y no usar los ficheros .hbm.xml.

El código fuente de la clase Profesor queda de la siguiente forma:

 1: @Entity
 2: @Table(name="Profesor")
 3: public class Profesor implements Serializable  {
 4:
 5:     @Id
 6:     @Column(name="Id")
 7:     private int id;
 8:
 9:     @Column(name="nombre")
10:     private String nombre;
11:
12:     @Column(name="ape1")
13:     private String ape1;
14:
15:     @Column(name="ape2")
16:     private String ape2;
17:
18:     @Enumerated(EnumType.ORDINAL)
19:     private TipoFuncionario tipoFuncionario;
20:
21:     public Profesor(){
22:     }
23:
24:     public Profesor(int id, String nombre, String ape1, String ape2, TipoFuncionario tipoFuncionario) {
25:         this.id = id;
26:         this.nombre = nombre;
27:         this.ape1 = ape1;
28:         this.ape2 = ape2;
29:         this.tipoFuncionario = tipoFuncionario;
30:     }
31: }

Clase Profesor anotada

Podemos ver cómo en la línea 18 se ha incluido la anotación @Enumerated.

  • @Enumerated: Esta anotación indica que la propiedad Java es un enumerado.
    • EnumType Este atributo indica cómo se debe persistir en la base de datos el enumerado. Sus posible valores son:
      • ORDINAL: Se almacenará en la base de datos el ordinal del enumerado.
      • STRING: Se almacenará en la base de datos el nombre del enumerado.

Podemos ver cómo Hibernate soporta la persistencia de Enumerados de una forma mucho más sencilla usando las anotaciones que usando el fichero .hbm.xml.

Código Java

Ahora que ya tenemos preparadas la clase Java para que pueda persistirse veamos el código necesario para persistirla.

 1: Profesor profesor=new Profesor(412, "Elias", "Rubio", "Sánchez",TipoFuncionario.Interino);
 2:
 3: Session session=sessionFactory.openSession();
 4: session.beginTransaction();
 5:
 6: session.save(profesor);
 7:
 8: session.getTransaction().commit();
 9: session.close();

Persistiendo la clase Profesor

Como podemos ver, el usar enumerados no añade ningún tipo de complejidad al código Java que se usa.

unidades/04_claves_primarias_y_tipos_datos/04_enumerados.txt · Última modificación: 2016/07/03 20:35 (editor externo)
Ir hasta arriba
CC Attribution-Noncommercial-Share Alike 3.0 Unported
chimeric.de = chi`s home Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0