@Id and @GeneratedValue for primary keys in Spring Boot

Introduction

We use @Id to mark a field as the main identifier for a database record. @GeneratedValue helps create unique IDs automatically so we don't have to set them ourselves.

When you want to uniquely identify each record in a database table.

When you want the database or framework to automatically create unique IDs for new records.

When building applications that store data and need to retrieve or update specific entries.

When you want to avoid manually managing primary key values to prevent duplicates.

Syntax

Spring Boot

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

@Entity
public class EntityName {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    // other fields, getters, setters
}

@Id marks the primary key field.

@GeneratedValue tells Spring Boot to generate the ID automatically. The strategy defines how IDs are created.

Examples

This example uses GenerationType.IDENTITY which lets the database handle ID generation, often using auto-increment.

Spring Boot

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

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long userId;

    private String name;
}

This example uses GenerationType.SEQUENCE which uses a database sequence to generate IDs, common in some databases like Oracle.

Spring Boot

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

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long productId;

    private String productName;
}

GenerationType.AUTO lets Spring Boot pick the best strategy based on the database.

Spring Boot

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

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long orderId;

    private String orderDetails;
}

Sample Program

This Spring Boot app defines a Person entity with @Id and @GeneratedValue. It saves a new person and prints the list before and after saving. The ID is generated automatically.

Spring Boot

package com.example.demo;

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import org.springframework.beans.factory.annotation.Autowired;

@Entity
class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;

    public Person() {}

    public Person(String name) {
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Person{id=" + id + ", name='" + name + "'}";
    }
}

@Repository
interface PersonRepository extends JpaRepository<Person, Long> {}

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

    @Autowired
    private PersonRepository personRepository;

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println("Before saving:");
        personRepository.findAll().forEach(System.out::println);

        Person newPerson = new Person("Alice");
        personRepository.save(newPerson);

        System.out.println("After saving:");
        personRepository.findAll().forEach(System.out::println);
    }
}

Important Notes

Time complexity: Generating the ID is very fast and handled by the database or framework.

Space complexity: No extra space is needed beyond the entity object.

Common mistake: Forgetting to add @Id causes errors because the framework doesn't know the primary key.

Use @GeneratedValue when you want automatic unique IDs. If you want to set IDs manually, do not use it.

Summary

@Id marks the primary key field in an entity.

@GeneratedValue automatically creates unique IDs for new records.

Choosing the right GenerationType depends on your database and needs.

Practice

1. What is the main purpose of the @Id annotation in a Spring Boot entity?

easy

A. To specify a foreign key relationship

B. To generate unique values automatically

C. To define a database table name

D. To mark the primary key field of the entity

Solution

1. Step 1: Understand the role of @Id

   The @Id annotation marks a field as the primary key in a database entity.

2. Step 2: Differentiate from other annotations

   @GeneratedValue generates values, but @Id specifically identifies the primary key field.

3. Final Answer:

   To mark the primary key field of the entity -> Option D

4. Quick Check:

   @Id marks primary key [OK]

Hint: Remember: @Id means 'this is the primary key' [OK]

Common Mistakes:

• Confusing @Id with @GeneratedValue
• Thinking @Id generates values automatically
• Using @Id to name tables

2. Which of the following is the correct way to use @GeneratedValue with GenerationType.IDENTITY in a Spring Boot entity?

easy

A. @GeneratedValue(strategy = GenerationType.AUTO)

B. @GeneratedValue(strategy = GenerationType.SEQUENCE)

C. @GeneratedValue(strategy = GenerationType.IDENTITY)

D. @GeneratedValue(strategy = GenerationType.TABLE)

Solution

1. Step 1: Identify the correct strategy for identity generation

   GenerationType.IDENTITY is used to let the database auto-increment the primary key.

2. Step 2: Match the annotation syntax

   The correct syntax is @GeneratedValue(strategy = GenerationType.IDENTITY).

3. Final Answer:

   @GeneratedValue(strategy = GenerationType.IDENTITY) -> Option C

4. Quick Check:

   Use GenerationType.IDENTITY with strategy = GenerationType.IDENTITY [OK]

Hint: Use strategy = GenerationType.IDENTITY for auto-increment keys [OK]

Common Mistakes:

• Using AUTO instead of IDENTITY for auto-increment
• Omitting the strategy parameter
• Confusing SEQUENCE with IDENTITY

3. Given the entity code below, what will be the value of user.getId() after saving a new user to the database?

 @Entity
 public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String name;

   // getters and setters
 }

medium

A. A unique auto-generated Long value

B. null

C. The name of the user

D. An exception will be thrown

Solution

1. Step 1: Understand @GeneratedValue with IDENTITY

   This strategy lets the database generate a unique primary key value automatically when saving.

2. Step 2: Predict the value after saving

   After saving, user.getId() will hold the generated unique Long value assigned by the database.

3. Final Answer:

   A unique auto-generated Long value -> Option A

4. Quick Check:

   @GeneratedValue with IDENTITY creates unique IDs [OK]

Hint: After save, IDENTITY generates a unique Long ID automatically [OK]

Common Mistakes:

• Expecting id to be null after save
• Confusing id with other fields
• Assuming an error occurs without database setup

4. Consider this entity code snippet:

 @Entity
 public class Product {
   @Id
   @GeneratedValue
   private Long productId;

   private String name;
 }

What is the likely problem with this code?

medium

A. Missing strategy in @GeneratedValue may cause unexpected ID generation

B. The field productId should not be private

C. The @Id annotation is missing

D. The entity class must implement Serializable

Solution

1. Step 1: Check @GeneratedValue usage

   The @GeneratedValue annotation without specifying a strategy defaults to AUTO, which may behave differently depending on the database.

2. Step 2: Understand impact of missing strategy

   This can cause unexpected ID generation behavior if the database does not support the default strategy well.

3. Final Answer:

   Missing strategy in @GeneratedValue may cause unexpected ID generation -> Option A

4. Quick Check:

   Always specify strategy to avoid surprises [OK]

Hint: Always specify strategy in @GeneratedValue to avoid surprises [OK]

Common Mistakes:

• Thinking private fields cause errors
• Believing @Id is missing
• Assuming Serializable is mandatory

5. You want to create a Spring Boot entity with a primary key that uses a database sequence named user_seq. Which is the correct way to annotate the ID field?

hard

A. @Id @GeneratedValue(strategy = GenerationType.IDENTITY)

B. @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_seq") @SequenceGenerator(name = "user_seq", sequenceName = "user_seq", allocationSize = 1)

C. @Id @GeneratedValue(strategy = GenerationType.TABLE)

D. @Id @GeneratedValue(strategy = GenerationType.AUTO)

Solution

1. Step 1: Identify sequence generation requirements

   Using a database sequence requires GenerationType.SEQUENCE and a matching @SequenceGenerator annotation.

2. Step 2: Match annotations to sequence name

   The @SequenceGenerator defines the sequence name and allocation size, linked by the generator name in @GeneratedValue.

3. Final Answer:

   @Id @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_seq") @SequenceGenerator(name = "user_seq", sequenceName = "user_seq", allocationSize = 1) -> Option B

4. Quick Check:

   Use SEQUENCE with @SequenceGenerator for DB sequences [OK]

Hint: Use @SequenceGenerator with SEQUENCE strategy for DB sequences [OK]

Common Mistakes:

• Using IDENTITY instead of SEQUENCE for sequences
• Omitting @SequenceGenerator annotation
• Confusing TABLE and AUTO strategies