Many To One Unidirectional Mapping In Hibernate/JPA Annotation Example Using Spring Boot and Oracle

In this post, we will see Many To One Unidirectional Mapping In Hibernate/JPA Annotation Example Using Spring Boot and Oracle.

Let’s see some points related to Many To One Unidirectional Mapping In Hibernate/JPA Annotation example then we will see a complete example from scratch using Spring Boot and Oracle.

  • We have two entity Book.java and Story.java. Book and Story entity will have Many To One mapping.
  • For this example, we are assuming multiple books can have one(i.e same) story. The below example is a unidirectional relationship that means the multiple books can have one(i.e same story) but the book can’t have multiple stories.
  • We are going to use two annotations @ManyToOne and @JoinColumn for mapping.
  • We will not create a table manually, let’s hibernate do this job.

Note –  Default Fetch type in case of  below annotations.

@OneToOne – Default fetch type is EAGER.
@OneToMany – Default fetch type is LAZY.
@ManyToOne – Default fetch type is EAGER.
@ManyToMany – Default fetch type is LAZY.

We are going to use Spring Boot, maven, embedded tomcat, postman, Eclipse and oracle database. Here we will have some rest endpoint which will be used to save and retrieve data in the database. After running the below example we will be able to save the Book and Story entity which is in Many To One relationship.

Save URL – http://localhost:9091/book/savebook

Request data –

[

	{
		"bookName": "Book1"
	},
	{
		"bookName": "Book2"
	},
	{
		"bookName": "Book3"
	}

]

 

Response Data – 

[{
		"bookId": 1,
		"bookName": "Book1",
		"story": {
			"storyId": 2,
			"storyName": "my story"
		}
	},
	{
		"bookId": 3,
		"bookName": "Book2",
		"story": {
			"storyId": 2,
			"storyName": "my story"
		}
	},
	{
		"bookId": 4,
		"bookName": "Book3",
		"story": {
			"storyId": 2,
			"storyName": "my story"
		}
	}
]

 

Many To One Unidirectional In Hibernate/JPA Spring Boot
Database details –
Many To One Unidirectional In Hibernate/JPA Spring Boot

Let’s see Many To One Unidirectional Mapping In Hibernate/JPA Annotation Example Using Spring Boot and Oracle from scratch.

Open eclipse and create maven project, Don’t forget to check ‘Create a simple project (skip)’click on next. Fill all details(GroupId – manytoonehibernatejpa, ArtifactId – manytoonehibernatejpa and name – manytoonehibernatejpa) and click on finish. Keep packaging as the jar.
Open pom.xml and replace it with the below code.
<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>manytoonehibernatejpa</groupId>
	<artifactId>manytoonehibernatejpa</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>manytoonehibernatejpa</name>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.2.RELEASE</version>
	</parent>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>

		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>

		<dependency>
			<groupId>com.oracle</groupId>
			<artifactId>ojdbc6</artifactId>
			<version>11.2.0.3</version>
		</dependency>

	</dependencies>

	<build>
		<finalName>${project.artifactId}</finalName>
		<plugins>

			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<fork>true</fork>
					<executable>C:\Program Files\Java\jdk1.8.0_131\bin\javac.exe</executable>
				</configuration>
			</plugin>


		</plugins>
	</build>
</project>

Note – In pom.xml we have defined javac.exe path in configuration tag. You need to change accordingly i.e where you have installed JDK.

If you see any error for oracle dependency then follow these steps. Let maven download all necessary jar. Once it is done we will able to see the maven dependency folder which contains different jar files.
We can start writing our controller classes, ServiceImpl and Repository. The directory structure of the application looks as below.


Many To One Unidirectional In Hibernate/JPA Spring Boot
Define entity class i.e Book.java and Story.java.
Book.java
package com.hibernatejpa.entity;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;

@Entity
public class Book {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private int bookId;

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

	@ManyToOne(cascade = CascadeType.ALL)
	@JoinColumn(name = "story_id",referencedColumnName="storyId")
	private Story story;

	public int getBookId() {
		return bookId;
	}

	public void setBookId(int bookId) {
		this.bookId = bookId;
	}

	public String getBookName() {
		return bookName;
	}

	public void setBookName(String bookName) {
		this.bookName = bookName;
	}

	public Story getStory() {
		return story;
	}

	public void setStory(Story story) {
		this.story = story;
	}


	
	

}

Story.java

package com.hibernatejpa.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Story {

	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private int storyId;

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

	public int getStoryId() {
		return storyId;
	}

	public void setStoryId(int storyId) {
		this.storyId = storyId;
	}

	public String getStoryName() {
		return storyName;
	}

	public void setStoryName(String storyName) {
		this.storyName = storyName;
	}

}

Define the repository interface extending CrudRepository.


BookRepository.java

package com.hibernatejpa.repository;

import java.io.Serializable;

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import com.hibernatejpa.entity.Book;
@Repository
public interface BookRepository extends CrudRepository<Book,Serializable> {
	public Book findByBookId(int bookId);
}

Define the Service interface.

BookService.java

package com.hibernatejpa.service;

import java.util.List;

import org.springframework.stereotype.Component;

import com.hibernatejpa.entity.Book;

@Component
public interface BookService {
	public List<Book> saveBook(List<Book> book);
	public Book findByBookId(int bookId);
}

Define service implementation class.

BookServiceImpl.java

package com.hibernatejpa.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.hibernatejpa.entity.Book;
import com.hibernatejpa.entity.Story;
import com.hibernatejpa.repository.BookRepository;
import com.hibernatejpa.service.BookService;

@Service("bookServiceImpl")
public class BookServiceImpl implements BookService {

	@Autowired
	private BookRepository bookRepository;

	public List<Book> saveBook(List<Book> bookList) {

		List<Book> response = (List<Book>) bookRepository.saveAll(bookList);
		return response;

	}

	public Book findByBookId(int bookId) {
		Book book = bookRepository.findByBookId(bookId);
		return book;
	}
}

Note – See here more about @Component, @Controller, @Service and @Repository annotations here.

Define the controller class or endpoint

BookController.java

package com.hibernatejpa.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.hibernatejpa.entity.Book;
import com.hibernatejpa.entity.Story;
import com.hibernatejpa.service.BookService;

@RestController
@RequestMapping(value = "/book")
public class BookController {

	@Autowired
	private BookService bookService;

	@RequestMapping(value = "/savebook", method = RequestMethod.POST)
	@ResponseBody
	public List<Book> saveBook(@RequestBody List<Book> bookList) {

		Story story = new Story();
		story.setStoryName("my story");
		for (Book book : bookList) {
			book.setStory(story);
		}

		List<Book> bookResponse = bookService.saveBook(bookList);
		return bookResponse;
	}

	@RequestMapping(value = "/{bookId}", method = RequestMethod.GET)
	@ResponseBody
	public Book getBookDetails(@PathVariable int bookId) {
		Book bookResponse = bookService.findByBookId(bookId);

		return bookResponse;
	}

}

JpaConfig.java

package com.hibernatejpa.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@Configuration
@EnableJpaRepositories(basePackages = "com.hibernatejpa.repository")
public class JpaConfig {

}

Define the SpringMain.java


package com.hibernatejpa.main;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan(basePackages="com.hibernatejpa.*")
@EntityScan("com.hibernatejpa.*")
public class SpringMain {
	public static void main(String[] args) {

        SpringApplication.run(SpringMain.class, args);
    }

}

And finally, we have an application.properties file where we have database details.

# Connection url for the database
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:XE
spring.datasource.username=SYSTEM
spring.datasource.password=oracle2
spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
# Show or not log for each sql query
spring.jpa.show-sql = true
 
 
spring.jpa.hibernate.ddl-auto =create
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.Oracle10gDialect
 
server.port = 9091

Let’s deploy the application running SpringMain class as a java application.

Let’s tets the save URI – http://localhost:9091/book/savebook

Request Data.

[
{
"bookName":"Book1"
},
{
"bookName":"Book2"
},
{
"bookName":"Book3"
}
]

Many To One Unidirectional In Hibernate/JPA Spring Boot

 

Let’s see in the below diagram which will give us a brief about flow.

Many To One Unidirectional In Hibernate/JPA Spring Boot

That’s all about Many To One Unidirectional Mapping In Hibernate/JPA Annotation Example Using Spring Boot and Oracle.

One to One Mapping Annotation Example in Hibernate/JPA using Spring Boot and Oracle.
One to One Bidirectional Mapping Example In Hibernate/JPA Using Spring Boot and Oracle.
One To Many Mapping Annotation Example In Hibernate/JPA Using Spring Boot And Oracle.
One To Many Bidirectional Mapping In Hibernate/JPA Annotation Example Using Spring Boot and Oracle
Many To Many Mapping Annotation Example In Hibernate/JPA Using Spring Boot And Oracle.
Hibernate Table Per Concrete Class Spring Boot
Hibernate Table Per Subclass Inheritance Spring Boot
Hibernate Single Table Inheritance using Spring Boot
@ManyToOne Docs.

Summary – We have seen Many To One Unidirectional Mapping In Hibernate/JPA Annotation Example Using Spring Boot and Oracle.