====== 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''

<code java 1>
public enum TipoFuncionario {
    Carrera,
    Practicas,
    Interino
}

public class Profesor implements Serializable  {
    
    private int id;
    private String nombre;
    private String ape1;
    private String ape2;
    private TipoFuncionario tipoFuncionario;

    public Profesor(){ 
    }

    public Profesor(int id, String nombre, String ape1, String ape2, TipoFuncionario tipoFuncionario) {
        this.id = id;
        this.nombre = nombre;
        this.ape1 = ape1;
        this.ape2 = ape2;
        this.tipoFuncionario = tipoFuncionario;
    }
}
</code>

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''.

<note important>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.</note>

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


<uml>
class Profesor 
Profesor : int id
Profesor : String nombre
Profesor : String ape1
Profesor : String ape2


class TipoFuncionario <<Enumeration>>
TipoFuncionario : Carrera
TipoFuncionario : Practicas
TipoFuncionario : Interino


Profesor  -->  TipoFuncionario : tipoFuncionario
</uml>

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

<uml>
class Profesor <<Table>>
Profesor : INTEGER id
Profesor : VARCHAR nombre
Profesor : VARCHAR ape1
Profesor : VARCHAR ape2
Profesor : INTEGER tipoFuncionario
</uml>

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:

<code xml 1| Fichero Profesor.hbm.xml>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="ejemplo06.Profesor" >
        <id column="Id" name="id" type="integer"/>   
        <property name="nombre" />
        <property name="ape1" />
        <property name="ape2" />
    
        <property name="tipoFuncionario" >
            <type name="org.hibernate.type.EnumType">
                <param name="enumClass">ejemplo06.TipoFuncionario</param>
                <param name="type">4</param>
            </type>    
        </property>
    </class>
</hibernate-mapping>
</code>

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 <javadoc h41>org.hibernate.type.EnumType</javadoc> 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 <javadoc jdk7>java.sql.Types</javadoc>. 

<note>
¿Qué significa que en el parámetro ''type'' se debe poner el número de java.sql.Types?
La clase Java <javadoc jdk7>java.sql.Types</javadoc> 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  |  
</note>
===== 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:

<code java 1| Clase Profesor anotada >
@Entity
@Table(name="Profesor")
public class Profesor implements Serializable  {
    
    @Id
    @Column(name="Id")
    private int id;
    
    @Column(name="nombre")
    private String nombre;
    
    @Column(name="ape1")
    private String ape1;
    
    @Column(name="ape2")
    private String ape2;
    
    @Enumerated(EnumType.ORDINAL) 
    private TipoFuncionario tipoFuncionario;

    public Profesor(){ 
    }

    public Profesor(int id, String nombre, String ape1, String ape2, TipoFuncionario tipoFuncionario) {
        this.id = id;
        this.nombre = nombre;
        this.ape1 = ape1;
        this.ape2 = ape2;
        this.tipoFuncionario = tipoFuncionario;
    }
}
</code>

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.

<note>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''.</note>
===== Código Java =====
Ahora que ya tenemos preparadas la clase Java para que pueda persistirse veamos el código necesario para persistirla.

<code java 1|Persistiendo la clase Profesor>
Profesor profesor=new Profesor(412, "Elias", "Rubio", "Sánchez",TipoFuncionario.Interino);

Session session=sessionFactory.openSession();
session.beginTransaction();

session.save(profesor);

session.getTransaction().commit();
session.close();
</code>

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