book

Spring System Design in Practice

Name: Spring System Design in Practice
Author: Rodrigo Santiago
ISBN: 9781803249018

by Rodrigo Santiago

May 2025

Beginner to intermediate

456 pages

12h 12m

English

Packt Publishing

Read now

Unlock full access

Spring System Design in Practice
Foreword
Contributors
About the author
About the reviewer
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchShare your thoughtsFree Benefits with Your Book
Part 1: Foundations for System Design
Chapter 1: What are the Product Requirements?
Unlocking your finances with the Spring FrameworkHow is this book structured to help you succeed?Why do we need to understand business requirements?Perfecting business requirementsWhat are business requirements?Crystal-clear needs – ensuring businesses get requirements rightVisualizing timelines for problem-solvingCrafting business requirementsThe pitfalls of product requirementsAre mock designs business requirements?Requirements should not express technology choicesDoes a customer know the problems they are experiencing?Are solutions the final step?Breaking the curse of technical debtDense documentationVague documentationLooking beyond the happy pathDisregarding other business areas and processesAssuming too much about other areasSummary
Chapter 2: Sorting Complex Requirements into Features, Use Cases, and Stories
Naming the distinct features of your productIdentifying actors, events, life cycles, stages, types, levels, and loopsWho will perform actions in your system?Defining critical events for each actorListing the main features of the systemExtracting a feature’s events timelineSimplifying requirementsUnderstanding stages, levels, types, life cycles, and loopsCreating user journeys, stories, and use casesUser journeysUser storiesUse cases descriptionsStructuring the final business requirements documentWhich of these artifacts should come first?Scaling results with long-term business requirementsExercisesSummary
Chapter 3: Defining Domains for Your Application
Technical requirementsDetermining which features to deliver firstCriteria for prioritizing a business requirementSorting prioritiesDefining domains and boundaries for your applicationWhat are product domains and why are they important?Detecting common concepts and eliminating redundancy across use casesSetting up and defining domains for your productSetting up domain composition, boundaries, and limitsDefining the right services for your domainsWhat are services and why should we think about them?How to model and document domain services correctlyCrafting your domain diagramSequencing the activity across servicesThe Rental Proposal sequence diagramIntroduction to PlantUML as a tool for building sequence diagramsSummary
Chapter 4: Defining Services for Your Domains
Understanding non-functional requirementsHandling user requirementsI/O and data maintenance requirementsExploring sizing requirementsStorage typesRequirements for data processingTesting requirementsAI, data engineering, and analytics requirementsDisaster recovery capabilitiesChoosing protocolsSummary

Part 2: Designing Great Spring Services
Chapter 5: Writing Your Services – Introducing REST APIs with the Spring Framework
Technical requirementsMoving from domain design to programmingMicroservice communicationIntroducing the HTTP protocolWhat are the main HTTP verbs?What are the main HTTP response codes?Writing your first Spring appUsing SDKMAN to manage your tool versionsUsing Spring InitializrOpening your Spring projectBuilding your application using GradleImplementing your first Spring Controller classRunning your Spring ApplicationDesigning your API servicesWhat are APIs?Why do we need RESTful standards?Dissecting a RESTful resource addressAdding parameters to your API endpointsUsing payloads in RESTful servicesUsing UUIDs to uniquely identify objectsUsing HTTP request headersHow Spring apps run internallyIntroducing the Spring Framework component lifecycleWhat are Spring beans and why are they important?Introducing the Spring Boot projectUnderstanding the Spring Framework component scanWhere are Spring beans stored at runtime?How to easily access a Spring beanSpring container and inversion of controlCreating RESTful APIs in SpringWriting a rental property REST API with Spring WebSpring Web cheat sheetSummary
Chapter 6: Translating Business Requirements into Well-Designed Spring APIs
Technical requirementsMastering the blueprint for any Spring microserviceExploring the vertical layersUnderstanding the horizontal layersRental proposal service designError handling in REST APIsImplementing business services in SpringDeclaring service interfaces in SpringWriting the implementation class for your serviceOrganizing your Spring classesWriting automated tests for your Spring appsUnderstanding the basic test patternCreating integrated tests with Spring TestTesting Beans in isolationOther testing optionsComing up with a test case listPerfecting the application tests over timeRunning your tests in the consoleTuning Spring Web for peak performanceMaking your API design a lot better for clientsRichardson Maturity Model for creating/documenting REST APIsSummary
Chapter 7: Handling Data and Evolving Your Microservice
Technical requirementsData persistence in applications with SpringReactive versus non-reactive data handlingNon-reactive data handlingReactive data handlingSQL versus NoSQL data storageSQL databasesNoSQL databasesMicroservices versus monolith application data designData complexity and granularity levelOrganizing databasesImplementing non-reactive SQL database persistenceAdding support to a dev databaseDefining entities to be persistedORM versus raw SQL in Spring DataJpaRepository – your go-to SQL interface in Spring DataUsing JpaRepository as an ORM-enabled repositoryUsing Lombok to translate DTO to entity classes and vice versaJpaRepository class hierarchy made simpleCustomizing database queries using JpaRepositoryUsing JPQL to create custom queriesUnderstanding other limitations of JpaRepositoryDealing with a very high volume of data and requestsRetrieving paged results in Spring JpaRepositoryUsing multiple service implementations on your applicationUsing @Qualifier to inject multiple bean implementations for the same serviceHow does EntityManager work?Working with transactions in Spring DataUsing the @Transactional annotation in a methodManaging transactions by using the EntityManager beanUsing NamedParameterJdbcTemplate to run raw SQL queriesReferencing all the implementations we have done so farTesting your applications with data integrationSummary
Part 3: Security, Performance, and Scalability
Chapter 8: Securing Services with Spring Security and OAuth 2.0
Understanding the security areas in your applicationWhat is OAuth 2.0 and why use it?Use case 1 – system A accesses system B-owned resourcesUse case 2 – system A accesses its own resourcesBasic service types in OAuth 2.0Industry-grade authorization providersUnderstanding how JWTs workThe JWT headerThe JWT payloadThe JWT signatureDifferent architectures for validating tokensImplementing HomeIt securityCreating your projectCreating your security configuration classAdding Spring Security to the Rental Properties serviceImplementing and using refresh tokensSummary
Chapter 9: High-Performance Secure Communication Between Spring Services
Technical requirementsService communication made easyAdding more security to HomeIt authenticationWhat is RestAssured?Writing a high-performance service with WebFluxLooking at the Revoke Token Service folder structureWriting the Revoke Token Service properties fileWriting the database schema fileWriting the Revoke Token Service persistence layerReactive versus blocking servicesWriting the Revoke Token service classWriting a reactive endpoint Handler classWriting the RouterConfig and resource addressesWriting a customized Basic authorization filterConnecting services with API requestsAdding security filters to your authentication flowWriting API integration tests with RestAssuredCreating the project structureDeclaring dependenciesWriting the actual testsMaking the actual requests using RestAssuredSummary
Chapter 10: Building Asynchronous, Event-Driven Systems With NoSQL Databases
Technical requirementsA maintainability issue with RESTful APIsWhat is heavy coupling?How service coupling makes code harder to maintainIntroducing event-driven architecturesWhat is the difference between a queue and a topic?How should your notification messages look?Using Kafka in event-driven servicesKafka main conceptsInstalling Kafka on a Linux machineUsing MongoDB for NoSQL persistencyOur event-driven sample in HomeItBuilding our rental proposal service publishersCombining WebFlux, MongoDB, and Kafka in Spring ServicesStreaming object collections with WebFluxBuilding our rental properties service consumersExtending our end-to-end testsSummary
Part 4: Orchestrating Resilient Services
Chapter 11: Launching Your Self-Organizing Microservice Cloud
Technical requirementsHow to produce your service logsWhat are the existing log levels?How to write logs in SpringUnderstanding your log outputHow to organize your property filesWriting your properties filesOverriding a property file when starting the packaged applicationSetting property values using environment variablesCreating property files per deployment environmentInjecting properties in your servicesSetting up your services using Spring CloudUnderstanding the Spring Cloud topologyLaunching the Discovery serviceLaunching the Config serviceSetting up your property files on a Git repositoryIntegrating your services with Spring CloudLaunching the API Gateway serviceHitting the API gateway with our integration testsSummary
Chapter 12: Optimizing Your Services
Technical requirementsSetting the right performance expectations for your projectFailures are unavoidableLaunch early, optimize laterKey bottlenecks that can slow things downEliminate single points of failureDistributed transactions going wrongPrepare your services for concurrent requestsUsing caching to speed up access to critical dataRecovering from failures with dead letter queuesReal-time service monitoring with Spring ActuatorHandling faulty services with Resilience4jUsing the Circuit Breaker patternUsing the Rate Limiting patternUsing Retry in Resilience4JUsing the Bulkhead patternPreventing race conditions with a SQL trickWhy microservice-level solutions won’t workA simple and effective solution – database locksRecovering from failures by using an audit jobDealing with a surge of requests by using throttlingSummaryEpilogue
Chapter 13: Unlock Your Exclusive Benefits
Unlock this Book’s Free Benefits in 3 Easy StepsStep 1
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare your thoughts

Content preview from Spring System Design in Practice

Part 1: Foundations for System Design

Before writing a single line of code, we need to understand what we’re building. This part focuses on dissecting product requirements, organizing them into actionable development tasks, and structuring domain models that will form the backbone of our system. By the end of this part, you’ll have a clear path from abstract business needs to a concrete technical vision.

This part includes the following chapters:

Chapter 1, What are Product Requirements?
Chapter 2, Sorting Complex Requirements into Features, Use Cases, and Stories
Chapter 3, Defining Domains for Your Application
Chapter 4, Defining Services for Your Domains

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Design Microservices Architecture with Patterns and Principles

Publisher Resources

ISBN: 9781803249018

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Spring System Design in Practice

by Rodrigo Santiago

Part 1: Foundations for System Design

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.