Artículo

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 @ManyToOne siempre es ese lado; en @OneToMany bidireccional, el otro lado lleva mappedBy. Mantén los dos lados sincronizados con métodos de ayuda, usa fetch = LAZY en @ManyToOne y reserva cascade y orphanRemoval para 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

ReglaPor qué
La FK define el lado propietario; el otro lleva mappedBySi solo cambias el lado inverso, JPA no guarda nada
Métodos anadirX/quitarX que actualicen ambos ladosEvitan 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 @ManyToManyCon List, Hibernate borra y reinserta toda la tabla intermedia al quitar un elemento
cascade solo en composicióncascade = REMOVE en @ManyToMany puede borrar etiquetas compartidas con otros libros
No expongas entidades en la APILas 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.

jpa hibernate spring data jpa onetomany manytoone manytomany relaciones

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.

Compartir artículo