Skip to content
josejbocanegra edited this page May 28, 2019 · 5 revisions

En este video explicaré como crear dos entidades y cómo relacionarlas mediante una asociación uno a uno.

En este modelo conceptual existen dos clases: Ciudad (City) y Ciudadano (Citizen). En el modelo se indica que una ciudad solo puede tener un ciudadano que cumple el rol de alcalde (mayor), y que un ciudadano solo puede administrar (manage) una ciudad.

La ciudad tiene dos atributos (el id, de tipo long y el nombre de tipo cadena de caracteres), mientras que ciudadano tiene tres atributos (id, de tipo long, y nombre y dirección, ambos de tipo cadena de caracteres).

En el modelo de entidades existen dos asociaciones para representar la bidireccionalidad: una asociación entre City y Citizen denominada mayor, y una asociación entre Citizen y City llamada manage.

Como cada extremo tiene una cardinalidad 0..1, eso significa que la anotación del extremo en las dos asociaciones, debe ser OneToOne.

En este ejemplo se ha decidido que City sea la entidad dueña de la relación. Por eso, en la asociación que apunta a City (manage), se ha definido en la propiedad mappedBy el valor mayor.

Es muy importante que en este caso el método Fetch sea LAZY. Si no se establece esa propiedad, cuando se cargan los datos de la ciudad, también se cargarían los datos del ciudadano, y con los datos del ciudadano también se cargarían los datos de la ciudad, quedando así en un loop infinito de carga de datos.

A nivel de código, debemos ir a proyecto back, y en el paquete "entities" vamos a crear las entidades.

Iniciamos creando una clase denominada City. Anotamos esa nueva clase con @Entity

Ciudad extiende de BaseEntity. Esto es importante, porque BaseEntity tiene un atributo ID que se incrementa automáticamente cada vez que se agrega un nuevo registro a la base de datos, y este atributo será heredado por la clase Ciudad. También se debe indicar que la clase implementa la interfaz Serializabe. Esto se requiere dado que los datos del objeto deben poderse convertir en un arreglo de Bytes, para ser, por ejemplo, enviados a través de la red a un cliente.

Creamos el atributo name, de tipo string.

Luego incluimos la anotación OneToOne para el atributo mayor de tipo Citizen. Importamos los paquetes necesarios.

Como cuando se ejecuten las pruebas unitarias no queremos que se cree un ciudadano, incluimos la anotación @PodamExclude

Como la clase Citizen no está aun creada, vamos a crearla.

Igual que con la clase ciudad, debemos extender de base entity, implementar la interfaz serializable y anotarla como entidad

Se crean los atributos nombre y direccion, ambos de tipo string

Luego se incluye la anotación OneToOne para el atruto manage de tipo ciudad, y se incluyen los atributos mappedBy con valor mayor, y fectch con valor Lazy

Posteriormente se refactoriza el código para incluir los getters y setters de todos los atributos

Ahora, regresamos a la clase Ciudad, y vemos que ya no tenemos el error. Incluimos la anotación PodamExclude y refactorizamos para incluir getters y setters,

Limpiamos y construimos el proyecto principal y ejecutamos el proyecto api.

Si todo está correcto se deberá mostrar una nueva ventana en el navegador con el mensaje Hola mundo.

Finalmenete, vamos a la pestaña servicios de netbeans y en la base de datos, deben aparecer dos tablas (ciudad y ciudadano). Y como ciudad es la dueña de la relación, debe tener un atributo que representa la llave foránea de ciudadano.

Imgur

Este es el código en Java que representa a cada entidad:

@Entity
public class City extends BaseEntity implements Serializable
{
    private String name;
    
    @PodamExclude
    @OneToOne
    private Citizen mayor;

    //...
}
@Entity
public class Citizen extends BaseEntity implements Serializable
{
    private String name;
    
    private String address;

    @PodamExclude  
    @OneToOne(
        mappedBy = "mayor",
    	fetch = FetchType.LAZY
    )
    private City manage;

    //...
}

====================================================

En este video explicaré como crear dos entidades y cómo relacionarlas mediante una asociación compartida uno a muchos.

En este modelo conceptual existen dos clases: Ciudad (City) y Carro (Car). En el modelo conceptual se indica que en una ciudad se registran varios carros, pero que un carro solo se puede registrar en una ciudad.

Nótese que la relación de tipo shared implica que tanto ciudad como carro pueden existir independientemente. Es decir, se puede crear un carro sin asociarlo obligatoriamente a una ciudad; o se puede crear una ciudad sin asociarle ningún carro.

La ciudad tiene dos atributos (el id, de tipo long y el nombre de tipo cadena de caracteres), mientras que ciudadano tiene tres atributos (id, de tipo long, y nombre y dirección, ambos de tipo cadena de caracteres).

En el modelo de entidades existen dos asociaciones para representar la bidireccionalidad: una asociación entre City y Citizen denominada mayor, y una asociación entre Citizen y City llamada manage.

Como cada extremo tiene una cardinalidad 0..1, eso significa que la anotación del extremo en las dos asociaciones, debe ser OneToOne.

En este ejemplo se ha decidido que City sea la entidad dueña de la relación. Por eso, en la asociación que apunta a City (manage), se ha definido en la propiedad mappedBy el valor mayor.

Es muy importante que en este caso el método Fetch sea LAZY. Si no se establece esa propiedad, cuando se cargan los datos de la ciudad, también se cargarían los datos del ciudadano, y con los datos del ciudadano también se cargarían los datos de la ciudad, quedando así en un loop infinito de carga de datos.

A nivel de código, debemos ir a proyecto back, y en el paquete "entities" vamos a crear las entidades.

====================================================

En este video explicaré como crear dos entidades y cómo relacionarlas mediante una asociación compuesta uno a muchos.

Clone this wiki locally