Learn Microservices with Spring Boot: A Practical Approach to RESTful Services Using an Event-Driven Architecture, Cloud-Native Patterns, and Containerization

Table of Contents
About the Author
About the Technical Reviewers
Chapter 1: Setting the Scene
	Who Are You?
	How Is This Book Different from Other Books and Guides?
		Learning: An Incremental Process
		Is This a Guide or a Book?
	From Basics to Advanced Topics
		Skeleton with Spring Boot, the Professional Way
		Test-Driven Development
		Microservices
		Event-Driven System
		Nonfunctional Requirements
	Online Content
	Summary
Chapter 2: Basic Concepts
	Spring
	Spring Boot
	Lombok and Java
	Testing Basics
		Test-Driven Development
		Behavior-Driven Development
		JUnit
		Mockito
		AssertJ
	Testing in Spring Boot
	Logging
	Summary and Achievements
Chapter 3: A Basic Spring Boot Application
	Setting Up the Development Environment
	The Skeleton Web App
	Spring Boot Autoconfiguration
	Three-Tier, Three-Layer Architecture
	Modeling Our Domain
		Domain Definition and Domain-Driven Design
		Domain Classes
	Business Logic
		What We Need
		Random Challenges
		Attempt Verification
	Presentation Layer
		REST
		REST APIs with Spring Boot
		Designing Our APIs
		Our First Controller
		How Automatic Serialization Works
		Testing Controllers with Spring Boot
			Valid Attempt Test
			Validating Data in Controllers
	Summary and Achievements
Chapter 4: A Minimal Front End with React
	A Quick Intro to React and Node
	Setting Up the Development Environment
	The React Skeleton
	A JavaScript Client
	The Challenge Component
		The Main Structure of a Component
		Rendering
		Integration with the App
	Running Our Front End for the First Time
	Debugging
	Adding CORS Configuration to the Spring Boot App
	Playing with the Application
	Deploying the React App
	Summary and Achievements
Chapter 5: The Data Layer
	The Data Model
	Choosing a Database
		SQL vs. NoSQL
		H2, Hibernate, and JPA
	Spring Boot Data JPA
		Dependencies and Autoconfiguration
		Spring Boot Data JPA Technology Stack
		Data Source (Auto)configuration
	Entities
	Repositories
	Storing Users and Attempts
	Displaying Last Attempts
		Service Layer
		Controller Layer
		User Interface
	Playing with the New Feature
	Summary and Achievements
Chapter 6: Starting with Microservices
	The Small Monolith Approach
	Why a Small Monolith?
		The Problems with Microservices from Day Zero
		Small Monoliths Are for Small Teams
		Embracing Refactoring
	Planning the Small Monolith for a Future Split
	New Requirements and Gamification
		Gamification: Points, Badges, and Leaderboards
	Moving to Microservices
		Independent Workflows
		Horizontal Scalability
		Fine-Grained Nonfunctional Requirements
		Other Advantages
		Disadvantages
	Architecture Overview
	Designing and Implementing the New Service
		Interfaces
		The Spring Boot Skeleton for Gamification
		Domain
		Service
		Data
		Controller
		Configuration
		Changes in Multiplication Microservice
		UI
	Playing with the System
	Fault Tolerance
	The Challenges Ahead
		Tight Coupling
		Synchronous Interfaces vs. Eventual Consistency
		Transactions
		API Exposure
	Summary and Achievements
Chapter 7: Event-Driven Architectures
	Core Concepts
		The Message Broker
		Events and Messages
		Thinking in Events
		Asynchronous Messaging
		Reactive Systems
	Pros and Cons of Going Event-Driven
	Messaging Patterns
		Publish-Subscribe
		Work Queues
		Filtering
		Data Durability
	Message Broker Protocols, Standards, and Tools
	AMQP and RabbitMQ
		Overall Description
		Exchange Types and Routing
		Message Acknowledgments and Rejection
	Setting Up RabbitMQ
	Spring AMQP and Spring Boot
	Solution Design
		Adding the AMQP Starter
		Event Publishing from Multiplication
		Gamification as a Subscriber
	Analysis of Scenarios
		Happy Flow
		Gamification Becomes Unavailable
		The Message Broker Becomes Unavailable
		Transactionality
		Scaling Up Microservices
	Summary and Achievements
Chapter 8: Common Patterns in Microservice Architectures
	Gateway
		Spring Cloud Gateway
		The Gateway Microservice
		Changes in Other Projects
		Running the Gateway Microservice
		Next Steps
	Health
		Spring Boot Actuator
		Including Actuator in Our Microservices
	Service Discovery and Load Balancing
		Consul
		Spring Cloud Consul
		Spring Cloud Load Balancer
		Service Discovery and Load Balancing in the Gateway
		Playing with Service Discovery and Load Balancing
	Configuration per Environment
		Configuration in Consul
		Spring Cloud Consul Config
		Implementing Centralized Configuration
		Centralized Configuration in Practice
	Centralized Logs
		Log Aggregation Pattern
		A simple Solution for Log Centralization
		Consuming Logs and Printing Them
	Distributed Tracing
		Spring Cloud Sleuth
		Implementing Distributed Tracing
	Containerization
		Docker
		Spring Boot and Buildpacks
		Running Our System in Docker
		Dockerizing Microservices
		Dockerizing the UI
		Dockerizing the Configuration Importer
		Docker Compose
		Scaling Up the System with Docker
		Sharing Docker Images
	Platforms and Cloud-Native Microservices
		Container Platforms
		Application Platforms
		Cloud Providers
		Making a Decision
		Cloud-Native Microservices
	Conclusions
Afterword
Index