Remove Entity with Many-to-Many Relationship in JPA

1. Overview

In this tutorial, we’ll learn how to remove entities from many-to-many relationships in JPA.

2. Many-to-Many Relationship

The many-to-many relationship is one where two entities are connected with an additional junction table. To map these entities efficiently, we should follow a few guidelines.

Firstly, when defining a many-to-many relationship, we should consider using a Set instead of a List. As a JPA implementation, Hibernate doesn’t remove entities from a List in an efficient way.

When using a List, Hibernate removes all entities from the junction table and inserts the remaining ones. This can cause performance issues. We can easily avoid this problem by using Set.

Secondly, we shouldn’t use the CascadeType.REMOVE and, therefore, CascadeType.ALL in our mappings.

In a many-to-many relationship, both entities are independent of each other. For instance, suppose we have two entities, Post and Category. When removing the record from the Post entity, we usually don’t want to remove associated Category entities. With CascadeType.REMOVE, JPA will remove all associated entities, even those that might still be connected to other entities.

To define a many-to-many relationship in JPA, we can use the @ManyToMany annotation.

The many-to-many association can be either unidirectional or bidirectional.

3. Removal from Unidirectional @ManyToMany

Now, let’s see how to remove entities from unidirectional many-to-many associations.

Firstly, let’s define the data models, Post and Category, that we’re going to use in the examples:

@Entity
@Table(name = "post")
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

    @Column(name = "title")
    private String title;

    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH})
    @JoinTable(name = "post_category",
      joinColumns = @JoinColumn(name = "post_id"),
      inverseJoinColumns = @JoinColumn(name = "category_id")
    )
    private Set<Category> categories = new HashSet<>();

    // getters and setters
}

@Entity
@Table(name = "category")
public class Category {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

    @Column(name = "name")
    private String name;

    // getters and setters
}

Here, we defined the relationship as unidirectional since it’s not required to use the association from the Category table. Furthermore, we declared the Post entity as the one responsible for managing the relationship.

Now, say we have two Post entities, both associated with the same Category:

Category category1 = new Category("JPA");
Category category2 = new Category("Persistence");

Post post1 = new Post("Many-to-Many Relationship");
post1.getCategories().add(category1);
post1.getCategories().add(category2);

Post post2 = new Post("Entity Manager");
post2.getCategories().add(category1);

entityManager.persist(post1);
entityManager.persist(post2);

Next, let’s remove the category from the first Post entity:

void givenEntities_whenRemove_thenRemoveAssociation() {
   Post post1 = entityManager.find(Post.class, 1L);
   Post post2 = entityManager.find(Post.class, 2L);
   Category category = entityManager.find(Category.class, 1L);

   post1.getCategories().remove(category);

   assertEquals(1, post1.getCategories().size());
   assertEquals(1, post2.getCategories().size());
}

As a result, the relation between the first Post and Category was removed. Additionally, JPA didn’t delete the associated category.

Since we’re using Set instead of List, JPA generates a single delete statement to remove the association from the junction table.

4. Removal from Bidirectional @ManyToMany

In bidirectional relationships, we can manage an association from both sides.

Firstly, let’s create a bidirectional association between Book and Author entities:

@Entity
@Table(name = "book")
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

    @Column(name = "title")
    private String title;

    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
    @JoinTable(name = "book_author",
      joinColumns = @JoinColumn(name = "book_id"),
      inverseJoinColumns = @JoinColumn(name = "author_id")
    )
    private Set<Author> authors = new HashSet<>();

    // getters and setters
}

@Entity
@Table(name = "author")
public class Author {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

    @Column(name = "name")
    private String name;

    @ManyToMany(mappedBy = "authors")
    private Set<Book> books = new HashSet<>();

    // getters and setters
}

JPA will create an additional junction table to store connections between two entities. This table acts as a child side of the association. Therefore, both the Author and Book entities represent the parent sides.

However, although parents might seem identical, they’re not. The ownership of the relation is determined by the mappedBy attribute. The entity that isn’t the owner will have the mappedBy attribute.

In our example, the Book entity is the owner. Hence, it’ll propagate the association changes to the junction table.

4.1. Removal from the Owner Entity

Let’s see how to remove entities from the owner side.

We’ll add the helper methods to the entity that acts like the owner of the association. In our case, it’s the Book entity:

public void removeAuthor(Author author){
   this.authors.remove(author);
   author.getBooks().remove(this);
}

When deleting the author, we can call the helper method to remove the association:

void givenEntities_whenRemoveFromOwner_thenRemoveAssociation() {
   Author author = (Author) entityManager
     .createQuery("SELECT author from Author author where author.name = ?1")
     .setParameter(1, "Ralph Johnson")
     .getSingleResult();

   Book book1 = entityManager.find(Book.class, 1L);
   Book book2 = entityManager.find(Book.class, 2L);

   book1.removeAuthor(author);
   entityManager.persist(book1);

   assertEquals(3, book1.getAuthors().size());
   assertEquals(1, book2.getAuthors().size());
}

4.2. Removal from Non-Owner Entity

When removing records from the entity that isn’t the owner of the relationship, we should take care of deleting the relation manually:

for (Book book : author1.getBooks()) {
   book.getAuthors().remove(author1);
}
entityManager.remove(author1);

Furthermore, let’s place the code inside the method and annotate it with the @PreRemove annotation:

@PreRemove
private void removeBookAssociations() {
   for (Book book: this.books) {
       book.getAuthors().remove(this);
   }
}

JPA will execute everything inside this method before removing an entity.

Lastly, let’s create a test to check if the functionality is working properly:

void givenEntities_whenRemoveFromNotOwner_thenRemoveAssociation() {
    Author author = (Author) entityManager
      .createQuery("SELECT author from Author author where author.name = ?1")
      .setParameter(1, "Ralph Johnson")
      .getSingleResult();
    Book book1 = entityManager.find(Book.class, 1L);
    Book book2 = entityManager.find(Book.class, 2L);

    entityManager.remove(author);

    assertEquals(3, book1.getAuthors().size());
    assertEquals(0, book2.getAuthors().size());
}

5. Conclusion

In this article, we learned how to remove entities from many-to-many relationships in JPA.