3.2 Relaciones de Asociación ManyToOne / OneToMany

<< Anterior - Volver Menu JPA - Siguiente >>

Bidireccional

Relación de Asociación OneToMany / ManyToOne:

Para realizar una relación OneToMany y ManyToOne en Taylor solo es seleccionar en la paleta que se encuentra en la parte derecha el tipo de asociación OneToMany, luego damos clic a la entidad Padre de la relación y con clic sostenido nos dirigimos a la entidad Hija de la relación y soltamos el clic. Como en el ejemplo de la Relación de Asociación OneToOne, le agregamos el Atributo mappedBy al atributo que esta anotado con el tipo de asociación pero en la entidad que representa el padre en la asociación. En la siguiente imagen se podremos observar como queda la relación en la perspectiva de Taylor.

perspectivaTaylor4.JPG

Como podemos ver en la imagen anterior en la Entidad Persona se agrega un atributo que se llama children y si observamos aun mejor es una lista o colección, por otro lado en la Entidad Vehículo obtenemos un atributo de nombre parent, lo cual nos quiere decir que hace referencia a la entidad padre de la relación, que en este caso seria a la Entidad Persona.

A continuación se mostrar las dos Entidades que representa la relación en código java:

Clase Entidad Persona.class:

@Entity
public class Persona implements Serializable, Cloneable{
    /** @generated */
    private static final long serialVersionUID = 1L;

    /** @generated */
    public Persona() {
    }

    *
    *
    *    Mas Código
    *
    *

    // La entidad Persona referencia una colección de la Entidad Vehiculo
    // La entidad Persona es la Dueña de la relacion.
    @OneToMany(fetch = FetchType.EAGER, mappedBy="parent", cascade =     CascadeType.ALL)
    public List<Vehiculo> getChildren() {
        if (this.children == null) {
            this.children = new ArrayList<Vehiculo>();
        }
        return children;
    }

    /** @generated */
    public void setChildren(final List<Vehiculo> children) {
        this.children = children;
    }

    /**
     * Este metodo añade un nuevo vehiculo a la Coleccion
     * @generated
     */
    public void addChildren(Vehiculo children) {
        if (children == null) {
            return;
        }
        getChildren().add(children);
        children.setParent(this);
    }

    /**
     * Este metodo remueve un vehiculo de la coleccion
     * @generated
     */
    public void removeChildren(Vehiculo children) {
        if (children == null) {
            return;
        }
        getChildren().remove(children);
        children.setParent(null);
    }

    /**
     * Este metodo borra todos los vehiculos de la Lista
     */
    public void removeAllChildren() {
        List<Vehiculo> remove = new ArrayList<Vehiculo>();
        remove.addAll(getChildren());
        for (Vehiculo element : remove) {
            removeChildren(element);
        }
    }

    /** @generated */
    private List<Vehiculo> children = null;

    *
    *
    *    Mas Código
    *
    *

}

Clase Entidad Vehiculo.class:

@Entity
public class Vehiculo implements Serializable, Cloneable{
    /** @generated */
    private static final long serialVersionUID = 1L;

    /** @generated */
    public Vehiculo() {
    }

    *
    *
    *    Mas Código
    *
    *
    // En la Entidad Vehiculo se referencia una instancia simple de la Entidad Persona.
    @ManyToOne(optional = true, fetch = FetchType.EAGER, cascade =     CascadeType.ALL)
    public Persona getParent() {
        return parent;
    }

    /** @generated */
    public void setParent(final Persona parent) {
        this.parent = parent;
    }

    /** @generated */
    private Persona parent = null;

    *
    *
    *    Mas Código
    *
    *

}

En las Siguientes imágenes veremos como queda mapeada las entidades en la Base de Datos.

mapeoBD7.JPG
mapeoBD8.JPG

Lo que podemos analizar en la imágenes anteriores es que en la Tabla VEHICULO se agregaron dos campos “PARENT_ID” y “PARENT_CEDULA”, lo que nos quiere decir es que esos dos campos hace referencia a la tabla PERSONA y por que dos campos, porque si nos fijamos bien la Tabla o Entidad Persona tiene una llave primaria compuesta.

Unidireccional

Relación de Asociación OneToMany:

Para realizar una relación unidireccional con la asociación OneToMany se sigue los mismos paso que se vieron en la relación unidireccional con asociación OneToOne, los cuales son:

  • Seleccionamos el Objeto de Asociación (Asociation) del navegador de ficheros o de objetos de eclipse.
  • Nos dirigimos a la parte inferior de la pantalla, donde se encuentran las porpiedades de dicho objeto.
  • Seleccionamos la pestaña Second End y deshabilitamos el checkBox con nombre IsNavigable.

Como veremos a continuación en la entidad Hija desaparecerá el atributo que hacia referencia a la Entidad padre junto con la anotación de asociación ManyToOne.

perspectivaTaylor5.JPG

En el siguiente fragmento podremos ver como queda plasmado esta relación unidireccional en código java:

Clase Entidad Persona.class:

public class Persona implements Serializable, Cloneable{
    /** @generated */
    private static final long serialVersionUID = 1L;

    /** @generated */
    public Persona() {
    }

    *
    *
    *    Mas Código
    *
    *

    // La entidad Persona referencia una colección de la Entidad Vehiculo
    // La entidad Persona es la Dueña de la relacion.
    @OneToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    public Set<Vehiculo> getChildren() {
        if (this.children == null) {
            this.children = new HashSet<Vehiculo>();
        }
        return children;
    }

    /** @generated */
    public void setChildren(final Set<Vehiculo> children) {
        this.children = children;
    }

    /**
     * Este metodo añade un nuevo vehiculo a la Coleccion
     * @generated
     */
    public void addChildren(Vehiculo children) {
        if (children == null) {
            return;
        }
        getChildren().add(children);
    }

    /**
     * Este metodo remueve un vehiculo de la coleccion
     * @generated
     */
    public void removeChildren(Vehiculo children) {
        if (children == null) {
            return;
        }
        getChildren().remove(children);
    }

    /**
     * Este metodo borra todos los vehiculos de la Lista
     */
    public void removeAllChildren() {
        List<Vehiculo> remove = new ArrayList<Vehiculo>();
        remove.addAll(getChildren());
        for (Vehiculo element : remove) {
            removeChildren(element);
        }
    }

    /** @generated */
    private Set<Vehiculo> children = null;

    *
    *
    *    Mas Código
    *
    *

}

Clase Entidad Vehiculo.class:

@Entity
public class Vehiculo implements Serializable, Cloneable{
    /** @generated */
    private static final long serialVersionUID = 1L;

    /** @generated */
    public Vehiculo() {
    }

    /*
     *  La Entidad Vehículo no tiene un atributo que haga referencia a la clase padre de la relacion.
     */

    // No tiene ninguna anotación de Relación de Asociación ManyToOne.

    *
    *
    *    Mas Código.
    *
    *

}

En las Siguientes imágenes veremos como queda mapeada las entidades en la Base de Datos:

mapeoBD9.JPG
mapeoBD10.JPG
mapeoBD11.JPG

Lo que podemos analizar en las imágenes anteriores es que al momento de mapearse las entidades en la Base de Datos se crea una Tabla detalle de nombre PERSONA_VEHICULO, donde los campos PERSONA_ID y PERSONA_CEDULA hacer referencia a la tabla PERSONA y el campo CHILDREN_PLACAVEHICULO hace referencia a la Tabla VEHICULO.

Relación de Asociación ManyToOne:

Para realizar una relación de asociación ManyToOne unidireccinal en Taylor, se siguen los siguientes pasos:

  • Se selecciona de la paleta que se encuentra en la parte derecha, el icono de asociación (Asociation) ManyToOne.
  • Se da clic en la entidad detalle o la dueña de la relación y con clic sostenido arrastra el mouse hasta la otra entidad de la relación y soltamos el clic.

Taylor por defecto este tipo de asociación no genera los atributos en las dos entidades solo genera el atributo en la entidad la cual es dueña de la relación. A continuación una imagen donde ilustra este tipo de relación en la perspectiva de Taylor.

perspectivaTaylor6.JPG

En el proximo framento se muestra como queda este tipo de relacion unidireccional en lenguaje java:

Clase Entidad Persona.class:

@Entity
public class Persona implements Serializable, Cloneable{
    /** @generated */
    private static final long serialVersionUID = 1L;

    /** @generated */
    public Persona() {
    }

    // La entidad no tiene un atributo que haga referencia a la Entidad del otro lado de la relacion.
    // No tiene ninguna anotación de Relación de Asociación ManyToOne.

    *
    *
    *    Mas Código.
    *
    *

}

Clase Entidad Vehiculo.class:

@Entity
public class Vehiculo implements Serializable, Cloneable{
    /** @generated */
    private static final long serialVersionUID = 1L;

    /** @generated */
    public Vehiculo() {
    }

    *
    *
    *    Mas Código.
    *
    *

    // La Entidad Vehiculo es la dueña de la relacion.
    // La Entidad Vehiculo hace una referencia simple de la Entidad Persona. 
    @ManyToOne(optional = true, fetch = FetchType.EAGER, cascade =     CascadeType.ALL)
    public Persona getTarget() {
        return target;
    }

    /** @generated */
    public void setTarget(final Persona target) {
        this.target = target;
    }

    /** @generated */
    private Persona target = null;

    *
    *
    *    Mas Código.
    *
    *

}

En las Siguientes imágenes veremos como queda mapeada las entidades en la Base de Datos:

mapeoBD12.JPG
mapeoBD13.JPG

En las dos imágenes anteriores se puede concluir que a momento de mapearse las entidades a la base de datos se generan dos campos “TARGET_ID” y “TARGET_CEDULA” en la tabla VEHICULO, los cuales hacen referencia a la tabla PERSONA.

<< Anterior - Volver Menu JPA - Siguiente >>

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License