Software Architecture with Spring (Wanderson Xesquevixos)（Z-Library）

【One-Line Pitch】 A practical, case-study-driven guide to designing scalable Java systems with Spring 6, following one online-auction application as it evolves from monolith to microservices and beyond. Best for experienced Java engineers stepping toward architect roles, or working architects who want a structured tour of modern Spring-based architecture styles. 【Book Arc】 - **Opening (~0%–15%)**: Establishes architecture fundamentals — what architecture is versus design, the architect's role, coupling/cohesion, SOLID and KISS/DRY/YAGNI, plus a survey of architectural styles and the CAP theorem for database selection. - **Early (~15%–30%)**: Moves into concrete styles using the running online-auction case study: monolithic (layered, MVC, Spring Security, testing), client-server (REST, token auth, OpenAPI, coverage), and microservices (DDD, bounded contexts, synchronous communication, Actuator). - **Middle (~30%–50%)**: Covers event-driven architecture with Kafka (pub-sub, outbox/inbox, saga), pipe-and-filter with Spring Batch, and serverless FaaS via Spring Cloud Function on AWS, then pivots to advanced topics: security (OAuth2/OIDC, OWASP) and observability (logs, metrics, traces, OpenTelemetry). - **Late (~50%–80%)**: Deepens engineering practice — testing (pyramid, Testcontainers, TDD/BDD), performance and optimization (JVM/GC tuning, caching, Spring WebFlux reactive programming), and orchestration with Kubernetes. - **Ending (~80%–100%)**: Closes with CI/CD — building pipelines with Jenkinsfile, environment setup, and deployment automation, tying the architecture journey into a delivery workflow. 【Key Takeaways】 - **Architecture is a decision discipline, not just a diagram** (Opening): the book frames architecture as trade-offs aligned to business goals, with ATAM and ADRs as tools for documenting and defending choices. - **Coupling and cohesion are the levers you actually control** (Opening): SOLID, KISS, DRY, YAGNI, and the Law of Demeter are presented as practical guides for keeping modules cohesive and loosely coupled. - **One case study carries the whole book** (Early–Ending): the online-auction app is refactored repeatedly across styles, so concepts are shown as evolving decisions rather than isolated theory. - **Style choice is contextual, not hierarchical** (Early): monolith, client-server, microservices, event-driven, serverless, and pipe-and-filter each get benefits and drawbacks — the book avoids declaring one universally superior. - **Domain-driven design underpins the microservices transition** (Early): bounded contexts and database-per-service choices drive how the monolith is decomposed, with synchronous communication and coupling trade-offs discussed explicitly. - **Security and observability belong in the design, not the afterthought** (Middle): OAuth2/OIDC, OWASP concerns, and logs/metrics/traces with OpenTelemetry and Zipkin are treated as first-class architectural concerns. - **Performance work is concrete and JVM-level** (Late): heap sizing, garbage collector tuning, caching, and reactive programming with Spring WebFlux are the levers offered for latency and throughput. - **Delivery completes the architecture** (Ending): Kubernetes orchestration and Jenkins-based CI/CD show how designed systems actually reach production. 【Reading Tips】 - Read Part 1 (foundations, decisions, system context) carefully even if you know Spring — it sets the vocabulary the case study relies on. - Treat the online-auction case study as the spine: skim repeated setup/code scaffolding, but slow down where the architecture is being refactored, since that is where the reasoning lives. - If you are already comfortable with monoliths and REST, you can move faster through the early style chapters and deep-read the microservices, event-driven, and DDD sections. - The advanced chapters (security, observability, performance, Kubernetes, CI/CD) are largely self-contained — use them as targeted references when a project needs them. - Keep the trade-off framing in mind: the value is in *why* a style fits a context, not in memorizing configurations. 【Coverage Limits】 This guide is synthesized from stratified excerpts (front matter, table of contents, preface, and selected chapters); detailed code walkthroughs and later chapter internals are only partially represented, so specific implementation steps are not summarized here.