Hibernate Relationship Tutorial – @OneToMany and @ManyToOne (Part 1 to 7)

I’m happy, that finally we have a complete tutorial that addresses the challenges faced by many programmers. Entity relationships(@OneToMany and @ManyToOne). So everything about relationships in covered here. Use the links to quickly jump to any section you want.
We explain the concept, then we implement it.

 

Part 1 – Introduction

In this comprehensive tutorial, we’ll build an application made up of three entities: Location, User and Post.

How they relate is that: Location contains users and User has posts. This is illustrated in the figure below

Relationship Diagram
Relationship Diagram

 

Part 2 – Setting Up the Application

In this part, we would set up a Spring Boot Starter application. Follow the steps below:

Step 1: Create a Spring application (you should be able to do this by now). Add the starter web dependency. Also add the starter-jpa dependency.

Step 2: Create three classes corresponding to Post, User and Location. Put them in the models package

Step 3: Also create all the repositories in the repositories package

Step 4: Create the services in the Services package

Step 5: Finally, create the RestControllers in the controllers package

 

Part 3 – @ManyToOne Relationship

We would now configure Many-to-one relationship between the User and the Location entities. Similarly, we do the same between the Post and User entities.

Follow the steps below:

Step 1: Annotate the Location field of the User entity with @ManyToOne annotation.

Step 2: Annotate the User field of the Post entity with @ManyToOne annotation

When you use these annotation, the entity decides to handle the relationship. In the first case, the User entity does this by creating a column called location_id in the User table. Similarly, the Post entity does this by creating a column called user_id

 

Part 4 – Configure the H2 Database

H2 Database is an in-memory database that is normally used during development. Now we configure the H2 database following the steps below:

Step 1: Open the application.properties file. It is in the src/main/resources folder

Step 2: Add the following code in the application.properties file

 

spring.h2.console.enabled=true
spring.datasource.platform=h2
spring.datasource.url=jdbc:h2:mem:socialdb
spring.datasource.driverClassName=org.h2.Driver

 

Step 3: Run the the application and access the H2 Console

 

Part 5 – Database Initialization (data.sql)

We would write a script to insert some initial data into the database. Follow the steps below:

Step 1: Create a file inside the src/main/resources folder. Name it data.sql

Step 2: Open the file and add the following code

insert into Location(id, name) values(1, 'Budapest, Hungary');
insert into Location(id, name) values(2, 'Owerri, Nigeria');
insert into Location(id, name) values(3, 'Califonia, USA');

insert into User(id, firstname, lastname, email, location_id) values(1, 'Kindson', 'Munonye', 'kany@gmail.com', 1);
insert into User(id, firstname, lastname, email, location_id) values(2, 'Jeffrey', 'Yuba', 'yuba@gmail.com', 2);
insert into User(id, firstname, lastname, email, location_id) values(3, 'Solace', 'Okeke', 'solace@gmail.com', 3);

insert into Post(id, post_date, details, user_id) values(1, CURRENT_TIMESTAMP(), 'Very good post', 1);
insert into Post(id, post_date, details, user_id) values(2, CURRENT_TIMESTAMP(), 'A rainy day', 2);
insert into Post(id, post_date, details, user_id) values(3, CURRENT_TIMESTAMP(), 'nice tutorials', 3);

 

Step 3: Run the application. Access h2-console and verify that the data is inserted. The H2-Console window is shown below

H2 Console
H2 Console

 

Part 6 – @OneToMany Relationship

This relationship allows us to get list of child entities under a parent entity. For examples, we could get the list of posts for a user. Or we could get list of users in a location. Follow the steps below:

Step 1:  In the Location class, add a private field of List<User> type. (This means list of all users under that location)

Step 2:  Annotate this field with the @OneToMany annotation

Step 3:  In the User class, add a private field of List<Post> type. (This means list of all posts for that user)

Step 4: Annotate this field with the @OneToMany annotation

Step 5: Run the application and access the H2 Console

Now, you will notice in the H2 console that there are additional tables that have been created.

What happens here is this:

for the User-Location relationship, the Location entity decides to handle the relationship mapping by creating an additional table called LOCATION_USERS.

Again, for the Post-User relationship, the User entify decides the handle the relationship by creating an additional table called POST_USERS.

But remember that the relationship mapping has already been handled using by the @ManyToOne using the location_id and the user_id columns.

This duplicate mapping can be resolved using the mappedBy attibute

 

Part 7 – The mappedBy Attribute

The mappedBy is an attribute of the @OneToMany relationship. You use the mappedBy to tell the @OneToMany annotation that the relationship has already been handled using a foreign key in the corresponding entity. In this way, an additional table is not created.

To do this:

Step 1: In the @OneToMany annotation in the Location entity, add mappedBy=”location”

Step 2: In the @OneToMany annotation in the User entity, add mappedBy=”user”

Step 3: Launch the application, access H2-Console and check that there are no more duplicate tables;

Let’s now move on the the next section…

4 Comments on “Hibernate Relationship Tutorial – @OneToMany and @ManyToOne (Part 1 to 7)”

Leave a Reply

Your email address will not be published. Required fields are marked *