JPA entity with @Entity annotation in Spring Boot - Step-by-Step Execution

Concept Flow - JPA entity with @Entity annotation

Write class with @Entity

↓

Add @Id for primary key

↓

Add fields for columns

↓

Spring Boot scans entity

↓

Entity mapped to DB table

↓

Use repository to save/load entity

This flow shows how a Java class is marked as a JPA entity with @Entity, given a primary key with @Id, then scanned and mapped to a database table for CRUD operations.

Execution Sample

Spring Boot

import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity
public class Person {
  @Id
  private Long id;
  private String name;
}

Defines a simple JPA entity class Person with an id as primary key and a name field.

Execution Table

Step	Action	Annotation Processed	Effect	Resulting State
1	Read class Person	None yet	Class loaded	Person class exists
2	Detect @Entity annotation	@Entity	Mark class as JPA entity	Person is an entity
3	Detect @Id on field 'id'	@Id	Mark 'id' as primary key	'id' is primary key
4	Detect fields 'id' and 'name'	None	Map fields to columns	Fields mapped to columns
5	Spring Boot scans entities	All entities	Prepare ORM mapping	Person mapped to DB table
6	Use repository to save Person	None	Persist entity to DB	Person saved in DB
7	Use repository to load Person	None	Retrieve entity from DB	Person loaded from DB
8	End	N/A	Process complete	Entity ready for CRUD

💡 All entity annotations processed, entity mapped and ready for database operations

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
Person class	Not loaded	Loaded and marked @Entity	Primary key 'id' marked	Fields mapped	Ready as JPA entity

Key Moments - 3 Insights

Why do we need the @Entity annotation on the class?

The @Entity annotation tells Spring Boot and JPA that this class should be treated as a database entity. Without it, the class won't be mapped to a table (see execution_table step 2).

What is the role of the @Id annotation?

The @Id annotation marks the primary key field of the entity. This is required so JPA knows which field uniquely identifies each record (see execution_table step 3).

Can the entity work without fields other than the primary key?

Yes, but usually you add fields to represent columns. The primary key is mandatory, but other fields map to table columns (see execution_table step 4).

Visual Quiz - 3 Questions

Look at the execution table, at which step is the class marked as a JPA entity?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Check the 'Annotation Processed' column for @Entity in the execution_table.

According to the variable tracker, what is the state of the Person class after Step 3?

A Primary key 'id' marked

B Loaded and marked @Entity

C Not loaded

D Fields mapped

💡 Hint

Look at the 'After Step 3' column in the variable_tracker for Person class.

If the @Id annotation was missing, what would happen in the execution flow?

A The class would not be marked as an entity

B Fields would not be mapped to columns

C The primary key would not be identified, causing errors

D Spring Boot would skip scanning the class

💡 Hint

Refer to key_moments about the role of @Id and execution_table step 3.

Concept Snapshot

JPA Entity with @Entity annotation:
- Use @Entity on class to mark it as a database entity.
- Use @Id on a field to mark the primary key.
- Fields become table columns.
- Spring Boot scans and maps entities automatically.
- Entities enable CRUD operations via repositories.

Full Transcript

This visual execution trace shows how a Java class becomes a JPA entity using the @Entity annotation. First, the class is loaded and detected with @Entity, marking it as a database entity. Then the @Id annotation marks the primary key field. Other fields are mapped to database columns. Spring Boot scans all entities and prepares them for ORM mapping. Finally, the entity can be saved and loaded from the database using repositories. Key points include the necessity of @Entity to mark the class and @Id to identify the primary key. The variable tracker shows the state changes of the class as annotations are processed. The quizzes reinforce understanding of when and why these annotations are used.

Practice

1. What is the main purpose of the @Entity annotation in a Spring Boot application?

easy

A. To mark a class as a database table for JPA

B. To create a REST API endpoint

C. To configure application properties

D. To define a service component

Solution

1. Step 1: Understand the role of @Entity

   The @Entity annotation tells Spring Boot and JPA that this class represents a table in the database.

2. Step 2: Differentiate from other annotations

   Other annotations like @RestController or @Service serve different purposes unrelated to database tables.

3. Final Answer:

   To mark a class as a database table for JPA -> Option A

4. Quick Check:

   @Entity marks database tables [OK]

Hint: Remember: @Entity means database table class [OK]

Common Mistakes:

• Confusing @Entity with @Service
• Thinking @Entity creates REST endpoints
• Assuming @Entity configures app settings

2. Which of the following is the correct way to declare a JPA entity class with an ID field?

easy

A. @Entity public class User { private Long id; }

B. public class User { private Long id; }

C. @Entity public class User { @Id private Long id; }

D. @Service public class User { @Id private Long id; }

Solution

1. Step 1: Check for @Entity annotation

   The class must have @Entity to be recognized as a JPA entity.

2. Step 2: Verify presence of @Id on a field

   Every entity needs a unique identifier marked with @Id to map the primary key.

3. Final Answer:

   @Entity public class User { @Id private Long id; } -> Option C

4. Quick Check:

   Entity + Id field = correct syntax [OK]

Hint: Entity needs @Entity and @Id on ID field [OK]

Common Mistakes:

• Missing @Entity annotation
• Forgetting @Id on the ID field
• Using @Service instead of @Entity

3. Given this entity class:

@Entity
public class Product {
  @Id
  private Long id;
  private String name;

  public Product() {}
  public Product(Long id, String name) {
    this.id = id;
    this.name = name;
  }
  public String getName() { return name; }
}

What will happen if you save a Product with id=1 and name="Book" using JPA repository and then retrieve it?

medium

A. The Product is not saved because of missing @Column

B. You get a Product object with id=1 and name="Book"

C. You get a runtime error because no setter for name

D. You get a Product object with id=1 but name is null

Solution

1. Step 1: Understand JPA entity saving and retrieval

   JPA uses the @Entity class and its fields to save and load data. The constructor and getter allow access to fields.

2. Step 2: Check if missing setter affects retrieval

   JPA can set fields via reflection even without setters, so name will be loaded correctly.

3. Final Answer:

   You get a Product object with id=1 and name="Book" -> Option B

4. Quick Check:

   JPA loads fields even without setters [OK]

Hint: JPA sets fields directly; getters needed to read [OK]

Common Mistakes:

• Assuming missing setter causes runtime error
• Thinking @Column is mandatory for saving
• Believing name will be null without setter

4. Identify the error in this entity class:

@Entity
public class Customer {
  private Long id;
  private String email;

  public Long getId() { return id; }
  public String getEmail() { return email; }
}

medium

A. Missing @Entity annotation

B. Missing default constructor

C. Fields should be public

D. Missing @Id annotation on the id field

Solution

1. Step 1: Check for @Entity annotation

   The class has @Entity, so it is recognized as an entity.

2. Step 2: Verify presence of @Id annotation

   The id field lacks @Id, so JPA cannot identify the primary key, causing errors.

3. Final Answer:

   Missing @Id annotation on the id field -> Option D

4. Quick Check:

   Every entity needs @Id on primary key [OK]

Hint: Always put @Id on the primary key field [OK]

Common Mistakes:

• Assuming default constructor is mandatory (JPA provides one)
• Thinking fields must be public
• Ignoring missing @Id annotation

5. You want to create a JPA entity Order with a composite primary key made of orderId and productId. Which approach correctly applies the @Entity annotation and primary key setup?

hard

A. Use @Entity on Order and create a separate @Embeddable class for the composite key with @EmbeddedId in Order

B. Use @Entity on Order and mark both fields @Id without extra class

C. Use @Entity on Order and mark only one field @Id, ignore the other

D. Use @Entity on Order and define composite key in application.properties

Solution

1. Step 1: Understand composite keys in JPA

   JPA requires a separate class annotated with @Embeddable to represent composite keys.

2. Step 2: Use @EmbeddedId in the entity

   The entity class uses @EmbeddedId to include the composite key class as its primary key.

3. Final Answer:

   Use @Entity on Order and create a separate @Embeddable class for the composite key with @EmbeddedId in Order -> Option A

4. Quick Check:

   Composite key needs @Embeddable + @EmbeddedId [OK]

Hint: Composite keys need @Embeddable class + @EmbeddedId field [OK]

Common Mistakes:

• Marking multiple fields with @Id without composite key class
• Ignoring one key field in composite key
• Trying to configure keys in properties file