Real data with JPA, H2 & Lombok

Shared core

The chapter below remains the canonical explanation for both goals. Keep its model, examples, and trade-offs shared; only the deliberate practice changes with the route.

Learn deeply: build evidence

Use this chapter’s TaskFlow work to make one small, observable change. Run the stated acceptance checks before recording practice.

Prepare for interviews: explain the trade-off

Without notes, explain the boundary this chapter protects, one concrete implementation decision, and the cost of a tempting shortcut. Then answer one follow-up using the chapter’s own example.

Section 1What actually sits between your code and the database

Two names get muddled constantly. Pin them down before writing anything:

And on top of both, Spring Data JPA is the convenience layer that gives you the repository for free — you declare an interface, it writes the class. The chain, top to bottom:

Section 2Add two dependencies

Open pom.xml and add the JPA starter and the H2 driver next to the web starter you already have. (In a fresh project you'd tick these on start.spring.io; adding them by hand shows exactly what they are.)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Reload Maven (IntelliJ shows a little refresh icon). Now configure H2 in the settings sheet:

# --- H2 in-memory database ---
spring.datasource.url=jdbc:h2:mem:taskflow
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

# let Hibernate create the tables from your @Entity classes at startup
spring.jpa.hibernate.ddl-auto=update

# handy while learning
spring.jpa.show-sql=true          # print the SQL Hibernate runs
spring.h2.console.enabled=true    # a web UI to browse the DB at /h2-console

Section 3Turn the model into a table

Take the Task from Chapter 3 and add four annotations. That's the whole change — the fields stay the same, because they were always the columns-to-be.

package com.example.taskflow.model;

import jakarta.persistence.*;

@Entity                 // "this class is a table"
@Table(name = "tasks")  // (optional) name the table explicitly
public class Task {

    @Id                                                     // primary key
    @GeneratedValue(strategy = GenerationType.IDENTITY)     // DB auto-assigns the id
    private Long id;

    @Column(nullable = false)                               // NOT NULL column
    private String title;

    private boolean done;   // maps to a column automatically; no annotation needed

    public Task() { }

    public Task(String title, boolean done) {   // note: no id — the DB assigns it
        this.title = title;
        this.done = done;
    }

    // ...the same getters & setters as before...
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }
    public boolean isDone() { return done; }
    public void setDone(boolean done) { this.done = done; }
}

Section 4Delete the repository, replace it with one interface

This is the moment. Our Chapter 3 TaskRepository was ~30 lines of Map-juggling. Delete all of it and replace the class with a one-line interface:

package com.example.taskflow.repository;

import com.example.taskflow.model.Task;
import org.springframework.data.jpa.repository.JpaRepository;

public interface TaskRepository extends JpaRepository<Task, Long> { }

Section 5Run it and watch the SQL

Start the app. Because show-sql=true, creating a task now prints the actual SQL Hibernate generated from your entity:

You wrote no SQL. Hibernate read your @Entity and produced it. Now open http://localhost:8080/h2-console in a browser, set JDBC URL to jdbc:h2:mem:taskflow (must match the properties file), user sa, no password → Connect. You'll see a TASKS table with your row in it. Seeing the actual table demystifies "where did my data go."

Section 6Lombok — delete the boilerplate

Your Task is mostly getters and setters. Lombok generates those at compile time from a single annotation, so the source shows only what's interesting. It removes typing, not concepts — the getters still exist in the compiled class.

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

package com.example.taskflow.model;

import jakarta.persistence.*;
import lombok.*;

@Entity
@Table(name = "tasks")
@Getter @Setter                 // generate all getters & setters
@NoArgsConstructor              // generate Task()
@AllArgsConstructor            // generate Task(id, title, done)
public class Task {

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

    @Column(nullable = false)
    private String title;

    private boolean done;
}

Section 7Swap H2 → MySQL (config, not code)

Here's the promise from Chapter 1 made real. To move from H2 to MySQL you change one dependency and three properties. Not a single Java file changes — entity, repository, service, controller all stay.

<!-- remove h2, add: -->
<dependency>
  <groupId>com.mysql</groupId>
  <artifactId>mysql-connector-j</artifactId>
  <scope>runtime</scope>
</dependency>

spring.datasource.url=\
  jdbc:mysql://localhost:3306/taskflow
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.jpa.hibernate.ddl-auto=update

Section 8Exercises

public interface TaskRepository extends JpaRepository<Task, Long> {
    List<Task> findByDone(boolean done);   // Spring writes: WHERE done = ?
}

public List<Task> getAll(Boolean done) {
    return (done == null) ? repository.findAll() : repository.findByDone(done);
}

@GetMapping
public List<Task> all(@RequestParam(required = false) Boolean done) {
    return service.getAll(done);
}

spring.datasource.url=jdbc:h2:file:./data/taskflow