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.

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 {
    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;
    }
}

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 el siguiente diagrama UML se ve la relación entre Profesor y TipoFuncionario.

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

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.

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

• Profesor.hbm.xml

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

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>

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

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

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

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

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

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

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| 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;
    }
}

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.

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

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();

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