How To Set Default Values In Hibernate & JPA

Quick Answer: To establish a jpa default value in Hibernate, developers choose between Java-level field initialization (private String status = "ACTIVE";) and database schema-level constraints via @Column(columnDefinition = "varchar(255) default 'ACTIVE'") paired with @ColumnDefault. To ensure database defaults apply when persisting entities with null fields, enable @DynamicInsert on the entity class or utilize compact record default value constructors.

In enterprise Java persistence layers utilizing Hibernate and Jakarta Persistence (JPA), managing default values for entity properties is a frequent requirement. Whether defaulting a user account status to “PENDING”, setting a creation timestamp, or initializing a numeric counter to zero, developers must choose the correct abstraction level. Confusing in-memory Java initialization with database column DDL defaults leads to silent bugs where null values unexpectedly overwrite database table defaults during SQL insert statements.

Table of Contents

JPA Default Value Strategies: Java Level vs. Database Schema Level

There are two distinct architectural layers where default values can be configured:

Strategy	Implementation Syntax	Where Default Is Applied	Direct SQL Insert Behavior
Java Field Initialization	`private String status = "ACTIVE";`	JVM Memory upon object instantiation	Explicitly inserts “ACTIVE” in INSERT statement
Database DDL Default	`@ColumnDefault("'ACTIVE'")`	Database Engine (PostgreSQL / MySQL DDL)	Fails if Hibernate sends explicit NULL
@DynamicInsert	`@DynamicInsert` on Entity class	Database Engine (Omits null columns from SQL)	Allows database column default to trigger
@PrePersist Lifecycle Hook	`@PrePersist void init() { ... }`	Entity Manager prior to SQL execution	Inserts calculated/dynamic default values

Using @ColumnDefault and @DynamicInsert in Hibernate

When relying on database-level column defaults, standard Hibernate behavior can cause unexpected behavior. By default, Hibernate generates static INSERT statements including every entity field. If a field in Java is null, Hibernate executes INSERT INTO users (id, status) VALUES (1, NULL);, actively overriding the database column default!

To resolve this, annotate your entity with @DynamicInsert:

import org.hibernate.annotations.ColumnDefault;
import org.hibernate.annotations.DynamicInsert;
import jakarta.persistence.*;

@Entity
@Table(name = "accounts")
@DynamicInsert
public class Account {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // Database DDL generation default
    @Column(name = "status", nullable = false)
    @ColumnDefault("'ACTIVE'")
    private String status;

    @Column(name = "retry_count", nullable = false)
    @ColumnDefault("0")
    private Integer retryCount;

    // Standard getters and setters
}

With @DynamicInsert enabled, any field with a null Java value is omitted from the generated SQL INSERT statement, allowing the database engine’s default value constraint to take effect seamlessly.

Configuring Java Set Default Value in Modern Java Records

In modern Java (17+ and 21+), developers increasingly use Java Records for immutable data transfer objects (DTOs) and persistence projections. Because records use compact canonical constructors without mutable field initializers, configuring how to java set default value patterns or record default value instances requires compact constructor customization:

// Compact Constructor for Default Values in Java Records
public record UserAccountDto(
    Long id,
    String username,
    String role,
    boolean emailVerified
) {
    // Compact constructor injecting default values
    public UserAccountDto {
        if (role == null || role.isBlank()) {
            role = "ROLE_USER"; // Default value assignment
        }
    }

    // Static factory providing default instance
    public static UserAccountDto of(String username) {
        return new UserAccountDto(null, username, "ROLE_USER", false);
    }
}

Recommended Best Practice Summary

For Simple Fields: Initialize fields directly in the Java entity declaration (private Integer count = 0;). It is clear, readable, and works across all JPA providers without vendor-specific annotations.
For Audit Timestamps: Use JPA @CreationTimestamp or @PrePersist callback methods.
For Legacy Database Integration: Pair @ColumnDefault with @DynamicInsert when database triggers or schema constraints manage authoritative defaults.