Relaciones en JPA: @OneToMany, @ManyToOne, @ManyToMany y @OneToOne
Cómo mapear relaciones en JPA: @OneToMany, @ManyToOne, @ManyToMany y @OneToOne, lado propietario, mappedBy, cascade y orphanRemoval.
En resumen: en JPA cada relación tiene un lado propietario, el que tiene la clave foránea y decide qué se guarda: en
@ManyToOnesiempre es ese lado; en@OneToManybidireccional, el otro lado llevamappedBy. Mantén los dos lados sincronizados con métodos de ayuda, usafetch = LAZYen@ManyToOney reservacascadeyorphanRemovalpara relaciones de composición (un pedido y sus líneas). Probado con Spring Boot 4.1.2, Hibernate 7 y H2, con el SQL que generó Hibernate.
Vídeo explicativo
El modelo
Un Autor tiene un Perfil (1:1) y muchos Libro (1:N); cada Libro tiene varias Etiqueta y cada etiqueta varios libros (N:M).
@Entity
public class Autor {
@Id
@GeneratedValue
private Long id;
private String nombre;
// Lado inverso: mappedBy apunta al campo "autor" de Libro, que tiene la FK
@OneToMany(mappedBy = "autor", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Libro> libros = new ArrayList<>();
@OneToOne(cascade = CascadeType.ALL, orphanRemoval = true)
@JoinColumn(name = "perfil_id")
private Perfil perfil;
protected Autor() {}
public Autor(String nombre) {
this.nombre = nombre;
}
// Método de ayuda: mantiene sincronizados los dos lados de la relación
public void anadirLibro(Libro libro) {
libros.add(libro);
libro.setAutor(this);
}
public void quitarLibro(Libro libro) {
libros.remove(libro);
libro.setAutor(null);
}
// getters y setPerfil
}
@Entity
public class Libro {
@Id
@GeneratedValue
private Long id;
private String titulo;
private int paginas;
// Lado propietario: aquí vive la columna autor_id
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "autor_id")
private Autor autor;
@ManyToMany
@JoinTable(name = "libro_etiqueta",
joinColumns = @JoinColumn(name = "libro_id"),
inverseJoinColumns = @JoinColumn(name = "etiqueta_id"))
private Set<Etiqueta> etiquetas = new HashSet<>();
protected Libro() {}
public Libro(String titulo, int paginas) {
this.titulo = titulo;
this.paginas = paginas;
}
void setAutor(Autor autor) { this.autor = autor; }
// getters
}
@Entity
public class Etiqueta {
@Id
@GeneratedValue
private Long id;
private String nombre;
@ManyToMany(mappedBy = "etiquetas")
private Set<Libro> libros = new HashSet<>();
// constructores y getters
}
Perfil es una entidad sencilla con id y biografia.
Guardar y leer
interface AutorRepository extends JpaRepository<Autor, Long> {
@EntityGraph(attributePaths = "libros") // trae los libros en la misma consulta
Autor findByNombre(String nombre);
}
Etiqueta java = etiquetas.save(new Etiqueta("java"));
Etiqueta clasico = etiquetas.save(new Etiqueta("clásico"));
Autor bloch = new Autor("Joshua Bloch");
bloch.setPerfil(new Perfil("Autor de Effective Java"));
Libro effective = new Libro("Effective Java", 412);
effective.getEtiquetas().add(java);
effective.getEtiquetas().add(clasico);
bloch.anadirLibro(effective);
bloch.anadirLibro(new Libro("Java Puzzlers", 312));
autores.save(bloch); // cascade = ALL guarda perfil y libros
em.flush();
em.clear(); // vacía la caché de primer nivel: lo siguiente sale de la BD
Autor leido = autores.findByNombre("Joshua Bloch");
El SQL que generó Hibernate al leer, y lo que imprimimos:
select a1_0.id,l1_0.autor_id,l1_0.id,l1_0.paginas,l1_0.titulo,a1_0.nombre,a1_0.perfil_id
from autor a1_0 left join libro l1_0 on a1_0.id=l1_0.autor_id where a1_0.nombre=?
select p1_0.id,p1_0.biografia from perfil p1_0 where p1_0.id=?
Autor: Joshua Bloch | perfil: Autor de Effective Java
select ... from libro_etiqueta e1_0 join etiqueta e1_1 on e1_1.id=e1_0.etiqueta_id where e1_0.libro_id=?
Libro: Effective Java -> 2 etiquetas
select ... from libro_etiqueta e1_0 join etiqueta e1_1 on e1_1.id=e1_0.etiqueta_id where e1_0.libro_id=?
Libro: Java Puzzlers -> 0 etiquetas
Etiqueta java -> 1 libro(s)
Dos cosas se ven en ese SQL. El @EntityGraph trajo autor y libros con un solo left join. Y las etiquetas se cargaron con una consulta por libro: es el problema N+1. Con 100 libros serían 100 consultas; se resuelve ampliando el @EntityGraph o con join fetch. Tienes más en joins en JPA.
orphanRemoval
autor.quitarLibro(refactoring);
em.flush();
delete from libro where id=?
Libros tras quitar uno con orphanRemoval: 1
Con orphanRemoval = true, quitar un libro de la lista del autor borra la fila. Tiene sentido si un libro no puede existir sin su autor; si no, no lo actives.
Las reglas que evitan problemas
| Regla | Por qué |
|---|---|
La FK define el lado propietario; el otro lleva mappedBy | Si solo cambias el lado inverso, JPA no guarda nada |
Métodos anadirX/quitarX que actualicen ambos lados | Evitan objetos en memoria que no coinciden con la base de datos |
@ManyToOne(fetch = LAZY) | Por defecto es EAGER y carga en cascada objetos que no necesitas |
Set en @ManyToMany | Con List, Hibernate borra y reinserta toda la tabla intermedia al quitar un elemento |
cascade solo en composición | cascade = REMOVE en @ManyToMany puede borrar etiquetas compartidas con otros libros |
| No expongas entidades en la API | Las relaciones bidireccionales provocan JSON infinito y cargas perezosas fuera de transacción; usa DTOs |
| Si la tabla intermedia tiene datos propios (fecha, rol), conviértela en entidad | @ManyToMany no permite columnas extra |
Preguntas frecuentes
¿Unidireccional o bidireccional?
Empieza por unidireccional @ManyToOne (el libro conoce a su autor). Añade el @OneToMany inverso solo si de verdad navegas del autor a sus libros: cada lado extra es más código que mantener sincronizado.
¿Qué es LazyInitializationException?
Acceder a una relación LAZY cuando la sesión ya se cerró, típicamente en el controlador. Carga lo necesario dentro del servicio (con @EntityGraph o join fetch) y devuelve un DTO.
¿Por qué mis tablas se llaman raro?
Hibernate usa el nombre de la clase. Si las entidades son clases anidadas, aparecen nombres como modelo$libro; nos pasó en la primera versión de este ejemplo. Usa clases de primer nivel o @Table(name = "...").
¿Cómo pruebo esto contra PostgreSQL real?
Con Testcontainers: arranca un PostgreSQL en Docker durante el test.
Sigue aprendiendo
Las relaciones, el problema N+1, las proyecciones y el rendimiento de JPA son el núcleo del curso Spring Data JPA 4.1. Antes, repasa @Entity en JPA y JpaRepository.
Newsletter Semanal de Java
Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.
Sin spam. Cancela cuando quieras.