Kotlin with JPA: How to Defeat Default Constructor Hell

Meet the "Default Constructor Hell" in Kotlin + JPA

If you've ever tried to make Kotlin work with JPA (Java Persistence API), you've likely encountered a situation where Hibernate throws an exception like this when starting the application:

org.hibernate.InstantiationException: No default constructor for entity: com.example.User\n

Sound familiar? It sure does. This is the problem that has gathered thousands of views on Stack Overflow and earned the grim name "Kotlin with JPA: default constructor hell".

In this article, we'll calmly, step by step, break down:

\n
• Why this error occurs in the first place
\n
• Why Kotlin "doesn't want" to generate an empty constructor
\n
• Three proven ways to solve the problem (from simple to professional)
\n
• Which method to choose for your project
\n

Let's go!

Why does Hibernate require a no-argument constructor?

Let's start with Java. In classic Java, we are used to writing:

public class User {\n    private Long id;\n    private String name;\n\n    // Mandatory empty constructor\n    public User() {}\n\n    // Getters, setters...\n}\n

Hibernate (and any JPA implementation) uses reflection to create objects. When it reads a row from the database, it needs to create an instance of the User class, and then populate the fields via reflection. For this, it needs a constructor without parameters (default constructor).

In Java, the compiler automatically creates an empty constructor if you haven't defined any other constructor. Therefore, the problem usually doesn't arise.

What's special about Kotlin?

Kotlin is a language with a strong emphasis on immutability and safety. Take a look at a typical Kotlin class:

data class User(\n    val id: Long = 0,\n    val name: String = ""\n)\n

Two key things are happening here:

\n
• All properties are declared in the primary constructor
\n
• Properties are declared as val (immutable) and have default values
\n

Kotlin does not generate a separate empty constructor if you have a primary constructor with parameters. Even if all parameters have default values, this is not considered a "real" no-argument constructor at the JVM bytecode level.

When Hibernate tries to call User.class.newInstance() via reflection, it doesn't find an empty constructor — and crashes with an error.

Method 1: The Simplest — Explicitly Add a Secondary Constructor

The most straightforward path is to add a second, empty constructor manually:

data class User(\n    val id: Long = 0,\n    val name: String = ""\n) {\n    // Secondary constructor without parameters\n    constructor() : this()\n}\n

Here, constructor() : this() means: "call the primary constructor with default values".

Pros:

\n
• Very simple and clear
\n
• Requires no plugins or additional configuration
\n

Cons:

\n
• You need to write this constructor for every entity
\n
• If you have 10-15 entities, it becomes tedious
\n
• Easy to forget to add
\n

Method 2: Use an open class and make all properties var

Many examples online suggest this solution:

open class User {\n    var id: Long = 0\n    var name: String = ""\n}\n

Here, we make the class open (so Hibernate can create proxies), and the properties — var (mutable). And there's no primary constructor — meaning Kotlin will generate a default empty constructor.

Pros:

\n