Lesson 73Phase 9: Data and the web

Saving data with Spring Data JPA

Mapping classes to tables with JPA entities, repositories that write the SQL for you, and a full create, read, update and delete API.

By BasithUpdated 26 October 202655 min

JPA
@Entity
@Id
repository
JpaRepository
H2

The book API from the last lesson forgets every book the moment it stops, because the books live in a list in memory. This lesson stores them in a database. You will not write a line of SQL: you describe a book once, as a class, declare an interface, and Spring Data JPA writes the SQL for you, while you watch it do so.

By the end of this lesson

Explain what JPA does: a class becomes a table, and an object becomes a row.
Write an entity with @Entity, @Id and @GeneratedValue, and say why it is a class and not a record.
Get a working repository from an interface that extends JpaRepository, including a query made from a method name.
Build the full create, read, update and delete API, with the right status codes.
Reject bad input with validation annotations and @Valid.

From before

SQL, MySQL and JDBC and creating and executing queries wrote tables, inserts and selects by hand. Your first web API built the controller and showed how Spring hands each class the objects it needs. This lesson joins the two.

JPA in one picture#

Java keeps data in objects; a relational database keeps it in tables. Copying between them by hand is what you did with JDBC: read each column of each row and build an object. An ORM (object-relational mapper) does that copying for you. JPA, the Jakarta Persistence API, is Java's standard for ORMs, Hibernate is the implementation Spring Boot uses, and Spring Data JPA sits on top and writes whole repositories for you.

Java	Database
The class `Book`	The table `book`
One `Book` object	One row
The field `title`	The column `title`
The field marked `@Id`	The primary key

Three new dependencies#

In Spring Initializr, add Spring Data JPA, Validation and H2 Database to the project, or add them to the pom.xml by hand. H2 is a database written in Java that runs inside your program, in memory, so there is nothing to install; it starts empty on every run. Spring Boot sees it on the classpath and connects to it with no settings at all.

pom.xml (added next to spring-boot-starter-webmvc)

read along

1<dependency>

2 <groupId>org.springframework.boot</groupId>

3 <artifactId>spring-boot-starter-data-jpa</artifactId>

4</dependency>

5<dependency>

6 <groupId>org.springframework.boot</groupId>

7 <artifactId>spring-boot-starter-validation</artifactId>

8</dependency>

9<dependency>

10 <groupId>com.h2database</groupId>

11 <artifactId>h2</artifactId>

12 <scope>runtime</scope>

13</dependency>

The entity#

An entity is a class whose objects are stored as rows. Book stops being a record and becomes a class:

Book.java

read along

1package com.example.library;

3import jakarta.persistence.Entity;

4import jakarta.persistence.GeneratedValue;

5import jakarta.persistence.Id;

7@Entity

8public class Book {

9 @Id

10 @GeneratedValue

11 private Long id;

12 private String title;

13 private String author;

15 protected Book() {

16 }

18 public Book(String title, String author) {

19 this.title = title;

20 this.author = author;

21 }

23 public Long getId() { return id; }

24 public String getTitle() { return title; }

25 public String getAuthor() { return author; }

26 public void setTitle(String title) { this.title = title; }

27 public void setAuthor(String author) { this.author = author; }

28}

@Entity says “store objects of this class in a table”. The table is named after the class, book, and each field becomes a column.
@Id marks the primary key, and @GeneratedValue lets the database choose it. It is a Long, not a long, so a new book that is not saved yet can have null as its id.
JPA builds objects when it reads rows, by calling a constructor with no arguments and then filling in the fields. That is why there is a protected Book(), and why an entity cannot be a record, whose fields never change.

The repository: an interface, and nothing else#

BookRepository.java

read along

1package com.example.library;

3import java.util.List;

4import org.springframework.data.jpa.repository.JpaRepository;

6public interface BookRepository extends JpaRepository<Book, Long> {

7 List<Book> findByAuthor(String author);

8}

You never write a class that implements this interface. When the program starts, Spring Data creates one, and it can be injected anywhere, like the BookService in the last lesson. JpaRepository<Book, Long> (a Book repository, with Long ids) brings the usual methods:

Method	Does
`findAll()`	Every book, as a List
`findById(id)`	The book, as an `Optional`, empty if there is none
`save(book)`	Inserts a new book (no id yet) or updates an existing one, and returns it with its id
`existsById(id)`, `count()`	Whether a book exists; how many there are
`deleteById(id)`	Removes the book

And findByAuthor? Spring Data reads the method's name: find, by, the field author. From that it writes a query with where author = ?. Names like findByTitleContaining or findByAuthorOrderByTitle work the same way. These are derived queries.

Key idea
Describe the data once as an entity, declare a repository interface, and Spring Data supplies the code and the SQL. You only write SQL for questions a method name cannot express.

The controller, now with a database#

The controller asks for a BookRepository instead of a BookService, and gains update and delete:

BookController.java

read along

1@RestController

2@RequestMapping("/books")

3public class BookController {

4 private final BookRepository books;

6 public BookController(BookRepository books) {

7 this.books = books;

8 }

10 @GetMapping

11 public List<Book> all(@RequestParam(required = false) String author) {

12 return author == null ? books.findAll() : books.findByAuthor(author);

13 }

15 @GetMapping("/{id}")

16 public ResponseEntity<Book> one(@PathVariable long id) {

17 return books.findById(id)

18 .map(ResponseEntity::ok)

19 .orElse(ResponseEntity.notFound().build());

20 }

22 @PostMapping

23 public ResponseEntity<Book> add(@Valid @RequestBody NewBook request) {

24 Book saved = books.save(new Book(request.title(), request.author()));

25 return ResponseEntity.status(HttpStatus.CREATED).body(saved);

26 }

28 @PutMapping("/{id}")

29 public ResponseEntity<Book> update(@PathVariable long id, @Valid @RequestBody NewBook request) {

30 return books.findById(id)

31 .map(book -> {

32 book.setTitle(request.title());

33 book.setAuthor(request.author());

34 return ResponseEntity.ok(books.save(book));

35 })

36 .orElse(ResponseEntity.notFound().build());

37 }

39 @DeleteMapping("/{id}")

40 public ResponseEntity<Void> delete(@PathVariable long id) {

41 if (!books.existsById(id)) {

42 return ResponseEntity.notFound().build();

43 }

44 books.deleteById(id);

45 return ResponseEntity.noContent().build();

46 }

47}

Two books are added at start-up by a small CommandLineRunner, a bean whose code Spring runs once the application is ready:

LibraryApplication.java (added inside the class)

read along

1@Bean

2CommandLineRunner seed(BookRepository books) {

3 return args -> {

4 books.save(new Book("Dune", "Frank Herbert"));

5 books.save(new Book("Emma", "Jane Austen"));

6 };

7}

Running it, and watching the SQL#

Add spring.jpa.show-sql=true to application.properties and Hibernate prints every SQL statement it sends. At start-up it builds the table from the entity:

Terminal (the SQL lines from the start-up log)

read along

1$ mvn spring-boot:run

2...

3Hibernate: drop table if exists book cascade

4Hibernate: drop sequence if exists book_seq

5Hibernate: create sequence book_seq start with 1 increment by 50

6Hibernate: create table book (id bigint not null, author varchar(255), title varchar(255), primary key (id))

7...

2026-10-19T15:55:44.645+03:00  INFO 59412 --- [library] [           main] com.example.library.LibraryApplication   : Started LibraryApplication in 4.556 seconds (process running for 5.106)

9Hibernate: select next value for book_seq

10Hibernate: insert into book (author,title,id) values (?,?,?)

11Hibernate: select next value for book_seq

12Hibernate: insert into book (author,title,id) values (?,?,?)

Hibernate made a book table with a column per field, and a sequence that hands out ids. The two inserts are the seed books. The question marks are the placeholders from JDBC: the values travel separately, so they are safe from SQL injection. Now the requests, each followed by the SQL it caused:

Terminal

read along

1$ curl http://localhost:8080/books

2[{"title":"Dune","author":"Frank Herbert","id":1},{"title":"Emma","author":"Jane Austen","id":2}]

3 Hibernate: select b1_0.id,b1_0.author,b1_0.title from book b1_0

5$ curl "http://localhost:8080/books?author=Jane%20Austen"

6[{"title":"Emma","author":"Jane Austen","id":2}]

7 Hibernate: select b1_0.id,b1_0.author,b1_0.title from book b1_0 where b1_0.author=?

9$ curl -i -X POST http://localhost:8080/books -H "Content-Type: application/json" \

10 -d '{"title": "Solaris", "author": "Stanislaw Lem"}'

11HTTP/1.1 201

12Content-Type: application/json

14{"title":"Solaris","author":"Stanislaw Lem","id":3}

15 Hibernate: insert into book (author,title,id) values (?,?,?)

17$ curl -X PUT http://localhost:8080/books/2 -H "Content-Type: application/json" \

18 -d '{"title": "Persuasion", "author": "Jane Austen"}'

19{"title":"Persuasion","author":"Jane Austen","id":2}

21$ curl -i -X DELETE http://localhost:8080/books/1

22HTTP/1.1 204

23 Hibernate: select count(*) from book b1_0 where b1_0.id=?

24 Hibernate: select b1_0.id,b1_0.author,b1_0.title from book b1_0 where b1_0.id=?

25 Hibernate: delete from book where id=?

27$ curl http://localhost:8080/books

28[{"title":"Persuasion","author":"Jane Austen","id":2},{"title":"Solaris","author":"Stanislaw Lem","id":3}]

(The indented Hibernate:lines appeared in the server's terminal, not in curl's; they are placed under each request here to pair them up.) findByAuthor really became where author=?. The JSON is built from the entity's getters: getTitle, getAuthor and getId become title, author and id. DELETE answers 204 No Content, success with nothing to send back, and /books/1 is now a 404.

An in-memory database forgets too

H2 in memory starts empty every time, which is ideal for learning and for tests. To keep data between runs, a real application points Spring at a database server such as PostgreSQL or MySQL: swap the H2 dependency for that database's driver and set spring.datasource.url, spring.datasource.username and spring.datasource.password in application.properties (with the password kept out of the file in practice). The entity, repository and controller do not change.

Refusing bad input#

Without checks, a client could add a book with an empty title. The validation starter adds annotations that state the rules on the data itself:

NewBook.java

read along

1package com.example.library;

3import jakarta.validation.constraints.NotBlank;

5public record NewBook(@NotBlank String title, @NotBlank String author) {

6}

@NotBlank means not null and not just spaces. Other common ones are @NotNull, @Size(max = 200), @Min(0) and @Email. The rules are only checked where a parameter is marked @Valid, as in add and update above. A request that breaks one never reaches your method:

Terminal

read along

1$ curl -i -X POST http://localhost:8080/books -H "Content-Type: application/json" \

2 -d '{"title": "", "author": "Nobody"}'

3HTTP/1.1 400

4Content-Type: application/json

5...

7{"timestamp":"2026-10-19T12:55:58.021Z","status":400,"error":"Bad Request","path":"/books"}

Quick check

Which method does JpaRepository NOT give you for free, so that you must declare it yourself?

Quick check

Why can't Book stay a record once it is an @Entity?

Try it

Answer each one in your head or on paper first, then open the answer.

Write the repository method for “every book whose title contains some text, ignoring case”, and the controller line that would call it.

save both inserts and updates. How does it know which to do?

A client sends PUT /books/2 with {"title": " ", "author": "Jane Austen"}. What does it get back, and does the database change?

Practice

Work through these on your own. Each one builds on this page.

Add a year field to Book (and to NewBook, with @Min(0)), and a derived query that lists books published after a given year, newest first. Test it with curl, and read the SQL Hibernate prints for it.

Add a second entity, Member, with its own repository and controller at /members. Then add POST /books/{id}/borrow that records which member has a book. Think first about where that information should live, as the console app project did with its loans.

Set spring.jpa.show-sql=false and instead set the log level of org.hibernate.SQL to DEBUG in application.properties. What changes in how the SQL is printed, and why would a team prefer that version?

Short guides on this topic

Quick answers to what people search for about it, with code to run.

How to Build a Web Application with Spring BootBuild a small Spring Boot web application step by step: create the project, add a controller, return a web page and JSON, and run it on its built-in server.12 min

Spotted a mistake, or a part that did not make sense? Report it by email

Saving data with Spring Data JPA

JPA in one picture#

Three new dependencies#

The entity#

The repository: an interface, and nothing else#

The controller, now with a database#

Running it, and watching the SQL#

Refusing bad input#

Try it

Practice

Further reading#

Short guides on this topic