====== Uno a uno (bidireccional) ======
Esta lección es muy similar a la anterior , pero en éste caso la relación entre las clases ''Profesor'' y ''Direccion'' va a ser bidireccional.


===== Clases Java =====
Antes de entrar en cómo se implemente en Hibernate , veamos las clases Java y las tablas que definen la relación //uno a uno//. 

Para nuestro ejemplo vamos a usar las clases:
  * ''Profesor''
  * ''Direccion''

Estas dos clases van a tener una relación uno a uno.

<code java 1 | Listado 1.Relación 1 a 1>
public class Profesor implements Serializable  {
    private int id;
    private String nombre;
    private String ape1;
    private String ape2;
    private Direccion direccion;
    
    public Profesor(){ 
    }

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

public class Direccion implements Serializable  {
    private int id;
    private String calle;
    private int numero;
    private String poblacion;
    private String provincia;
    private Profesor profesor;
    
    public Direccion(){ 
    }

    public Direccion(int id, String calle, int numero, String poblacion, String provincia) {
        this.id = id;
        this.calle = calle;
        this.numero = numero;
        this.poblacion = poblacion;
        this.provincia = provincia;
    }    
}

</code>

En el listado 1 podemos ver cómo la clase ''Profesor'' tiene una propiedad llamada ''direccion'' de la clase ''Direccion'' (línea 6) y además la clase ''Direccion'' también posee referencia a ''Profesor'' ya que hemos definido que la relación es bidireccional desde ''Profesor'' hacia ''Direccion'' y viceversa.

<note important>En la clases Java ''Profesor'' y ''Direccion'' 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 desde ''Profesor'' hacia ''Direccion'' y viceversa.

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


class Direccion
Direccion : int id
Direccion : String calle
Direccion : int numero
Direccion : String poblacion
Direccion : String provincia

Profesor "0..1" -- "0..1" Direccion

</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


class Direccion <<Table>>
Direccion : INTEGER id
Direccion : VARCHAR calle
Direccion : INTEGER numero
Direccion : VARCHAR poblacion
Direccion : VARCHAR provincia

Profesor "0..1" -- "0..1" Direccion
</uml>

Podemos apreciar que en el diseño de las tabla de la base de datos ya no existe una columna en ''Profesor'' con la clave primaria de ''Direccion'' o viceversa ya que si la hubiera sería una relación //muchos a uno//. Entonces ¿cómo se establece la relación entre las dos filas? Simplemente porque tanto ''Profesor'' como ''Direccion'' **deben tener** la misma clave primaria y de esa forma se establece la relación.

===== Fichero de mapeo ''.hbm.xml'' =====
Al persistir dos clases serán necesarios dos ficheros de persistencia:
  * ''Profesor.hbm.xml''
  * ''Direccion.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="ejemplo01.Profesor" >
    <id column="Id" name="id" type="integer"/>
    <property name="nombre" />
    <property name="ape1" />
    <property name="ape2" />
    
    <one-to-one name="direccion" cascade="all" />

  </class>
</hibernate-mapping>
</code>

El fichero básicamente contiene lo que se ha explicado en las lecciones anteriores excepto por el tag ''<one-to-one>'' de la línea 10.

=== Tag one-to-one ===
El tag ''<one-to-one>'' se utiliza para definir una relación //uno a uno// entre las dos clases Java. En su forma más sencilla contiene sólamente dos atributos:
  * ''name'':Este atributo contiene el nombre de la propiedad Java con la referencia al otro objeto con el que forma la relación //uno a uno//. En nuestro ejemplo es el atributo ''direccion''.
  * ''cascade'': Este atributo indicará a hibernate cómo debe actuar cuando realicemos las operaciones de persistencia de guardar, borrar, leer, etc. En el ejemplo el valor debe ser ''all'' indicando que deberemos realizar la misma operación en ''Profesor'' que en''Direccion''.

<note>Más información sobre el atributo ''cascade'' en [[unidades:03_relaciones:06_cascade]]</note> 

==== Direccion.hbm.xml ====

El fichero ''Direccion.hbm.xml'' quedará de la siguiente forma:
<code xml 1| Fichero Direccion.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="ejemplo01.Direccion" >
    <id column="Id" name="id" type="integer"/>
    <property name="calle"/>
    <property name="numero"/>
    <property name="poblacion"/>
    <property name="provincia"/>
    
    <one-to-one name="profesor" cascade="all" />
    
  </class>
</hibernate-mapping>
</code>

La clase ''Direccion'' también tiene la relación //uno a uno// hacia profesor.

===== 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 >
import java.io.Serializable;
import javax.persistence.*;


@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;
    
    @OneToOne(cascade=CascadeType.ALL)
    @PrimaryKeyJoinColumn
    private Direccion direccion;
}
</code>

A la propiedad ''direccion'' (línea 24) se han añadido dos anotaciones para indicar la relación //uno a uno// y que esta relación se implementa mediante la clave primaria.
  * **@OneToOne(cascade=CascadeType.ALL)**: Esta anotación indica la relación //uno a uno// de las 2 tablas. También indicamos el valor de ''cascade'' al igual que en el fichero de hibernate.
  * **@PrimaryKeyJoinColumn**: Indicamos que la relación entre las dos tablas se realiza mediante la clave primaria.
<note tip>En caso de no incluir la anotación ''@PrimaryKeyJoinColumn'' se producirá un error indicando que falta la columna ''direccion_Id'' en la tabla ''Profesor''. </note>
<note tip>Notar que si utilizamos anotaciones es necesario usar ''@PrimaryKeyJoinColumn'' mientras que usando el fichero ''.hbm.xml'' no es necesario indicarlo.</note>
<note>Más información sobre el atributo ''cascade'' en [[unidades:03_relaciones:06_cascade]]</note>

El código de ''Direccion'' es similar al anterior.

<code java 1 | Clase Direccion anotada >
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;


@Entity
@Table(name="Direccion")
public class Direccion implements Serializable  {

    @Id
    @Column(name="Id")
    private int id;
    
    @Column(name="calle")
    private String calle;
    
    @Column(name="numero")
    private int numero;
    
    @Column(name="poblacion")
    private String poblacion;
    
    @Column(name="provincia")
    private String provincia;
    
    @OneToOne(cascade=CascadeType.ALL)
    @PrimaryKeyJoinColumn
    private Profesor profesor;    
}
</code>

Como en el caso anterior vemos cómo debemos incluir los tags ''@OneToOne'' y ''@PrimaryKeyJoinColumn'' (Líneas 22 y 23) para establecer la relación entre ''Direccion'' y ''Profesor''.
====== Código Java ======
Ahora que ya tenemos preparadas las clase Java para que puedan persistirse veamos el código necesario para persistirlas.

<code java 1 | Persistiendo la clase Profesor>
Direccion direccion1=new Direccion(3, "Calle de la sarten", 23, "Manises", "Valencia");
Profesor profesor1=new Profesor(3, "Sergio", "Mateo", "Ramis");
profesor1.setDireccion(direccion1);
direccion1.setProfesor(profesor1);
        
Direccion direccion2=new Direccion(4, "Calle Luis lamarca", 45, "Torrente", "Valencia");
Profesor profesor2=new Profesor(4, "Paco", "Moreno", "Díaz");
profesor2.setDireccion(direccion2);
direccion2.setProfesor(profesor2);        
        
        
Session session=sessionFactory.openSession();    
session.beginTransaction();
        
session.save(profesor1);
session.save(direccion2);
        
session.getTransaction().commit();
session.close();
</code>

El ejemplo incluye dos casos:
  * Crear un objeto ''direccion1'' y otro ''profesor1'' (líneas 1 y 2),  crear las relaciones (líneas 3 y 4) y finalmente en la línea 16 guardar el objeto ''profesor1''.
  * Crear un objeto ''direccion2'' y otro ''profesor2'' (líneas 6 y 7),  crear las relaciones (líneas 8 y 9) y finalmente en la línea 17 guardar el objeto ''direccion2''.

<note important>
En ambos casos el resultado aparente es el mismo , se guarda tanto el objeto ''Direccion'' como el objeto ''Profesor'' al ser la relación bidireccional aunque realmente los 2 casos **no** son iguales; veamos ahora el porqué.

En el primer caso, si persistimos un objeto ''Profesor'' se inserta directamente dicho objeto en la base de datos por lo que **no** puede existir ya la fila pero sí que se permite que la ''Direccion'' ya exista, actualizándose en dicho caso. Pero en el segundo caso si persistimos el objeto ''Direccion'' lo que ocurre es lo contrario, no podrá existir la fila de la dirección pero sí podrá existir la fila del ''Profesor''.

</note>