Antes de explicar las herramientas que posee Hibernate al respecto de las claves primarias pasemos a repasar un poco los conceptos de bases de datos sobre claves primarias.

¿Qué propiedades debe tener una buena clave primaria?

• Debe ser única
• No puede ser null
• Nunca debe cambiar
• Debe ser una única columna
• Debe ser rápida de generar

Esta propiedad es obvia para todos , así que no me extenderé más.

Esta propiedad también está clara para cualquiera que sepa de bases de datos

Esta propiedad no es esencial que la cumpla una clave primaria pero si cambia se obliga a modificar todas las filas de otras tablas que tuvieran relación con la clave primaria que se ha modificado. Se podría dar el caso de que fuera necesario modificar miles o millones de filas de una base de datos si cambia una clave primaria, así que es recomendable que una clave primaria nunca cambie.

Esta propiedad tampoco es esencial que la cumpla una clave primaria. Sin embargo en ciertas circunstancias al usar SUBSELECTs en el lenguaje SQL se tiene que recurrir a extensiones propietarias de Oracle por culpa de tener claves primarias compuestas. Además de que podemos encontrarnos con algunas herramientas de desarrollo - como las de generación de informes- que no soporten claves primarias compuestas. Así que para evitar problemas sería recomendable usar claves primarias de una única columna.

Dado que para cada fila que generemos es necesaria una clave primaria es recomendable que el coste de generarla sea lo más bajo posible ya que puede ser un gran coste de tiempo/recursos generar miles o millones de claves primarias diariamente. En los entornos en la nube actuales, en los que se cobra por uso de CPU, la elección de una correcta clave primaria puede ser un ahorro de tiempo y dinero.

¿Cómo elegir entonces una clave primaria que satisfaga todas las anteriores características? La respuesta es sencilla: en la mayoría de los casos la clave primaria debería ser un valor numérico generado automáticamente.

¿Y qué hacemos con las clave primarias naturales? Una clave primaria natural es aquella columna/s de base de datos que actua de clave primaria en el modelo de negocio en el que estamos trabajando.

Por ejemplo, en la Agencia tributaria (Hacienda) debe ser un requerimiento legal que una persona disponga de un NIF para poder tributar. Lo natural es que si tuvieran una tabla Persona, el NIF fuera la clave primaria de dicha tabla. Esta columna se llamaría la clave primaria natural ya que es una columna relacionada con el modelo de negocio con el que estamos trabajando.

Pero, ¿qué problemas tiene usar una clave primaria natural como clave primaria?

• Puede cambiar: Por normal general una clave primaria natural puede llegar a cambiar por requerimientos del propio negocio. Aunque pensemos que el NIF de una persona no cambia sí que lo hace, ya que los niños pueden sacarse un NIF en hacienda sin tener DNI y posteriormente cuando tienen DNI se cambia el NIF inicial por el del DNI.
• Puede ser null: Quizás no tenga valor para un caso concreto del negocio. Por ejemplo, si nuestra app necesita un DNI para funcionar, los recién nacidos no tienen un DNI por lo que la pp fallaría en ciertos casos si la usáramos como clave primaria.
• Puede ser compuesta: La clave primaria natural, por su propia naturaleza, puede estar compuesta de varias columnas y como ya hemos comentado no es muy recomendable esa circunstancia.

Por todo ello seguimos recomendando usar una clave primaria que NO sea natural y que NO tenga significado en el modelo de negocio para evitarnos cualquier tipo de problema indeseado en el futuro.

Antes de entrar en cómo se implementa en Hibernate la generación de la clave primaria , veamos las clases Java y las tablas que se usan.

Para nuestro ejemplo vamos a usar la clase:

• Profesor

1

public class Profesor implements Serializable  {
 
    private int id;
    private String nombre;
    private String ape1;
    private String ape2;
 
    public Profesor(){ 
    }
 
    public Profesor(String nombre, String ape1, String ape2) {
        this.nombre = nombre;
        this.ape1 = ape1;
        this.ape2 = ape2;
    }
}

Podemos apreciar en la línea 11 que al constructor ya no se le pasa el valor de la propiedad id ya que será el propio Hibernate el que la generará.

En el siguiente diagrama UML muestra la clase Profesor.

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

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="ejemplo02.Profesor" >
        <id column="Id" name="id" type="integer">  
            <generator class="increment" />
        </id>
        <property name="nombre" />
        <property name="ape1" />
        <property name="ape2" />
 
    </class>
</hibernate-mapping>

El fichero básicamente es muy sencillo excepto por el nuevo tag <generator> de la línea 6.

El tag <generator> se utiliza para indicar que la clave primaria será generada por el propio Hibernate en vez de asignarla directamente el usuario:

• class:Este atributo indica el método que usará Hibernate para calcular la clave primaria.En nuestro ejemplo el valor es increment.

Los valores más usados del atributo class son los siguientes:

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")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int id;
 
    @Column(name="nombre")
    private String nombre;
 
    @Column(name="ape1")
    private String ape1;
 
    @Column(name="ape2")
    private String ape2;
 
    public Profesor(){ 
    }
 
    public Profesor(String nombre, String ape1, String ape2) {
        this.nombre = nombre;
        this.ape1 = ape1;
        this.ape2 = ape2;
    }
}

Podemos ver cómo se ha añadido la anotación @GeneratedValue para la generación de la clave primaria.

• @GeneratedValue: Esta anotación indica que Hibernate deberá generar el valor de la clave primaria.
  • strategy: Este atributo nos indica el método en el que Hibernate debe generar la clave primaria.En nuestro ejemplo el valor es GenerationType.IDENTITY.Los valores más usados para este atributo son los siguientes:

Acabamos de ver cómo usar las anotaciones del estándar de JPA, pero JPA no dispone de tantos métodos de generación de claves primarias como Hibernate.

Si queremos hacer uso de todos los métodos de generación de claves primarias de que dispone Hibernate mediante el uso de anotaciones, deberemos usar la anotación propietaria de Hibernate llamada @org.hibernate.annotations.GenericGenerator.

En este caso el código fuente de la clase Persona se debe modificar de la siguiente forma:

5

@Id
@Column(name="Id")  
@GeneratedValue( generator = "generador_propietario_hibernate_increment" )
@org.hibernate.annotations.GenericGenerator(
    name = "generador_propietario_hibernate_increment",
    strategy = "increment" 
)
private int id;

Como podemos ver la línea 7 se ha modificado y en la línea 8 se ha añadido la anotación @org.hibernate.annotations.GenericGenerator.

• @org.hibernate.annotations.GenericGenerator: Esta anotación permite crear un nuevo método de generación de claves primarias para ser utilizado desde JPA.
  • name: Es el nombre del nuevo generador de claves primarias.Puede tener cualquier valor.
  • strategy: Es el nombre de un método de generación de claves primarias.Sus valores son los mismos que el del atributo class del tag <generator> tal y como acabamos de ver en el fichero Profesor.hbm.xml.

La anotación @GeneratedValue ahora debe modificarse para usar el atributo generator en vez de strategy. El valor del atributo generator debe ser el nombre del generador que hemos creado , es decir, debe tener el mismo valor que el atributo name de la anotación @org.hibernate.annotations.GenericGenerator.

Veamos ahora cómo se puede generar la clave primaria de forma que sea el mismo valor que la clave primaria de otro objeto. Como en el caso de usar el fichero .hbm.xml vamos a usar como ejemplo la relación uno a uno bidireccional entre Profesor y Direccion. La forma de uisar la anotaciones es muy similar a la anterior de las anotaciones propietarias de Hibernate.

La forma de anotar la clase Direccion es la siguiente:

1

@Id
@Column(name="Id")
@GeneratedValue(generator="generador_clave_ajena")
@org.hibernate.annotations.GenericGenerator(
    name="generador_clave_ajena", 
    strategy="foreign", 
    parameters=@Parameter(name="property", value="profesor")
)
private int id;

Vemos cómo, en esta caso, la estrategia de generación de la clave primaria es “foreign” (Línea 6) y en la siguiente línea se indica que se debe obtener la clave primaria del objeto profesor.

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("Eduardo", "Grau", "Aroca");
 
Session session=sessionFactory.openSession();
session.beginTransaction();
 
session.save(profesor);
 
session.getTransaction().commit();
session.close();

Como podemos ver en la línea 1, al permitir que la clave primaria la genere Hibernate nos ahorramos tener que incluirla en el constructor. Es decir que como en otros casos , el código Java sigue estando muy simplificado gracias a Hibernate.