Persisting Data with Spring Data JPA Using Kotlin

Welcome to the first lesson of the course, "Persisting Data with Spring Data JPA." Throughout this course, you'll discover how to leverage Spring Data JPA to connect your Kotlin applications to relational databases, establish simple and complex relationships, implement pagination and sorting, and more. In this introductory lesson, we’ll delve into how Kotlin, being concise and interoperable with Java, makes working with Spring Data JPA efficient and less verbose. Kotlin's features, such as data classes and nullable types, complement the use of Spring, enhancing your productivity. Let’s get started!

Java Database Connectivity (JDBC) is a Java Standard Edition (SE) API that allows Java applications to interact with relational databases. It involves writing explicit SQL queries, managing database connections, and handling result sets manually. Here is an example of how to retrieve data using JDBC:

import java.sql.Connection
import java.sql.DriverManager
import java.sql.ResultSet
import java.sql.Statement

fun main() {
    val url = "jdbc:mysql://localhost:3306/mydb"
    val username = "root"
    val password = "password"

    try {
        DriverManager.getConnection(url, username, password).use { conn -> 
            val stmt: Statement = conn.createStatement()
            val rs: ResultSet = stmt.executeQuery("SELECT * FROM my_table")
            
            while (rs.next()) {
                println(rs.getString("column1"))
            }
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

As you can see, this approach is cumbersome with a lot of boilerplate code. This method has nothing to do with Spring Boot and reflects the complexities involved in manual database operations.

If you want to dive deeper into JDBC, refer to the official specification.

The Java Persistence API (JPA) provides a specification for Object Relational Mapping (ORM), simplifying database interactions by mapping Kotlin objects to database tables. ORM enables you to manipulate database records seamlessly through Kotlin objects, making your code cleaner and more maintainable. Here’s an example of a JPA entity class in Kotlin:

import jakarta.persistence.Entity
import jakarta.persistence.GeneratedValue
import jakarta.persistence.GenerationType
import jakarta.persistence.Id

@Entity
data class Person(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0,
    var name: String,
    var age: Int
)

In this example:

• @Entity: Denotes this class as a JPA entity. The default naming convention converts the class name from camel case to lower snake case to map it to a table. For instance, Person becomes person, TodoItem becomes todo_item, and OrderDetail becomes order_detail.
• Primary constructor with @Id specifies the primary key, where id is mapped to the primary key column.
• @GeneratedValue(strategy = GenerationType.IDENTITY): The primary key is auto-generated by the database.

For more on JPA, explore the official specification.