¡Esta es una revisión vieja del documento!


Tipos básicos

Al mapear una propiedad de una clase Java a una columna de base de datos podemos especificar el tipo. Ésto es posible ya que algunos tipos de Java pueden mapearse de distintas formas en la base de datos. Por ello Hibernate permite especificar un tipo más concreto para cada propiedad Java.

Tipos en Hibernate

La lista de los tipos más usados en Hibernate es la siguiente1):

Tipo Hibernate Tipo Java Tipo base de datos (MySQL)
integer int , java.lang.Integer INTEGER
long long, java.lang.Long BIGINT
short short , java.lang.Short SMALLINT
float float , java.lang.Float FLOAT
double double , java.lang.Double DOUBLE
character char , java.lang.Character CHAR
byte byte , java.lang.Byte TINYINT
boolean boolean , java.lang.Boolean TINYINT. Guarda el true como ”1” y el false como ”0
yes_no boolean , java.lang.Boolean CHAR(1). Guarda el true como ”Y” y el false como ”N
true_false boolean , java.lang.Boolean CHAR(1). Guarda el true como ”T” y el false como ”F
string java.lang.String VARCHAR
date java.util.Date DATE. Solo se guarda solo la información de la fecha (año, mes y día)
time java.util.Date TIME. Solo se guarda solo la información de la hora (horas, minutos y segundos)
timestamp java.util.Date DATETIME. Se guarda la información de la fecha y la hora (año, mes , día, horas, minutos y segundos)
text java.lang.String LONGTEXT
binary byte[] TINYBLOB
big_decimal java.math.BigDecimal DECIMAL
big_integer java.math.BigInteger DECIMAL

Como podemos ver , los tipos Java java.util.Date,java.lang.Boolean y java.lang.String pueden ser guardados en la base de datos en más de una forma.Pasemos ahora a ver cada una de dichas formas.

Fecha y hora

En java se suele cometer el error de pensar que la clase java.util.Date guarda únicamente los datos de año, mes y día. Desgraciadamente se guardan también los datos de horas, minutos y segundos.Así que ¿qué hacemos para guardar únicamente la fecha o únicamente la hora en la base de datos?.

La forma entonces de guardar únicamente la fecha o únicamente la hora o ambas cosas usando hibernate es especificar los tipos date , time o timestamp. Si no especificamos el tipo a Hibernate para un java.util.Date por defecto se usará el tipo timestamp con lo que se guardará la información de la fecha y la hora.

  • date : Con este tipo de Hibernate se almacenará un java.util.Date en la base de datos guardando únicamente la fecha (año, mes y día).
  • time : Con este tipo de Hibernate se almacenará un java.util.Date en la base de datos guardando únicamente la hora (horas, minutos y segundos).
  • timestamp : Con este tipo de Hibernate se almacenará un java.util.Date en la base de datos guardando la fecha y la hora (año, mes, día, horas, minutos y segundos). Este tipo no es necesario usarlo ya que es el tipo por defecto para las propiedades de tipo java.util.Date.

Actualmente en Java no hay forma estándar de guardar en un objeto únicamente la fecha (año, mes y día) o únicamente la hora (horas, minutos y segundos). Bueno, están las clases java.sql.Date y java.sql.Time pero esas clases se han creado para tratar directamente con JDBC y no es recomendable usarlas fuera del contexto del acceso a la base de datos mediante JDBC. Es decir, que las clases del paquete java.sql nunca se deberían usar en el código de nuestras clases de negocio o de entidad. En Java 8 se piensan definir nuevas clases relativas a la fecha y la hora, de forma que estén separadas la fecha y la hora. El trabajo está siendo desarrollado por el JCP en el JSR-310: Date and Time API.

Boolean

Hibernate permite 3 formas distintas de almacenar un booleano de Java en la base de datos. Para ello existen 3 tipos de datos en hibernate.

  • boolean: Es la forma estándar de guardar un booleano en la base de datos.
  • yes_no: El valor se guardará como un CHAR(1) con los valores de Y y N para true y false respectivamente.
  • true_false: El valor se guardará como un CHAR(1) con los valores de T y F para true y false respectivamente.

Texto

Hibernate permite 2 formas distintas de almacenar un java.lang.String de Java en la base de datos. Para ello existen 2 tipos de datos en hibernate.

  • string: Se guardará el java.lang.String como un VARCHAR en la base de datos.
  • text: Se guardará el java.lang.String como un CLOB o TEXT ,etc. en la base de datos.

Clases Java

Ahora que tenemos claro qué tipo de dato de Hibernate debemos usar para cada propiedad de Java, pasemos a explicar cómo se debe indicar dicho tipo de datos.

Para explicarlo usaremos el siguiente código Java.

 1: public class TiposBasicos implements Serializable  {
 2:     private int inte;
 3:     private long long1;
 4:     private short short1;
 5:     private float float1;
 6:     private double double1;
 7:     private char character1;
 8:     private byte byte1;
 9:     private boolean boolean1;
10:     private boolean yesno1;
11:     private boolean truefalse1;
12:     private String stri;
13:     private Date dateDate;
14:     private Date dateTime;
15:     private Date dateTimestamp;
16:     private String texto;
17:     private byte[] binario;
18:     private BigDecimal bigDecimal;
19:     private BigInteger bigInteger;
20:
21:     public TiposBasicos() {
22:
23:     }
24: }

Clase TiposBasicos

En la clase Java TiposBasicos no se han incluido los métodos get/set de cada propiedad para facilitar la lectura pero deben estar en la clase Java.

El siguiente diagrama UML muestra la clase TiposBasicos: PlantUML Graph

Para las propiedades Java que tienen más de una forma de guardarse en la base de datos vamos a indicar el tipo concreto de hibernate que se va a usar:

Propiedad Java Tipo Hibernate
dateDate date
dateTime time
dateDateTime timestamp
booleanSimple boolean
booleanYesno yes_no
booleanTruefalse true_false
stri string
stringClob text

Tablas

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

PlantUML Graph

Fichero de mapeo ''.hbm.xml''

Para persistir la clase es necesario el fichero de persistencia:

  • TiposBasicos.hbm.xml
 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="ejemplo01.TiposBasicos" >
 5:       <id name="inte" type="integer"  />
 6:       <property name="long1"  type="long" />
 7:       <property name="short1"  type="short" />
 8:       <property name="float1"  type="float" />
 9:       <property name="double1"  type="double" />
10:       <property name="character1"  type="character" />
11:       <property name="byte1"  type="byte" />
12:       <property name="boolean1"  type="boolean" />
13:       <property name="yesno1"  type="yes_no" />
14:       <property name="truefalse1"  type="true_false" />
15:       <property name="stri"  type="string" />
16:       <property name="dateDate"  type="date" />
17:       <property name="dateTime"  type="time" />
18:       <property name="dateTimestamp"  type="timestamp" />
19:       <property name="texto"  type="text" />
20:       <property name="binario"  type="binary" />
21:       <property name="bigDecimal"  type="big_decimal" />
22:       <property name="bigInteger"  type="big_integer" />
23:   </class>
24: </hibernate-mapping>

TiposBasicos.hbm.xml

Podemos ver cómo cada propiedad Java se almacenará en la base de datos según el tipo de Hibernate que le hemos definido.

El atributo type de cada tag <property> se usa para especificar el tipo hibernate de cada propiedad Java.El atributo name se usa para indicar el nombre de la propiedad Java.

Al definir que una propiedad Java es la clave primaria mediante el tag <id> también se usa el atributo type para indicar el tipo de Hibernate.

<id name="inte" type="integer"  />

No es necesario indicar el tipo de las propiedades Java que tienen una única correspondencia con los tipos de hibernate o si él ya elige la correcta por defecto. Es decir no hace falta indicar el tipo para las propiedaes int, float , etc. Sin embargo hibernate recomienda ponerlas ya que se mejora el rendimiento al arrancar la aplicación puesto que así Hibernate se evita tener que ir clase por clase para averiguar su tipo. El tiempo de arranque de una aplicación puede ser muy crítico en entornos como Google App Engine.

Anotaciones

Como ya hemos visto es posible prescindir del fichero .hbm.xml anotando el código directamente.

El código fuente de la clase TiposBasicos queda de la siguiente forma:

 1: @Entity
 2: @Table(name="TiposBasicos")
 3: public class TiposBasicos implements Serializable {
 4:
 5:     @Id
 6:     @Type(type="integer")
 7:     private int inte;
 8:     @Type(type="long")
 9:     private long long1;
10:     @Type(type="short")
11:     private short short1;
12:     @Type(type="float")
13:     private float float1;
14:     @Type(type="double")
15:     private double double1;
16:     @Type(type="character")
17:     private char character1;
18:     @Type(type="byte")
19:     private byte byte1;
20:     @Type(type="boolean")
21:     private boolean boolean1;
22:     @Type(type="yes_no")
23:     private boolean yesno1;
24:     @Type(type="true_false")
25:     private boolean truefalse1;
26:     @Type(type="string")
27:     private String stri;
28:     @Temporal(TemporalType.DATE)
29:     private Date dateDate;
30:     @Temporal(TemporalType.TIME)
31:     private Date dateTime;
32:     @Temporal(TemporalType.TIMESTAMP)
33:     private Date dateTimestamp;
34:     @Lob
35:     private String texto;
36:     @Type(type="binary")
37:     private byte[] binario;
38:     @Type(type="big_decimal")
39:     private BigDecimal bigDecimal;
40:     @Type(type="big_integer")
41:     private BigInteger bigInteger;
42:
43:
44:     public TiposBasicos() {
45:
46:     }
47: }

Vemos como sobre cada una de las propiedades Java añadimos las anotaciones para indicar su tipo. Indicar que se han usado notaciones estándar de JPA y propietarias de Hibernate.

Veamos ahora el significado de cada una de las anotaciones:

  • @Temporal(TemporalType.DATE) : Indica el tipo de datos de hibernate de date. Es una anotación estándar de JPA.
  • @Temporal(TemporalType.TIME) : Indica el tipo de datos de hibernate de time. Es una anotación estándar de JPA.
  • @Temporal(TemporalType.TIMESTAMP) : Indica el tipo de datos de hibernate de timestamp. Es una anotación estándar de JPA.
  • @Lob : Indica el tipo de datos de hibernate de text. Es una anotación estándar de JPA.
  • @Type : Esta anotación indica el tipo de datos de hibernate.Esta notación es específica de Hibernate
    • type: Este atributo contiene el tipo concreto de Hibernate. Sus posibles valores se han indicado en la tabla del principio de este tema.

Como podemos ver el estándar de JPA no soporta los tipos de hibernate yes_no y true_false, la cual cosa no debería extrañarnos ya que no es muy ortodoxa. Pero , ¿porqué no hay una anotación éstandar en JPA para los tipos integer, double, etc.? La respuesta es simple. Porque no es necesario ya que el estándar de JPA indica que se usará el propio tipo de la propiedad Java, así que no es necesario indicárselo. Es decir, si el tipo Java es float, ¿para qué crear una anotación para indicar que su tipo de Hibernate es float?.

Como en el caso de del fichero de mapeo .hbm.xml no es necesario indicar todos los tipos.

Código Java

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

 1: Date date=new Date();
 2: byte array[]={(byte)0x45,(byte)0xF5,(byte)0x3A,(byte)0x67,(byte)0xFF};
 3:
 4: TiposBasicos tiposBasicos1=new TiposBasicos();
 5: tiposBasicos1.setInte(1);
 6: tiposBasicos1.setLong1(12);
 7: tiposBasicos1.setShort1((short)13);
 8: tiposBasicos1.setFloat1(14.1F);
 9: tiposBasicos1.setDouble1(15.2);
10: tiposBasicos1.setCharacter1('W');
11: tiposBasicos1.setByte1((byte)16);
12: tiposBasicos1.setBoolean1(true);
13: tiposBasicos1.setYesno1(true);
14: tiposBasicos1.setTruefalse1(true);
15: tiposBasicos1.setStri("Hola mundo");
16: tiposBasicos1.setDateDate(date);
17: tiposBasicos1.setDateTime(date);
18: tiposBasicos1.setDateTimestamp(date);
19: tiposBasicos1.setTexto("texto muyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy largo");
20: tiposBasicos1.setBinario(array);
21: tiposBasicos1.setBigDecimal(new BigDecimal("0.3"));
22: tiposBasicos1.setBigInteger(new BigInteger("5345345324532"));
23:
24: TiposBasicos tiposBasicos2=new TiposBasicos();
25: tiposBasicos2.setInte(2);
26: tiposBasicos2.setLong1(12);
27: tiposBasicos2.setShort1((short)13);
28: tiposBasicos2.setFloat1(14.1F);
29: tiposBasicos2.setDouble1(15.2);
30: tiposBasicos2.setCharacter1('W');
31: tiposBasicos2.setByte1((byte)16);
32: tiposBasicos2.setBoolean1(false);   //<<--- Cambiado a false
33: tiposBasicos2.setYesno1(false);     //<<--- Cambiado a false
34: tiposBasicos2.setTruefalse1(false); //<<--- Cambiado a false
35: tiposBasicos2.setStri("Hola mundo");
36: tiposBasicos2.setDateDate(date);
37: tiposBasicos2.setDateTime(date);
38: tiposBasicos2.setDateTimestamp(date);
39: tiposBasicos2.setTexto("texto muyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy largo");
40: tiposBasicos2.setBinario(array);
41: tiposBasicos2.setBigDecimal(new BigDecimal("0.3"));
42: tiposBasicos2.setBigInteger(new BigInteger("5345345324532"));
43:
44: Session session = sessionFactory.openSession();
45: session.beginTransaction();
46:
47: session.save(tiposBasicos1);
48: session.save(tiposBasicos2);
49:
50: session.getTransaction().commit();
51: session.close();

En las líneas de 12 a 14 y 32 a 34 se guardan booleanos pero al tener distinto tipo de hibernate en la base de datos se guardará distinta información para cada uno de los 3 tipos. Por ello se guardan también 2 objetos TiposBasicos para ver las diferencias al guardar un true o un false.

En las líneas de 16 a 18 y 36 a 38 se guarda el mismo objeto date pero al tener distinto tipo de hibernate en la base de datos se guardará distinta información para cada uno de los 3 tipos.

Referencias

1) En el apartado de referencias podremos encontrar el listado completo de tipos de Hibernate.
unidades/04_claves_primarias_y_tipos_datos/01_tipos_basicos.1367047317.txt.gz · Última modificación: 2016/07/03 20:37 (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