Componentes

Los componentes permiten que varias clases relacionadas se almacenen en una única tabla de la base de datos. Es similar a la relación uno a uno desde el punto de vista de Java pero en la base de datos sólo hay una tabla.

Clases Java

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

Para nuestro ejemplo vamos a usar las clases:

  • Profesor
  • Nombre
 1: public class Profesor implements Serializable  {
 2:     private int id;
 3:     private Nombre nombre;
 4:
 5:     public Profesor(){
 6:     }
 7:
 8:     public Profesor(int id, Nombre nombre) {
 9:         this.id = id;
10:         this.nombre=nombre;
11:     }
12: }
13:
14: public class Nombre implements Serializable {
15:     private String nombre;
16:     private String ape1;
17:     private String ape2;
18:
19:     public Nombre() {
20:
21:     }
22:
23:     public Nombre(String nombre, String ape1, String ape2) {
24:         this.nombre = nombre;
25:         this.ape1 = ape1;
26:         this.ape2 = ape2;
27:     }
28:
29:     public String getNombreCompleto() {
30:         StringBuilder sb=new StringBuilder();
31:         if ((ape1!=null) && (ape1.trim().length()>0)) {
32:             sb.append(ape1);
33:         }
34:         if ((ape2!=null) && (ape2.trim().length()>0)) {
35:             if (sb.length()>0) {
36:                 sb.append(" ");
37:             }
38:             sb.append(ape2);
39:         }
40:         if ((nombre!=null) && (nombre.trim().length()>0)) {
41:             if (sb.length()>0) {
42:                 sb.append(",");
43:             }
44:             sb.append(nombre);
45:         }
46:
47:
48:         return sb.toString();
49:     }
50:
51:     public String getIniciales() {
52:         StringBuilder sb=new StringBuilder();
53:         if ((nombre!=null) && (nombre.trim().length()>0)) {
54:             sb.append(nombre.substring(0,1));
55:         }
56:         if ((ape1!=null) && (ape1.trim().length()>0)) {
57:             sb.append(ape1.substring(0,1));
58:         }
59:         if ((ape2!=null) && (ape2.trim().length()>0)) {
60:             sb.append(ape2.substring(0,1));
61:         }
62:
63:         return sb.toString().toUpperCase();
64:     }
65: }

Lo que hemos hecho es extraer las propiedades nombre, ape1 y ape2 en una nueva clase llamada Nombre. ¿Para qué hacer este cambio? Para justificarlo hemos añadido los métodos getNombreCompleto() y getIniciales(). Si no creáramos la nueva clase Nombre sería necesario volver a crear estos métodos en cualquier otra entidad que necesite el nombre.

En la clases Java Profesor y Nombre 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 que la relación es desde Profesor hacia Nombre.

PlantUML Graph

Tablas

La tabla de base de datos quedaría de la siguiente forma:

PlantUML Graph

Podemos apreciar que en el diseño de las tabla de la base de datos no existe ninguna tabla Nombre aunque sí que existe la clase Java Nombre.

Fichero de mapeo ''.hbm.xml''

Al persistir las dos clases 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="ejemplo04.Profesor" >
 5:     <id column="Id" name="id" type="integer"/>
 6:
 7:     <component name="nombre">
 8:         <property name="nombre" />
 9:         <property name="ape1" />
10:         <property name="ape2" />
11:     </component>
12:
13:   </class>
14: </hibernate-mapping>

Fichero Profesor.hbm.xml

El fichero básicamente es muy sencillo excepto por el nuevo tag component de la línea 7.

Tag component

El tag <component> se utiliza para especificar que la propiedad Java de la clase se persistirá en la propia tabla de la clase principal. En su forma más sencilla contiene sólo un atributo:

  • name:Este atributo contiene el nombre de la propiedad Java con la referencia al otro objeto con el que forma la relación. En nuestro ejemplo es el atributo nombre.

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:     @Embedded
 9:     private Nombre nombre;
10:
11:
12:     public Profesor(){
13:     }
14:
15:     public Profesor(int id, Nombre nombre) {
16:         this.id = id;
17:         this.nombre=nombre;
18:     }
19: }

Clase Profesor anotada

En la línea 8 se ha incluido la anotación @Embedded.

  • @Embedded: Esta anotación se usa para indicar que la propiedad nombre se guardará en la misma tabla que Profesor.

La clase Java Nombre quedará de la siguiente forma:

 1: @Embeddable
 2: public class Nombre implements Serializable {
 3:
 4:     @Column(name="nombre")
 5:     private String nombre;
 6:
 7:     @Column(name="ape1")
 8:     private String ape1;
 9:
10:     @Column(name="ape2")
11:     private String ape2;
12:
13:     public Nombre() {
14:
15:     }
16:
17:     public Nombre(String nombre, String ape1, String ape2) {
18:         this.nombre = nombre;
19:         this.ape1 = ape1;
20:         this.ape2 = ape2;
21:     }
22:
23:
24:
25:     public String getNombreCompleto() {
26:         StringBuilder sb=new StringBuilder();
27:         if ((ape1!=null) && (ape1.trim().length()>0)) {
28:             sb.append(ape1);
29:         }
30:         if ((ape2!=null) && (ape2.trim().length()>0)) {
31:             if (sb.length()>0) {
32:                 sb.append(" ");
33:             }
34:             sb.append(ape2);
35:         }
36:         if ((nombre!=null) && (nombre.trim().length()>0)) {
37:             if (sb.length()>0) {
38:                 sb.append(",");
39:             }
40:             sb.append(nombre);
41:         }
42:
43:
44:         return sb.toString();
45:     }
46:
47:     public String getIniciales() {
48:         StringBuilder sb=new StringBuilder();
49:         if ((nombre!=null) && (nombre.trim().length()>0)) {
50:             sb.append(nombre.substring(0,1));
51:         }
52:         if ((ape1!=null) && (ape1.trim().length()>0)) {
53:             sb.append(ape1.substring(0,1));
54:         }
55:         if ((ape2!=null) && (ape2.trim().length()>0)) {
56:             sb.append(ape2.substring(0,1));
57:         }
58:
59:         return sb.toString().toUpperCase();
60:     }
61: }

Clase Nombre anotada

A nivel de clase se ha incluido en la línea 1 el atributo @Embeddable.

  • @Embeddable:Se usa para indicar que esta clase se usará como un componente y que se guardará en la misma tabla que la clase que la posee.

Código Java

Ahora que ya tenemos preparadas las clase Java para que puedan persistirse veamos el código necesario para persistirlas.

 1: Profesor profesor=new Profesor(410, new Nombre("Gabriel", "Sáez", "Izquierdo"));
 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 componentes no añade ningún tipo de complejidad al código Java que se usa.

Diferencias

Veamos ahora qué diferencias hay entre crear una relación uno a uno y el uso de componentes.

  • En una relación uno a uno las 2 clases Java se almacenan en tablas distintas mientras que en un componente lo hace en la misma tabla.
  • En una relación uno a uno las 2 clases Java deben incluir la referencia a la clave primaria que ambas comparten mientras que en un componente sólo necesita clave primaria la clase principal y no el componente.
  • En una relación uno a uno es posible persistir cualquiera de las 2 clases y se guardará la otra pero en un componente sólo se puede persistir la clase principal y no el componente.
unidades/04_claves_primarias_y_tipos_datos/03_componentes.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