Free through lesson 3

Spring Boot for Beginners

From setting up your environment through DI and configuration, validation, Spring Data JPA, transactions, testing, Thymeleaf and Spring Security, all the way to a production setup on PostgreSQL and Docker. Twenty lessons that build one task management app from the first line to the last. Every piece of code and every log line was produced by actually running Spring Boot 4.1.1 on Java 21.

Start from lesson 1 Unlock every course

Curriculum

The 20 lessons are grouped into five chapters. Working through them in order is the best way, but you are welcome to dip into whatever interests you. Note: Java cannot run inside the browser, so try everything in the project you create in lesson 1.

Chapter 1 — Getting started and web basics (lessons 1–5)

You take apart the eight-line main that boots Tomcat along with everything else, then bind URLs and methods to receive requests. By the end you can set the status and headers yourself with ResponseEntity.

Setting up and creating the project

Generating a skeleton with Spring Initializr and booting Tomcat and all from an eight-line main. Including what the parent, starters and plugin in pom.xml are doing.

Free

Taking @SpringBootApplication apart

Explaining why your new controller returns a 404, in terms of component scanning. Also using --debug to see why each auto-configuration applied.

Free

@RestController and routing

Returning a record gives you JSON. How the return type decides the Content-Type, and why a duplicate URL fails at start-up.

Free

Four ways to receive a request

Path variables, query parameters, bodies and headers, all through annotations on the arguments. Including why a boolean breaks a PATCH.

Responses and status codes

Deciding the status, headers and body with ResponseEntity. Writing "200 if present, 404 if not" in one line, and returning 201 with a Location on create.

Chapter 2 — Spring's core ideas and validating input (lessons 6–9)

You get to grips with the DI container at the heart of Spring, move configuration outside, and guard your input with annotations. Finally you standardise error responses on ProblemDetail so they are managed in one place.

DI and beans

Spring is a DI container at heart. Splitting into three layers, and four reasons not to put @Autowired on a field. Including how to resolve several beans of the same type.

Configuration files and profiles

Getting values that change per environment out of the code. Writing @ConfigurationProperties as a record and failing at start-up on a bad setting. The precedence order, confirmed by measurement.

Guarding input with Bean Validation

Replacing hand-written ifs with annotations. That forgetting @Valid lets everything through silently, and why POST and PATCH need separate DTOs.

Exception handling and ProblemDetail

Shaping error responses to RFC 9457 and centralising the conversion in @RestControllerAdvice. Including why an exception message must never reach a 500 response.

Chapter 3 — The database (lessons 10–14)

You store data with Spring Data JPA and cover DTOs, relationships, search and transactions. Both the N+1 problem and "@Transactional is not working" are confirmed by counting for real.

Getting started with Spring Data JPA

Starting from why a record cannot be an entity, then getting CRUD from nothing but extending JpaRepository. Including how an update happens without calling save.

Completing CRUD with a service layer and DTOs

Four reasons never to expose an entity, and separate types per purpose. The record comes back as a DTO, and JPA disappears from the controller.

Relationships and the N+1 problem

Starting from the fact that @ManyToOne defaults to EAGER, then counting the SQL statements to see the N+1. Three fixes: JOIN FETCH, @EntityGraph and projections.

Search, paging and sorting

Just putting Pageable in the signature gives you paging. Why you should not return a Page directly, two approaches to dynamic search, and why sort columns need a whitelist.

Transactions

@Transactional works through a proxy. Confirming, by watching the row counts, the four ways it silently stops working: self-invocation, checked exceptions and swallowed errors.

Chapter 4 — Tests, screens and authentication (lessons 15–17)

You write three layers of tests fastest-first, build screens with Thymeleaf, and add sign-in with Spring Security. The service layer you have built up to now is reused without changing a single line.

Writing tests (three layers, fastest first)

Do not start with @SpringBootTest. Comparing three layers with their run times: unit tests without Spring, the @WebMvcTest and @DataJpaTest slices, and the whole thing.

Building screens with Thymeleaf

Returning HTML without changing a line of the service layer. Why th:field, using PRG to prevent duplicate submissions, and separating the advice for the API from the one for the screens.

Authentication and authorisation with Spring Security

From the philosophy that adding the dependency protects everything, through writing a SecurityFilterChain, the ROLE_ prefix trap, and separating the API and screen chains.

Chapter 5 — Operations and deployment (lessons 18–20)

Logging and Actuator let you see inside the app from outside, and you swap H2 for PostgreSQL. Finally you package it as a Docker image so it runs anywhere else.

Logging and Actuator

Dropping System.out.println and attaching a request ID to every log line with MDC. Expose only the Actuator endpoints you need, and always put them behind authentication.

PostgreSQL, Docker Compose and Flyway

Swapping H2 for real PostgreSQL and managing the schema with Flyway. Including why a migration must never be edited once it has been applied.

Wrapping up: building and deploying

From what is inside an executable jar, through a layered Dockerfile, how the wrong ENTRYPOINT form breaks graceful shutdown, to a minimal CI setup.

Once you have finished all 20 lessons, learn to operate this app in containers with Docker. Membership unlocks every course.