JPA Entities & Mapping

A JPA entity is a plain Java class that maps to a database table. With a handful of annotations — @Entity , @Id , @GeneratedValue , @Column , @Table — you describe how objects become rows and back again.

Learn JPA Entities & Mapping in our free Java course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free Java course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

Before You Start

You should understand classes and objects and the basics of Spring Data JPA . These examples use the jakarta.persistence annotations.

What You'll Learn

The Big Idea — A Form That Fills a Spreadsheet Row

💡 Analogy: Think of an @Entity class as a paper form and the database table as a spreadsheet . Each field on the form is a column; each filled-in form becomes one row. @Id is the row number, @GeneratedValue means the spreadsheet stamps that number for you, and @Column notes are the rules ("this box can't be blank, max 100 characters"). You design the form once; the framework files every submission as a tidy row.

Object-relational mapping is just this translation: objects to rows, rows to objects, automatically.

1️⃣ A Basic Entity

Annotate a class with @Entity , mark its key with @Id , and let the database generate ids. @Table and @Column fine-tune the names and constraints.

2️⃣ How a Generated Id Behaves

With @GeneratedValue , the id is null until the row is inserted ; the database then assigns the value. Here is a plain-Java simulation of that lifecycle you can actually run.

3️⃣ Keeping Fields Out — @Transient

JPA persists every field by default. A value you only compute in memory — a formatted price, a cached total — should be marked @Transient so it never becomes a column.

🧠 Quick Recall

Answer: Invoice — JPA derives the table name from the entity name unless @Table(name = "...") overrides it.

Answer: null for a generated Long id — the database assigns it on insert.

Answer: @Transient . The field stays in memory only and is never mapped to a column.

🎯 YOUR TURN — Map a Book

Create a Book entity with a generated id, a NOT NULL title, and a unique isbn_13 column.

🧩 MINI-CHALLENGE — Employee with a derived field

Map an Employee with custom column names and a @Transient computed salary.

Common Errors

• ❌ No no-arg constructor. The provider can't instantiate the entity. Fix: add a protected or public no-arg constructor.
• ❌ Forgetting @Id. Every entity needs a primary key. Fix: mark exactly one field (or composite) with @Id .
• ❌ Using a primitive for a generated id. It can't be null before insert. Fix: use Long , not long .
• ❌ Storing money as double. Rounding bugs creep in. Fix: store integer cents or use BigDecimal.
• ❌ Persisting computed fields. Derived values bloat the table. Fix: mark them @Transient .
• ❌ Mixing javax and jakarta imports. Modern Spring Boot uses jakarta.persistence . Fix: import from jakarta , not javax .

Pro Tips

• 💡 Use wrapper types for ids ( Long ) so a not-yet-saved entity reads as null .
• 💡 Add explicit @Column constraints — nullable , length , unique — to shape the generated schema.
• 💡 Keep a protected no-arg constructor for JPA and a real constructor for your own code.
• 💡 Prefer IDENTITY or SEQUENCE over assigning ids by hand in application code.

📋 Quick Reference

Annotation

Purpose

Note

@Entity

class is persistent

Maps to a table

@Table(name)

custom table name

Defaults to class name

@Id

primary key

Exactly one

@GeneratedValue

auto-generate key

IDENTITY / SEQUENCE

@Column(name)

custom column name

Defaults to field

@Column(nullable)

NOT NULL constraint

false = required

@Column(length)

VARCHAR size

For String columns

@Column(unique)

UNIQUE constraint

No duplicates

@Transient

not persisted

In-memory only

no-arg ctor

required by JPA

protected is fine

📚 Resources / Keep Learning

• 📘 Jakarta Persistence 3.1 specification (jakarta.ee)
• 📗 Spring Data JPA — entity persistence (docs.spring.io)
• 📗 Hibernate ORM documentation (hibernate.org)

❓ Frequently Asked Questions

🎉 Lesson Complete!

You can now map a class to a table with @Entity , define and auto-generate a primary key with @Id and @GeneratedValue , shape columns and tables with @Column and @Table , and exclude computed fields with @Transient .

Next up: Entity Relationships — connecting entities with @OneToMany , @ManyToOne , and @ManyToMany .

Practice quiz

Continue this course

• Previous: Spring Data JPA Basics
• Next: Entity Relationships

Related lessons

• classes and objects