Noticias de nuevas tecnologías y artículos sobre Java, linux, internet, twitter, facebook, programación, Visual Basic, .Net, SQL, FoxPro y algo más.

Vamos a usar tres anotaciones diferentes: @OneToOne, @OneToMany y @ManyToOne.

Como ejemplo, pensemos en las entidades Organizacion, Proyecto y Estudiante y en las siguientes restricciones:

• Una organización tiene varios proyectos.
• Cada proyecto está asociado a una organización.
• Un proyecto tiene un estudiante.
• Cada estudiante es asignado a un proyecto.

Antes de comenzar, para más información sobre entidades puedes leer este artículo.

La entidad para nuestra organización la declaramos de la siguiente forma:

@Entity
public class Organizacion { 

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "organizacion_id")
    private int idOrganizacion;

    @Basic
    @Column(nullable = false, length = 100)
    private String nombre;

    @OneToMany(cascade = CascadeType.ALL, mappedBy = "organizacion")
    private ArrayList<Proyecto> proyectos;

    public Organizacion(String nombre) {
        this.nombre = nombre;
    }
    // Getters and Setters
}

La anotación @OneToMany indica que una organización puede contener varios proyectos. La propiedad cascade define con qué tipo de operaciones se realizarán operaciones en "cascada", es decir se propagarán a las entidades relacionadas, en nuestro caso a los proyectos. Esta propiedad puede tener los siguientes valores:

• CascadeType.PERSIST - Cuando persistamos la entidad todas las entidades que contenga esta variable serán persistidas también.
• CascadeType.REMOVE - Cuando borremos la entidad todas las entidades que contenga esta variable se borrarán del mismo modo.
• CascadeType.REFRESH - Cuando actualicemos la entidad todas las entidades que contenga esta variable se actualizarán.
• CascadeType.MERGE - Cuando hagamos un "merge" de la entidad todas las entidades que contenga esta variable realizarán la misma operación.
• CascadeType.ALL - Todas las operaciones citadas anteriormente.

Las siguientes anotaciones son equivalentes:

@OneToMany(cascade = {CascadeType.PERSIST, CascadeType.REMOVE,
    CascadeType.REFRESH, CascadeType.MERGE})
private ArrayList<Proyecto> proyectos;

y

@OneToMany(cascade = CascadeType.ALL)
private ArrayList<Proyecto> proyectos;

La propiedad mappedBy = "organizacion" indica el nombre de la entidad Organizacion en el objeto Proyecto.

La entidad para nuestro proyecto la declaramos de la siguiente forma:

@Entity
public class Proyecto { 

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "proyecto_id")
    private int idProyecto;

    @Basic
    @Column(nullable = false)
    private String nombre;

    @ManyToOne
    @JoinColumn(name="organization_id", nullable = false)
    private Organization organization;

    @OneToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    @JoinColumn(name="estudiante_id")
    private Estudiante estudiante;

    public Proyecto(String nombre) {
        this.nombre = nombre;
    }
        // Getters and Setters
}

Ahora usamos la anotación @ManyToOne para indicar la relación. La anotación @JoinColumn(name="organization_id", nullable = false) define el nombre de la columna en la tabla de la base de datos y que este no puede ser null.