Hibernate with Kotlin

Hibernate is an ORM framework that seamlessly provides database connections through object mapping. It supports most of the modern relational databases and is considered a more sophisticated way compared to JDBC. When using along with Spring, it is best recommended to use Spring JPA's annotations instead of Hibernate's own. Spring JPA provides an abstraction that is further implemented by Hibernate. So basically you are using hibernate underneath JPA.

A quick overview of Hibernate key terminologies before moving forward:

• SessionFactory: It is a heavy-weight object, only created once in application, reads the hibernate config file, creates session objects.
• Session: Session is a wrapper around JDBC connection, main object to save/get objects, short-lived, use multiple sessions for operations, get session from sessionFactory.
• Transaction: A Transaction represents a unit of work with the database and most of the RDBMS supports transaction functionality.
• Query: Query objects use SQL or Hibernate Query Language (HQL) to retrieve data from the database and create objects.
• Criteria: Criteria objects are used to create and execute object-oriented criteria queries to retrieve objects.

So how does the Hibernate development process really work? There are 3 simple steps to get started:

1. Pre-Dev Config for database and Kotlin project
2. Annotating Kotlin class (or good old XML configs)
3. Writing code to perform database operations

Let's take a look at step 1 and what all we need to prepare before writing the actual code. 

I. Pre-Dev Config:

• PostgreSQL table config: The first obvious step is to create tables, identify primary and foreign keys. I am using Postgres relational database and have already created instructor, instructor_detail, student, course, review, course_student tables.

• Using the right JPA generation type strategy to manage primary keys: As a developer, nobody likes to manage primary keys. We just wish them to auto-populate every time we insert a new row. I am just going to use GenerationType.SEQUENCE strategy for all the entities which will use the default hibernate_sequence and share it across all the tables. We can always create separate sequences for each table and make hibernate use them.
• Additional config for Kotlin - By default, the Kotlin data classes don’t have no parameter constructors. We can either write them or we can use a noarg plugin to generate them. (Refer: https://www.baeldung.com/kotlin-jpa)
• Add a hibernate config file. Below is an example of my XML config file.

	<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
	<hibernate-configuration>
	<session-factory>
	<!-- JDBC Database connection settings -->
	<property name="connection.driver_class">org.postgresql.Driver</property>
	<property name="connection.url">jdbc:postgresql://localhost/postgres</property>
	<property name="connection.username">postgres</property>
	<property name="connection.password">admin</property>
	<!-- JDBC connection pool settings ... using built-in test pool -->
	<property name="connection.pool_size">1</property>
	<!-- Select our SQL dialect -->
	<property name="dialect">org.hibernate.dialect.PostgreSQL95Dialect</property>
	<!-- create / create-drop / update -->
	<property name="hbm2ddl.auto">update</property>
	<!-- Echo the SQL to stdout -->
	<property name="show_sql">true</property>
	<!-- Show SQL formatted -->
	<property name="format_sql">true</property>
	<!-- Set the current session context -->
	<property name="current_session_context_class">thread</property>
	</session-factory>
	</hibernate-configuration>

view raw hibernate.cfg.xml hosted with ❤ by GitHub

After all that DB and config setup, we are now ready to build a standalone hibernate project to make some CRUD operations. Step 2 and 3 are explained using multiple demo examples.

II. and III. Annotating Kotlin class & writing code to perform DB operations:

Basic CRUD Operations: Basic CRUD operations include create, read, update, and deleting data. I have created a Student class which has firstName, lastName, and email properties. The class is annotated with @Entity and @Table (table name from the Database) and its properties are annotated with @Column (column name from the database). It also has the id property mapped to the primary key column of the same name from the Database table. Following are a few examples of CRUD operations with Hibernate.

	package com.springhibernate.entity
	import javax.persistence.*
	@Entity
	@Table(name = "student")
	data class Student(@Column(name = "first_name") var firstName : String?,
	@Column(name = "last_name") val lastName : String?,
	@Column(name = "email") val email : String?) {
	@Id
	@Column(name = "id")
	@GeneratedValue(strategy=GenerationType.SEQUENCE)
	val id : Long? = null
	}

view raw Student.kt hosted with ❤ by GitHub

	import com.springhibernate.entity.Student
	import org.hibernate.cfg.Configuration
	fun main() {
	// create session factory
	val sessionFactory = Configuration()
	.configure("hibernate.cfg.xml")
	.addAnnotatedClass(Student::class.java)
	.buildSessionFactory()
	// create session
	var session = sessionFactory.currentSession
	try{
	// ------------------ Create --------------------
	// create the Student object
	println("Creating new student object...")
	val student = Student (firstName = "Daniel", lastName = "LaRusso", email = "danl@larusso.com")
	// start a transaction
	session.beginTransaction()
	// saving the Student object
	println("Saving the student...")
	session.save(student)
	// commit transaction
	session.transaction.commit()
	println("Saved! Generated Id : ${student.id}")
	// ------------------ Read --------------------
	// get new session and start transaction
	session = sessionFactory.currentSession
	session.beginTransaction()
	// retrieve student
	val newStudent = session.find(Student::class.java, student.id)
	println("Retrieving the student: $newStudent")
	// commit transaction
	session.transaction.commit()
	println("Done!")
	// ------------------ Read with HQL --------------------
	// get new session and start transaction
	session = sessionFactory.currentSession
	session.beginTransaction()
	// query student
	val studentList = session.createQuery("from Student s where s.id > 5").resultList
	println("Retrieving the student list: $studentList")
	// commit transaction
	session.transaction.commit()
	println("Done!")
	// ------------------ Update --------------------
	session = sessionFactory.currentSession
	session.beginTransaction()
	// get student
	val updateStudent = session.get(Student::class.java, 6L)
	// update student
	updateStudent.firstName = "Matthew"
	// update student with query
	session.createQuery("update Student s set s.email = 'matthew@abcd.com' where s.id = 6").executeUpdate()
	// commit transaction
	session.transaction.commit()
	println("Done!")
	// ------------------ Delete --------------------
	session = sessionFactory.currentSession
	session.beginTransaction()
	// delete student
	println("Deleting Student..")
	session.createQuery("delete from Student s where s.id = 11").executeUpdate()
	// commit transaction
	session.transaction.commit()
	println("Done!")
	} finally {
	sessionFactory.close()
	}
	}

view raw CRUDDemo.kt hosted with ❤ by GitHub

Advanced Mappings

One to One mapping: The Instructor class has one to one mapping with InstructorDetail. One Instructor can have only one InstructorDetail associated and vice a versa. Furthermore, the relationship between both of them can be unidirectional or bidirectional depending on the use case. If there's a unidirectional relationship defined in Instructor class, then we can fetch InstructorDetail from it but the vice versa is not possible. On the other hand, the bidirectional relationship makes it possible to fetch Instructor from InstructorDetail and vice a versa.

I would also like to mention the concept of cascading here. There are various cascading types available such as Persist, Remove, Refresh, Detach, Merge, and All. By looking at the options we can deduce that if any of these actions are performed on the calling object, the related object will undergo the same operation. For eg. we are defining CascadeType.ALL for InstructorDetail relationship defined on Instructor class. Let's say if we delete the Instructor, the InstructorDetail will also get deleted. In contrast, we are specifically leaving out CascateType.REMOVE for Instructor defined on InstructorDetail. That means if we delete InstructorDetail, Instructor will NOT get deleted. Note that by default no operations are cascaded.

	package com.springhibernate.entity
	import javax.persistence.*
	@Entity
	@Table(name = "instructor")
	data class Instructor(@Column(name = "first_name") var firstName : String?,
	@Column(name = "last_name") val lastName : String?,
	@Column(name = "email") val email : String?) {
	@Id
	@Column(name = "id")
	@GeneratedValue(strategy= GenerationType.SEQUENCE)
	val id : Long? = null
	@OneToOne(cascade = [CascadeType.ALL])
	@JoinColumn(name = "instructor_detail_id")
	var instructorDetail : InstructorDetail? = null
	}

view raw Instructor.kt hosted with ❤ by GitHub

	package com.springhibernate.entity
	import javax.persistence.*
	@Entity
	@Table(name = "instructor_detail")
	data class InstructorDetail(@Column(name = "youtube_channel") var youtubeChannel : String?,
	@Column(name = "hobby") val hobby : String?) {
	@Id
	@Column(name = "id")
	@GeneratedValue(strategy= GenerationType.SEQUENCE)
	val id : Long? = null
	// not included CascadeType.REMOVE - deleting instructor detail won't delete instructor
	@OneToOne(mappedBy = "instructorDetail", cascade = [CascadeType.DETACH,
	CascadeType.MERGE,
	CascadeType.PERSIST,
	CascadeType.REFRESH])
	val instructor : Instructor? = null
	}

view raw InstructorDetail.kt hosted with ❤ by GitHub

	package com.springhibernate.demo
	import com.springhibernate.entity.*
	import org.hibernate.cfg.Configuration
	import java.lang.Exception
	fun main() {
	// create session factory
	val sessionFactory = Configuration()
	.configure("hibernate.cfg.xml")
	.addAnnotatedClass(Instructor::class.java)
	.addAnnotatedClass(InstructorDetail::class.java)
	.buildSessionFactory()
	// create session
	var session = sessionFactory.currentSession
	try{
	// ------------ One to One uni-directional example ------------
	val instructor = Instructor("Johnny", "Lawrence", "jlawrence@ck.com")
	val instructorDetail = InstructorDetail("www.youtube.com/cobrakai", "karate")
	instructor.instructorDetail = instructorDetail
	session.beginTransaction()
	session.save(instructor)
	session.transaction.commit()
	// ------------ One to One Bi-directional example ------------
	session = sessionFactory.currentSession
	session.beginTransaction()
	val instructorDetailGet = session.get(InstructorDetail::class.java, 44L)
	println(instructorDetailGet)
	println(instructorDetailGet.instructor)
	session.transaction.commit()
	// ------------ One to One Bi-directional Delete example ------------
	session = sessionFactory.currentSession
	session.beginTransaction()
	val instructorDetailDel = session.get(InstructorDetail::class.java, 44L)
	println(instructorDetailDel)
	println(instructorDetailDel.instructor)
	println("deleting..")
	//important - breaking bi-directional link
	instructorDetailDel.instructor?.instructorDetail = null
	// delete InstructorDetail without deleting Instructor
	session.delete(instructorDetailDel)
	session.transaction.commit()
	println("Done!")
	} catch (exception : Exception) {
	exception.printStackTrace()
	} finally {
	session.close()
	sessionFactory.close()
	}
	}

view raw OneToOneDemo.kt hosted with ❤ by GitHub

One to Many mapping: The idea is one instructor can teach many courses. To make it work both ways, I have added a bidirectional relationship between Instructor and Course.

	package com.springhibernate.entity
	import javax.persistence.*
	@Entity
	@Table(name = "instructor")
	data class Instructor(@Column(name = "first_name") var firstName : String?,
	@Column(name = "last_name") val lastName : String?,
	@Column(name = "email") val email : String?) {
	@Id
	@Column(name = "id")
	@GeneratedValue(strategy= GenerationType.SEQUENCE)
	val id : Long? = null
	@OneToOne(cascade = [CascadeType.ALL])
	@JoinColumn(name = "instructor_detail_id")
	var instructorDetail : InstructorDetail? = null
	@OneToMany(fetch = FetchType.LAZY, mappedBy = "instructor", cascade = [CascadeType.DETACH,
	CascadeType.MERGE,
	CascadeType.PERSIST,
	CascadeType.REFRESH])
	var courses : MutableList<Course>? = null
	fun addCourse(tempCourse : Course) {
	if(courses == null){
	courses = mutableListOf()
	}
	courses?.add(tempCourse)
	tempCourse.instructor = this
	}
	}

view raw InstructorCourse.kt hosted with ❤ by GitHub

	package com.springhibernate.entity
	import javax.persistence.*
	@Entity
	@Table(name = "course")
	data class Course(@Column(name = "title") var title : String?) {
	@Id
	@Column(name = "id")
	@GeneratedValue(strategy= GenerationType.SEQUENCE)
	val id : Long? = null
	@ManyToOne(cascade = [CascadeType.REFRESH,
	CascadeType.PERSIST,
	CascadeType.MERGE,
	CascadeType.DETACH])
	@JoinColumn(name = "instructor_id")
	var instructor : Instructor? = null
	@OneToMany(fetch = FetchType.LAZY, cascade = [CascadeType.ALL])
	@JoinColumn(name = "course_id")
	var reviews : MutableList<Review>? = null
	fun addReview(review : Review) {
	if(reviews == null)
	reviews = mutableListOf()
	reviews?.add(review)
	}
	}

view raw Course.kt hosted with ❤ by GitHub

	package com.springhibernate.demo
	import com.springhibernate.entity.*
	import org.hibernate.cfg.Configuration
	import java.lang.Exception
	fun main() {
	// create session factory
	val sessionFactory = Configuration()
	.configure("hibernate.cfg.xml")
	.addAnnotatedClass(Instructor::class.java)
	.addAnnotatedClass(InstructorDetail::class.java)
	.addAnnotatedClass(Course::class.java)
	.buildSessionFactory()
	// create session
	val session = sessionFactory.currentSession
	try{
	session.beginTransaction()
	val instructor = session.get(Instructor::class.java, 43L)
	val course1 = Course("Cobra Kai Dojo")
	val course2 = Course("Biker Gang 101")
	instructor.addCourse(course1)
	instructor.addCourse(course2)
	session.save(course1)
	session.save(course2)
	session.transaction.commit()
	} catch (exception : Exception) {
	exception.printStackTrace()
	} finally {
	session.close()
	sessionFactory.close()
	}
	}

view raw OneToManyDemo.kt hosted with ❤ by GitHub

I have also created a Review class that follows the principle of one course having many reviews. Here's the thing, do we really want the Course-Review relationship a bidirectional? Logically speaking, we probably don't want to fetch course from review. So let's make it a unidirectional one.

	package com.springhibernate.entity
	import javax.persistence.*
	@Entity
	@Table(name = "review")
	data class Review(@Column(name="comment") val comment : String?) {
	@Id
	@Column(name = "id")
	@GeneratedValue(strategy= GenerationType.SEQUENCE)
	val id : Long? = null
	}

view raw Review.kt hosted with ❤ by GitHub

	package com.springhibernate.demo
	import com.springhibernate.entity.Course
	import com.springhibernate.entity.Instructor
	import com.springhibernate.entity.InstructorDetail
	import com.springhibernate.entity.Review
	import org.hibernate.cfg.Configuration
	import java.lang.Exception
	fun main() {
	// create session factory
	val sessionFactory = Configuration()
	.configure("hibernate.cfg.xml")
	.addAnnotatedClass(Instructor::class.java)
	.addAnnotatedClass(InstructorDetail::class.java)
	.addAnnotatedClass(Course::class.java)
	.addAnnotatedClass(Review::class.java)
	.buildSessionFactory()
	// create session
	val session = sessionFactory.currentSession
	try{
	session.beginTransaction()
	// create course
	val tempCourse = session.get(Course::class.java, 47L)
	//create reviews
	val review1 = Review("This is a good course!")
	val review2 = Review("Instructor is rude")
	// add reviews to course
	tempCourse.addReview(review1)
	tempCourse.addReview(review2)
	session.save(tempCourse)
	session.transaction.commit()
	} catch (exception : Exception) {
	exception.printStackTrace()
	} finally {
	session.close()
	sessionFactory.close()
	}
	}

view raw OneToManyUnidirDemo.kt hosted with ❤ by GitHub

Before moving on to the Many to Many mapping, I would like to take a pause and explain the concept of fetch type. There are 2 fetch types (loading strategies) available in hibernate, Eager loading, and Lazy loading. Eager loading will retrieve everything and lazy loading will retrieve on request. For eg. when you are using Eager loading and you load Instructor data, the hibernate will also load InstructorDetail, Course, and Review. This is not a good practice to follow in a production environment. You only need to load something that's needed to optimize your application and improve performance. That's where lazy loading comes into the picture. Lazy loading will only load Instructor data and retrieve everything else on demand. The only important thing to note here is lazy loading requires the session to be open otherwise you will encounter LazyLoadingException. The reason lazy loading should take place during the session's life cycle is that hibernate will make database calls using the session behind the scenes.

Many to Many mapping: One student can be enrolled in many courses and one course can have many students enrolled. This situation calls for Many to Many mapping and it needs a separate table in the database. I have established Many to Many relationship between Course and Student and also created a course_student table. Instead of @JoinColumn, we need to use @JoinTable annotation.

	package com.springhibernate.entity
	import javax.persistence.*
	@Entity
	@Table(name = "course")
	data class Course(@Column(name = "title") var title : String?) {
	@Id
	@Column(name = "id")
	@GeneratedValue(strategy= GenerationType.SEQUENCE)
	val id : Long? = null
	@ManyToOne(cascade = [CascadeType.REFRESH,
	CascadeType.PERSIST,
	CascadeType.MERGE,
	CascadeType.DETACH])
	@JoinColumn(name = "instructor_id")
	var instructor : Instructor? = null
	@OneToMany(fetch = FetchType.LAZY, cascade = [CascadeType.ALL])
	@JoinColumn(name = "course_id")
	var reviews : MutableList<Review>? = null
	fun addReview(review : Review) {
	if(reviews == null)
	reviews = mutableListOf()
	reviews?.add(review)
	}
	@ManyToMany(fetch = FetchType.LAZY, cascade = [CascadeType.REFRESH,
	CascadeType.PERSIST,
	CascadeType.MERGE,
	CascadeType.DETACH])
	@JoinTable(
	name = "course_student",
	joinColumns = [JoinColumn(name = "course_id")],
	inverseJoinColumns = [JoinColumn(name = "student_id")]
	)
	var students : MutableList<Student>? = null
	fun addStudent(student : Student){
	if(students == null)
	students = mutableListOf()
	students?.add(student)
	}
	}

view raw CourseStudent.kt hosted with ❤ by GitHub

	package com.springhibernate.entity
	import javax.persistence.*
	@Entity
	@Table(name = "student")
	data class Student(@Column(name = "first_name") var firstName : String?,
	@Column(name = "last_name") val lastName : String?,
	@Column(name = "email") val email : String?) {
	@Id
	@Column(name = "id")
	@GeneratedValue(strategy=GenerationType.SEQUENCE)
	val id : Long? = null
	@ManyToMany(fetch = FetchType.LAZY, cascade = [CascadeType.REFRESH,
	CascadeType.PERSIST,
	CascadeType.MERGE,
	CascadeType.DETACH])
	@JoinTable(
	name = "course_student",
	joinColumns = [JoinColumn(name = "student_id")],
	inverseJoinColumns = [JoinColumn(name = "course_id")]
	)
	var courses : MutableList<Course>? = null
	}

view raw StudentCourse.kt hosted with ❤ by GitHub

	package com.springhibernate.demo
	import com.springhibernate.entity.*
	import org.hibernate.cfg.Configuration
	import java.lang.Exception
	fun main() {
	// create session factory
	val sessionFactory = Configuration()
	.configure("hibernate.cfg.xml")
	.addAnnotatedClass(Instructor::class.java)
	.addAnnotatedClass(InstructorDetail::class.java)
	.addAnnotatedClass(Course::class.java)
	.addAnnotatedClass(Review::class.java)
	.addAnnotatedClass(Student::class.java)
	.buildSessionFactory()
	// create session
	val session = sessionFactory.currentSession
	try{
	session.beginTransaction()
	// get course
	val tempCourse = session.get(Course::class.java, 47L)
	// get students
	val student1 = session.get(Student::class.java, 9L)
	// add student course relation
	tempCourse.addStudent(student1)
	// save
	session.save(student1)
	println(student1.courses)
	println(tempCourse.students)
	session.transaction.commit()
	} catch (exception : Exception) {
	exception.printStackTrace()
	} finally {
	session.close()
	sessionFactory.close()
	}
	}

view raw ManyToManyDemo.kt hosted with ❤ by GitHub

Before ending this blog here are a few important takeaways:

• Rember to add Kotlin noarg plugin to avoid exceptions
• Add a right JPA generation type strategy to manage primary keys

I hope you learned something new about using Hibernate with Kotlin in this blog post. The entire code can be found on my GitHub. Thanks for reading and stay tuned for more! Happy coding 😃