Spring System Design in Practice (Rodrigo Santiago)（Z-Library）

【One-Line Pitch】 A practical, architecture-first guide to building scalable Spring and Spring Boot services, taking you from raw business requirements through domain design, REST APIs, data persistence, security, and resilience. Best for developers who know some Java/Spring and want to think like a system designer rather than just a coder. 【Book Arc】 - **Opening (~0%–10%)**: Frames the whole project around the HomeIt sample app (landlords and tenants) and argues that good design starts with requirements, not code. It sets up the "why before how" mindset and previews the full chapter map. - **Early (~10%–36%)**: Covers requirements engineering and domain modeling — sorting complex requirements into features, use cases, and stories, then defining domains, boundaries, and services with DDD techniques and sequence diagrams (PlantUML). This solves the "what are we actually building?" problem before any Spring code appears. - **Early–Middle (~36%–52%)**: Moves into hands-on Spring: HTTP and REST fundamentals, your first Spring Boot app (SDKMAN, Initializr, Gradle), controllers, the bean lifecycle and component scan, then translating requirements into layered, well-tested APIs. - **Middle (~52%–62%)**: Tackles data persistence — SQL vs NoSQL, reactive vs non-reactive handling, JpaRepository, JPQL, EntityManager, transactions, paging, and testing with data integration. This is where services become real and stateful. - **Late (~62%–64%)**: Security and communication — OAuth 2.0, JWTs, Spring Security configuration, refresh tokens, and secure inter-service calls. The excerpts thin out here, so treat this stage as a pointer rather than a detailed map. - **Ending (~64%+)**: Operations and resilience — logging, property management, Spring Cloud (Discovery, Config, API Gateway), performance bottlenecks, caching, dead letter queues, Actuator, and Resilience4j patterns (Circuit Breaker, Rate Limiting, Retry, Bulkhead). Closes on failure recovery and throttling. 【Key Takeaways】 - **Requirements are the blueprint, not paperwork** (Early): The book insists that best practices begin at conceptualization; skipping clear requirements wastes time and money. It matters because most Spring tutorials start at the controller, while this one starts at the business problem. - **Domain-driven design drives service boundaries** (Early): Domains, boundaries, and service composition are defined before coding, using use cases and sequence diagrams. This is the book's core differentiator — architecture decisions precede implementation. - **Spring's internals explain its behavior** (Early–Middle): Bean lifecycle, component scan, the container, and inversion of control are covered so you understand where beans live at runtime. Useful for debugging and for designing cleanly decoupled services. - **Layered API design is a repeatable blueprint** (Middle): Vertical and horizontal layers, service interfaces, implementation classes, and class organization form a template you can reuse for any microservice. Pair this with the Richardson Maturity Model for API quality. - **Data handling is a design choice, not a default** (Middle): SQL vs NoSQL, reactive vs non-reactive, ORM vs raw SQL, and JpaRepository limits are all weighed. The book stresses paging for high-volume data and transaction management via `@Transactional` or EntityManager. - **Security is layered and token-based** (Late): OAuth 2.0 flows, JWT structure (header, payload, signature), token validation architectures, and refresh tokens are framed around real use cases. Excerpts do not cover the full implementation detail. - **Failures are unavoidable — design for them** (Ending): "Launch early, optimize later," eliminate single points of failure, and use Resilience4j patterns plus dead letter queues. The book also offers a database-lock trick for race conditions when microservice-level fixes won't work. - **Spring Cloud ties services together** (Ending): Discovery, Config (backed by Git), and API Gateway form the operational topology. This is the glue that makes a microservice fleet manageable. 【Reading Tips】 - **Deep-read Parts 1–2 (requirements through data)**: This is the book's real value and the part most Spring resources skip. Skim the tooling setup (SDKMAN, Initializr, Gradle) if you're already comfortable. - **Follow the HomeIt app end to end**: The sample application threads through every chapter; building it yourself cements the design decisions far better than reading alone. - **Treat security and resilience chapters as checklists**: The excerpts are thin here, so use them to identify what you need (JWT validation, circuit breakers, throttling) and consult the code repository for specifics. - **Keep the GitHub repo open**: The book explicitly points to example code; copying from it avoids transcription errors and lets you focus on the architecture narrative. - **Note the Spring 7 caveat**: The author states the design concepts are largely framework-agnostic, so don't worry if your Spring version differs. 【Coverage Limits】 The excerpts are heavily front-loaded: requirements, domain design, and data chapters are well represented, while security, Spring Cloud, and resilience content appears mostly as chapter outlines. Detailed implementation guidance for those later topics is not covered here.