Skip to content

Backend Java, in four books.

Learn the language, build a REST API with Spring Boot, test it, then split it into services. Read the books in this order: each one assumes the ones before it.

  1. 1Core Java52
  2. 2Spring Boot44
  3. 3JUnit & Mockito19
  4. 4Microservices23
Read them in order, 1 to 4. Each spine is as thick as its book: 138 chapters, about 25 hours in all. The light band fills as you tick chapters.

Core Java

Eleven modules: how a program runs, objects and types, memory, collections, streams, concurrency, I/O and the modern language features up to Java 21. Everything else is written in Java, so this book comes first, even if you already know another language.

  1. 1The Java Machine
  2. 2Object-Oriented Design & Type System
  3. 3Methods, Constructors & Memory
  4. 4Class Design Patterns & Abstractions
  5. 5Metaprogramming & Error Handling
  6. 6The Collections Framework
  7. 7Streams & Functional Pipelines
  8. 8Concurrency & Multithreading
  9. 9Productivity & Developer Tooling
  10. 10High-Performance I/O & NIO
  11. 11Modern Java Evolution (Java 14–21)

Spring Boot

Nine modules, from a first REST API to a secured one ready for production. Most Java backends run on Spring Boot. It leans on what book 1 teaches: interfaces, annotations, collections, threads.

  1. 1Getting Started
  2. 2Controllers
  3. 3Beans & Dependency Injection
  4. 4Configuration
  5. 5AOP, Transactions & Async
  6. 6Handling Requests & Responses
  7. 7Data Access with JPA
  8. 8Security
  9. 9Production Readiness

JUnit 5 & Mockito

Nine modules: JUnit 5 first, from the first assertion to parameterized and dynamic tests, then mocking with Mockito. It needs only book 1, but reads best here: you test the kind of service code book 2 has you write, before book 4 splits it apart.

  1. 1Foundations
  2. 2Writing Tests
  3. 3Extending JUnit
  4. 4Repeated & Parameterized Tests
  5. 5Assumptions & Selecting Tests
  6. 6Dynamic Tests
  7. 7Mockito Fundamentals
  8. 8Mockito with JUnit 5
  9. 9Stubbing & Verification

Microservices

Eight modules: service calls, discovery, load balancing, fault tolerance, the API gateway, central configuration, tracing, logging and scheduled jobs on many instances. It splits one Spring Boot application into many, so it assumes books 2 and 3.

  1. 1Service-to-Service Calls
  2. 2Discovery & Load Balancing
  3. 3Fault Tolerance
  4. 4API Gateway
  5. 5Centralized Configuration
  6. 6Distributed Tracing
  7. 7Distributed Logging
  8. 8Distributed Scheduling

How the notes are made

Checked, not copied

Key claims are tested: Java on JDK 25 and against the Java Language Specification, Spring on Spring Boot 3 and Spring Cloud with real servers and brokers, tests on JUnit 5.13 and Mockito 5. Where a common explanation is wrong, the chapter states the correct behaviour.

Short and in order

Each chapter covers one topic and assumes only the chapters before it. Code comes as small listings you can run.

Check yourself

Every chapter ends with a few questions. The answers stay hidden until you open them.