- Book’s contents
- The practical case study
- The Book’s ToC
- Book’s extra chapters
- Questions about the book
- Supporting the author
In 2017, I wrote the book Learn Microservices with Spring Boot (1st ed.). I got a lot of feedback since then. Some technologies used in the book have evolved or have been replaced by others. Besides, I learned new topics, and came up with better ideas to structure the contents of a new book.
The result of this revision is the book’s Second Edition, a book where I take you through the journey of building a microservice architecture from scratch, using best practices, and looking at it from a hands-on perspective.
You can buy the book from your favorite online or physical store. The ISBN-13 codes are 9781484261309 for the Paperback edition and 9781484261316 for the e-book version. Here are some links to popular online stores:
- Build microservices with Spring Boot using a 3-tier, 3-layer design.
- Learn about TDD techniques and what their benefits are.
- Compare synchronous vs. asynchronous communication to connect microservices. See how they relate to eventual consistency.
- Use an event-driven architecture. Implement resilience and scalability with RabbitMQ.
- Master service discovery with Consul and load balancing with Spring Cloud Load Balancer
- Route requests with Spring Cloud Gateway.
- Keep flexible configurations per environment with Spring Cloud Consul.
- Trace every request from beginning to end with Sleuth and centralized logging.
- Deploy your microservices anywhere as Docker containers with Buildpacks.
- Start all the components in the microservice architecture with Docker Compose.
- Learn how to achieve your non-functional requirements with practical case studies for scalability, fault-tolerance, retries, etc.
- As a side track, learn how to build simple frontend interfaces with React.
The full table of contents is included below. All the source code included in the book is also available on Github. The links to the repositories are next to the chapter’s titles in the table of contents.
The practical case study
All the contents in the book are presented around a practical case study, that evolves each chapter with the introduction of new concepts.
You start with a small monolith, looking at the best design practices, and you learn how Spring Boot works with real examples.
Then, you introduce a second microservice in the system, and study the differences between synchronous and asynchronous communication. That’s how you get to Event-Driven architectures. Once you enter into the world of microservices, you must learn the most important architecture patterns for distributed systems: Gateway, Service Discovery, Load Balancing, Resilience, Scalability, Distributed Tracing, etc.
The Book’s ToC
Here you can have a sneak peek at the Book’s Table of Contents:
- Setting the scene
- Who are you?
- How is this book different from others?
- Online Contents
- Core concepts
- Spring Boot
- Lombok and Java
- Testing basics: TDD, BDD, JUnit, Mockito, AssertJ
- Testing in Spring Boot
- A basic Spring Boot app (+ GitHub Repo)
- Business Requirements
- Setting up the development environment
- The Skeleton Web App
- Spring Boot Auto-Configuration (check the blog post)
- Three-tier, Three-layer Architecture
- Modeling our domain
- Business logic
- The Presentation Layer
- A minimal frontend with React (+ GitHub Repo)
- Quick intro to React and Node
- Setting up the development environment
- The React app skeleton
- The Challenge Component
- Running our frontend for the first time
- Adding CORS configuration
- Playing with the app
- Deploying the frontend
- The data layer (+ GitHub Repo)
- The Data Model
- Choosing a database
- Spring Boot Data JPA
- Storing users and attempts
- New APIs and UI
- Playing with the new feature
- Starting with Microservices (+ GitHub Repo)
- Intro: what happened until now
- The Small Monolith approach
- New requirements and Gamification
- When should we move to microservices?
- Why microservices?
- Architecture Overview
- Designing and implementing the new microservice
- Playing with the system
- Fault Tolerance
- The challenges ahead
- Event-Driven Architecture (+ GitHub Repo)
- Core Concepts
- Pros and Cons of Event-Driven
- Messaging Patterns
- Message Broker Protocols, Standards and Tools
- AMQP and RabbitMQ
- Setting up RabbitMQ
- Spring AMQP and Spring Boot
- Solution Design
- Analysis: happy flow, resilience, and scalability.
- Common Patterns in Microservice Architectures (+ GitHub Repo)
- End-to-End tests with Cucumber
- Online Guide (to be published)
Book’s extra chapters
For this second edition, I’m creating book extensions that give you extra insights on other topics not included in the book. Subscribe to the newsletter to get the latest posts and guides.
Questions about the book
Do you have questions about the book? Feel free to ask!
- For general questions about the book: please use Goodreads’ book page. Alternatively, you can post a comment on this page.
- Did you find any broken link? That may happen, please let me know via comment on this page, Goodreads, or Twitter.
- Questions about the source code? Are you stuck? Don’t worry, I can help. Just open an issue on the corresponding Github repository. Not sure where? Just use the last chapter’s issues page.
Supporting the author
Did you like the book? That’s great, I’m glad I helped you learn something new. If you want to help me spread the word and make this book reach more people, you can: