Creación de Entidad con JPA: @Entity
Una Entidad es una clase java que nos sirve para mapear los campos de un determinado fichero de Base de Datos (BBDD). Cuando en nuestro proyecto necesitamos hacer uso de una Entidad, podemos crearla mediante la anotación JPA denominada @Entity. Dicha anotación está indicando que la clase marcada va a ser una Entidad que se corresponderá con algún fichero de BBDD. Hay que mencionar que la anotación @Entity se emplea tanto por los sistemas basados en Hibernate como en las aplicaciones que utilizan el framework de Spring Legacy o el de Spring Boot.
Dicho lo anterior, hay que comentar que el tratamiento de una Entidad realizado a partir de JPA se basa en la configuración de una serie de anotaciones que tendremos que ir incluyendo en nuestra clase. A partir de ellas, JPA construirá el objeto requerido y lo dejará mapeado contra el fichero de BBDD correspondiente. Antiguamente, la conexión con BBDD de las clases de nuestro modelo de datos debería realizarse mediante la especificación JDBC, lo que suponía un proceso mucho más complejo que el requerido mediante JPA.
Creación de Entidad con JPA: @Entity
Junto a la anotación principal, existen otra serie de anotaciones que deberán ser tenidas en cuenta para configurar correctamente nuestra Entidad. Todas estas anotaciones pertenecen a la librería JPA denominada javax.persistence.Vamos a revisarlas:
- @Entity: anotación para marcar la clase como Entidad.
- @Table: anotación en la que podremos indicar el nombre de la Tabla de BBDD que va a ser mapeada con la clase Entity. Si no se indica esta anotación, JPA por defecto interpreta que el nombre de la Tabla es el mismo que el nombre de la clase.
- @Id: sirve para marcar el atributo que se va a comportar como clave de la Entidad. Se deberá corresponder con la PK (Primary Key) de la Tabla de BBDD.
- @GeneratedValue: aquí se indica la estrategia de generación de los valores correspondientes a la clave de la Entidad. La estrategia deberá ser especificada entre paréntesis.
Las estrategias disponibles son las siguientes:
- IDENTITY
- AUTO
- SEQUENCE
- TABLE
Por ejemplo:
@GeneratedValue(strategy=GenerationType.IDENTITY)
En este ejemplo, con GenerationType.IDENTITY estamos especificando que el valor de la clave deberá ser gestionado y generado por la BBDD.
- @Column: sirve para especificar las características asociadas a un determinado atributo. Por ejemplo:
@Column(name="campo_tabla")
Esta anotación nos permitirá indicar que un atributo se corresponde con un campo determinado de la tabla de BBDD. El nombre de dicho campo deberá ser especificado entre paréntesis. Si no se indica ninguno, JPA asumirá que el nombre en BBDD es idéntico al nombre del atributo de la clase.
Las características modificables son las siguientes:
- columDefinition
- insertable
- length
- name
- nullable
- precision
- scale
- table
- unique
- updatable
- @ManyToOne: sirve para indicar que varias instancias de nuestra Entidad podrían estar relacionadas con una única instancia de otra Entidad.
Por ejemplo:
@ManyToOne
private Master master;
- @OneToMany: sirve para indicar que una instancia de nuestra Entidad podrá estar relacionada con varias instancias de otra Entidad.
Por ejemplo:
@OneToMany(mappedBy="master",cascade=CascadeType.ALL)
private List<Asignatura> asignaturas = new ArrayList<>();
Ejemplo de Entidad con JPA
A continuación, vamos a ver un ejemplo de cómo se debería construir una clase Entidad que cumpla con las especificaciones requeridas por JPA. Sería algo así como lo siguiente:
// **************************************************
package com.universo.annotated.modelo;
//Importar Anotaciones de JPA
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="valor")
public class Valor {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="id")
private Long id;
@Column(name="nombre")
private String nombre;
@Column(name="ticker")
private String ticker;
@Column(name="indice")
private String indice;
@Column(name="pais")
private String pais;
@Column(name="rentabilidad")
private Float rentabilidad;
public Valor() {
super();
}
public Valor(String nombre, String ticker, String indice, String pais,
Float rentabilidad) {
super();
this.nombre = nombre;
this.ticker = ticker;
this.indice = indice;
this.pais = pais;
this.rentabilidad = rentabilidad;
}
public Valor(String nombre, String ticker, String indice, String pais,
Float rentabilidad) {
super();
this.nombre = nombre;
this.ticker = ticker;
this.indice = indice;
this.pais = pais;
this.rentabilidad = rentabilidad;
}
public Valor(Long id, String nombre, String ticker, String indice, String pais,
Float rentabilidad) {
super();
this.id = id;
this.nombre = nombre;
this.ticker = ticker;
this.indice = indice;
this.pais = pais;
this.rentabilidad = rentabilidad;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getTicker() {
return ticker;
}
public void setTicker(String ticker) {
this.ticker = ticker;
}
public String getIndice() {
return indice;
}
public void setIndice(String indice) {
this.indice = indice;
}
public String getPais() {
return pais;
}
public void setPais(String pais) {
this.pais = pais;
}
public Float getRentabilidad() {
return rentabilidad;
}
public void setRentabilidad(Float rentabilidad) {
this.rentabilidad = rentabilidad;
}
@Override
public String toString() {
return "Valor [id=" + id + ", nombre=" + nombre + ", ticker=" + ticker +
", indice=" + indice + ", pais=" + pais +
", rentabilidad=" + rentabilidad + "]";
}
}
// **************************************************
👉 En la clase anterior podemos ver cómo habría que indicar, junto con @Entity, las anotaciones adicionales @Table, @Id, @GeneratedValue (con estrategia de generación IDENTITY) y @Column. Con este ejemplo, hemos construido una entidad "Valor" que estará mapeada contra la tabla de BBDD denominada "valor". Los atributos marcados con @Column se corresponderán con los campos de la BBDD. Como vemos, se trata de algo realmente sencillo de configurar y que nos va a ahorrar bastante trabajo frente a las estructuras antiguas que no hacían uso de JPA.
Pues nada, realmente eso es todo lo que había que contar en relación con la anotación @Entity. Con lo comentado en el post, ya nos debería quedar una idea más o menos clara de cómo habría que proceder a su implementación mediante las anotaciones correspondientes. La dudas, como siempre, podéis dejarlas aquí abajo.
Saludos.
Comentarios
Publicar un comentario