1. Overview
Sometimes we deal with entities with complex models consisting of parent and child elements. In this scenario, it can be beneficial to save the parent entity, thereby automatically saving all its children entities.
In this tutorial, we’ll delve into various aspects that we might otherwise overlook in achieving this automatic saving. We’ll discuss both unidirectional and bidirectional relationships.
2. Missed Relationships Annotations
The first thing we might overlook is adding a relationships annotation. Let’s create a child entity:
@Entity
public class BidirectionalChild {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
//getters and setters
}
Now, let’s create a parent entity that contains a list of our BidirectionalChild entities:
@Entity
public class ParentWithoutSpecifiedRelationship {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private List<BidirectionalChild> bidirectionalChildren;
//getters and setters
}
As we can see, the bidirectionalChildren field has no annotation on it. Let’s try to set up an EntityManagerFactory with these entities:
@Test
void givenParentWithMissedAnnotation_whenCreateEntityManagerFactory_thenPersistenceExceptionExceptionThrown() {
PersistenceException exception = assertThrows(PersistenceException.class,
() -> createEntityManagerFactory("jpa-savechildobjects-parent-without-relationship"));
assertThat(exception)
.hasMessage("Could not determine recommended JdbcType for Java type 'com.baeldung.BidirectionalChild'");
}
We encounter an exception where JdbcType cannot be determined for our child entity. This exception will be similar for both unidirectional and bidirectional relationships and the root cause is a missed @OneToMany annotation in our parent entity.
3. No CascadeType Specified
Great! Let’s move forward and create the Parent entity using the @OneToMany annotation. This way, our parent-child relationship will be accessible within the persistence context.
3.1. Unidirectional Relationship With @JoinColumn
To set up a unidirectional relationship we’ll use the @JoinColumn annotation. Let’s create the Parent entity:
@Entity
public class Parent {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@OneToMany
@JoinColumn(name = "parent_id")
private List<UnidirectionalChild> joinColumnUnidirectionalChildren;
//getters and setters
}
Now, let’s create the UnidirectionalChild entity:
@Entity
public class UnidirectionalChild {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
}
Finally, let’s try to save the Parent entity that contains a few children:
@Test
void givenParentWithUnidirectionalRelationship_whenSaveParentWithChildren_thenNoChildrenPresentInDB() {
Parent parent = new Parent();
List<UnidirectionalChild> joinColumnUnidirectionalChildren = new ArrayList<>();
joinColumnUnidirectionalChildren.add(new UnidirectionalChild());
joinColumnUnidirectionalChildren.add(new UnidirectionalChild());
joinColumnUnidirectionalChildren.add(new UnidirectionalChild());
parent.setJoinColumnUnidirectionalChildren(joinColumnUnidirectionalChildren);
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
entityManager.persist(parent);
entityManager.flush();
transaction.commit();
entityManager.clear();
Parent foundParent = entityManager.find(Parent.class, parent.getId());
assertThat(foundParent.getChildren()).isEmpty();
}
We’ve constructed the Parent entity with three children, stored it in the database, and cleared the persistence context. But when we try to verify if this parent retrieved from the database contains all the expected children we can observe that the children list appears empty.
Let’s take a look at the SQL queries generated by JPA:
Hibernate:
insert
into
Parent
(id)
values
(?)
Hibernate:
update
UnidirectionalChild
set
parent_id=?
where
id=?
We can see modifying queries for both entities but INSERT queries are absent for a UnidirectionalChild entity.
3.2. Bidirectional Relationship
Let’s add the bidirectional relationship to our Parent entity:
@Entity
public class Parent {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@OneToMany(mappedBy = "parent")
private List<BidirectionalChild> bidirectionalChildren;
//getters and setters
}
Here’s the BidirectionalChild entity:
@Entity
public class BidirectionalChild {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@ManyToOne
private Parent parent;
}
The BidirectionalChild contains a reference to the Parent entity. Let’s try to save our complex object with a bidirectional relationship:
@Test
void givenParentWithBidirectionalRelationship_whenSaveParentWithChildren_thenNoChildrenPresentInDB() {
Parent parent = new Parent();
List<BidirectionalChild> bidirectionalChildren = new ArrayList<>();
bidirectionalChildren.add(new BidirectionalChild());
bidirectionalChildren.add(new BidirectionalChild());
bidirectionalChildren.add(new BidirectionalChild());
parent.setChildren(bidirectionalChildren);
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
entityManager.persist(parent);
entityManager.flush();
transaction.commit();
entityManager.clear();
Parent foundParent = entityManager.find(Parent.class, parent.getId());Â Â Â Â
assertThat(foundParent.getChildren()).isEmpty();
}
Like in the previous section, no children’s items are saved here either. In this case, we’ll see the next queries in the log:
Hibernate:
insert
into
Parent
(id)
values
(?)
The reason is that we didn’t specify the CascadeType for our relationships. It’s essential to include it if we expect the parent and children entities to be automatically saved.
4. Setting CascadeType
Now that we’ve pinpointed the problem, let’s address it by employing CascadeType for both unidirectional and bidirectional relationships.
4.1. Unidirectional Relationship With @JoinColumn
Let’s add CascadeType.PERSIST to our unidirectional relationship in the ParentWithCascadeType entity:
@Entity
public class ParentWithCascadeType {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@OneToMany(cascade = CascadeType.PERSIST)
@JoinColumn(name = "parent_id")
private List<UnidirectionalChild> joinColumnUnidirectionalChildren;
//getters and setters
}
UnidirectionalChild remains unchanged. Now, let’s try to save the ParentWithCascadeType entity along with a few UnidirectionalChild entities related to it:
@Test
void givenParentWithCascadeTypeAndUnidirectionalRelationship_whenSaveParentWithChildren_thenAllChildrenPresentInDB() {
ParentWithCascadeType parent = new ParentWithCascadeType();
List<UnidirectionalChild> joinColumnUnidirectionalChildren = new ArrayList<>();
joinColumnUnidirectionalChildren.add(new UnidirectionalChild());
joinColumnUnidirectionalChildren.add(new UnidirectionalChild());
joinColumnUnidirectionalChildren.add(new UnidirectionalChild());
parent.setJoinColumnUnidirectionalChildren(joinColumnUnidirectionalChildren);
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
entityManager.persist(parent);
entityManager.flush();
transaction.commit();
entityManager.clear();
ParentWithCascadeType foundParent = entityManager
.find(ParentWithCascadeType.class, parent.getId());
assertThat(foundParent.getJoinColumnUnidirectionalChildren())
.hasSize(3);
}
As in the previous sections, we’ve created the parent entity, added a few children to it, and saved it within a transaction. As we can see, all the children entities are present in the database response.
Now, let’s examine what the SQL query logs look like:
Hibernate:
insert
into
ParentWithCascadeType
(id)
values
(?)
Hibernate:
insert
into
UnidirectionalChild
(id)
values
(?)
Hibernate:
update
UnidirectionalChild
set
parent_id=?
where
id=?
As we can see, the INSERT query for UnidirectionalChild is present.
4.2. Bidirectional Relationship
For the bidirectional relationship, we’re going to repeat the changes from the previous section. Let’s start with the ParentWithCascadeType entity modification:
@Entity
public class ParentWithCascadeType {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@OneToMany(mappedBy = "parent", cascade = CascadeType.PERSIST)
private List<BidirectionalChildWithCascadeType> bidirectionalChildren;
}
Now, let’s try to save the ParentWithCascadeType entity along with a few BidirectionalChildWithCascadeType entities related to it:
@Test
void givenParentWithCascadeTypeAndBidirectionalRelationship_whenParentWithChildren_thenNoChildrenPresentInDB() {
ParentWithCascadeType parent = new ParentWithCascadeType();
List<BidirectionalChildWithCascadeType> bidirectionalChildren = new ArrayList<>();
bidirectionalChildren.add(new BidirectionalChildWithCascadeType());
bidirectionalChildren.add(new BidirectionalChildWithCascadeType());
bidirectionalChildren.add(new BidirectionalChildWithCascadeType());
parent.setChildren(bidirectionalChildren);
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
entityManager.persist(parent);
entityManager.flush();
transaction.commit();
entityManager.clear();
ParentWithCascadeType foundParent = entityManager
.find(ParentWithCascadeType.class, parent.getId());
assertThat(foundParent.getChildren()).isEmpty();
}
Great, we’ve applied the same changes as for UnidirectionalChild and anticipate similar behavior. But, for some reason, we encounter an empty children list. Let’s examine the SQL query logs first:
Hibernate:
insert
into
ParentWithCascadeType
(id)
values
(?)
Hibernate:
insert
into
BidirectionalChildWithCascadeType
(parent_id, id)
values
(?, ?)
In the logs, we can observe that all the expected queries are present. Upon debugging the issue, we notice that the INSERT query for BidirectionalChildWithCascadeType has a parent_id set to null. The reason for this issue is that, for the bidirectional relationship, we need to explicitly specify the reference to the parent entity. The common pattern to do it is to specify the method, in the parent entity that supports such logic:
@Entity
public class ParentWithCascadeType {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@OneToMany(mappedBy = "parent", cascade = CascadeType.PERSIST)
private List<BidirectionalChildWithCascadeType> bidirectionalChildren;
public void addChildren(List<BidirectionalChildWithCascadeType> bidirectionalChildren) {
this.bidirectionalChildren = bidirectionalChildren;
this.bidirectionalChildren.forEach(c -> c.setParent(this));
}
}
Within this method, we set the children list reference to our parent entity, and for each of these children, we set the reference to this parent.
Now, let’s attempt to save this parent using our new method to set its children:
@Test
void givenParentWithCascadeType_whenSaveParentWithChildrenWithReferenceToParent_thenAllChildrenPresentInDB() {
ParentWithCascadeType parent = new ParentWithCascadeType();
List<BidirectionalChildWithCascadeType> bidirectionalChildren = new ArrayList<>();
bidirectionalChildren.add(new BidirectionalChildWithCascadeType());
bidirectionalChildren.add(new BidirectionalChildWithCascadeType());
bidirectionalChildren.add(new BidirectionalChildWithCascadeType());
parent.addChildren(bidirectionalChildren);
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
entityManager.persist(parent);
entityManager.flush();
transaction.commit();
entityManager.clear();
ParentWithCascadeType foundParent = entityManager
.find(ParentWithCascadeType.class, parent.getId());
assertThat(foundParent.getChildren()).hasSize(3);
}
As we can see, the parent entity was successfully saved with all its children, and we retrieved all of them back from the database.
5. Conclusion
In this article, we explored the potential reasons why child entities may not be saved automatically with a parent entity when using JPA. These reasons can differ for unidirectional and bidirectional relationships.
We used CascadeType.PERSIST to facilitate this logic. We can also consider other cascade types if we need automatic updates or removals.
As usual, the full source code can be found over on GitHub.
