Share E-Book
Scan to open this page

Scan with your phone to open this page

Author: Chris Richardson

Rating No ratings yet

Microservices Patterns teaches enterprise developers and architects how to build applications with the microservice architecture. Rather than simply advocating for the use the microservice architecture, this clearly-written guide takes a balanced, pragmatic approach, exploring both the benefits and drawbacks. About the Technology Successfully developing microservices-based applications requires mastering a new set of architectural insights and practices. In this unique book, microservice architecture pioneer and Java Champion Chris Richardson collects, catalogues, and explains 44 patterns that solve problems such as service decomposition, transaction management, querying, and inter-service communication. About the Book Microservices Patterns teaches you how to develop and deploy production-quality microservices-based applications. This invaluable set of design patterns builds on decades of distributed system experience, adding new patterns for writing services and composing them into systems that scale and perform reliably under real-world conditions. More than just a patterns catalog, this practical guide offers experience-driven advice to help you design, implement, test, and deploy your microservices-based application. What's inside • How (and why!) to use the microservice architecture • Service decomposition strategies • Transaction management and querying patterns • Effective testing strategies • Deployment patterns including containers and serverlessices About the Reader Written for enterprise developers familiar with standard enterprise application architecture. Examples are in Java. About the Author Chris Richardson is a Java Champion, a JavaOne rock star, author of Manning's POJOs in Action, and creator of the original CloudFoundry.com.

AI Reading Assistant

Whole-book reading guide from stratified index samples; jump to passages in the text

AI guide
【One-Line Pitch】 A balanced, pattern-driven guide to designing and operating microservice applications, showing not just how but also when and why to adopt the architecture. Best for enterprise developers and architects with Java experience who want production-grade guidance rather than hype. 【Book Arc】 - **Opening (~0%–10%)**: Diagnoses "monolithic hell" through the FTGO case study — slow deployments, painful scaling, poor fault isolation, and technology lock-in — establishing the concrete problems microservices are meant to solve. - **Early (~10%–30%)**: Introduces the microservice architecture pattern and its trade-offs, then moves into decomposition: organizing services by business capability or DDD subdomains, and untangling data using bounded contexts. - **Early–Middle (~30%–50%)**: Covers inter-service communication — synchronous RPI (REST, gRPC) versus asynchronous messaging, API definition, partial failure, and the Circuit breaker pattern. - **Middle (~50%–70%)**: Tackles distributed data management: transaction management across services, event-driven sagas, and querying patterns for data spread across multiple services. - **Late (~70%–85%)**: Addresses testing strategies for services and deployment patterns, including containers and serverless. - **Ending (~85%–100%)**: Consolidates the 44-pattern catalog and experience-driven advice for designing, implementing, and deploying a complete microservices-based application. 【Key Takeaways】 - **Microservices are a trade-off, not a default** (Opening): The book is deliberately balanced, weighing benefits like independent deployability against the costs of distributed systems, so you can judge fit rather than adopt blindly. - **Decomposition is an art guided by strategy** (Early): Two main approaches — Decompose by business capability and Decompose by subdomain — plus DDD bounded contexts help you draw service boundaries around business, not technical, concepts. - **Services must be loosely coupled via APIs, never shared databases** (Early): Treating a service's persistent data as private is what enables independent schema evolution and maintainability. - **Synchronous communication carries partial-failure risk** (Middle): Because clients and services aren't compiled together, incompatible APIs cause runtime failures; the Circuit breaker pattern is the key mitigation. - **Asynchronous messaging improves availability but adds complexity** (Middle): Message channels, at-least-once delivery, duplicate handling, and sharded channels for ordering are recurring concerns. - **Distributed transactions require sagas, not two-phase commit** (Middle): Managing data consistency across services and querying scattered data are among the hardest problems the patterns address. - **Testing and deployment deserve first-class patterns** (Late): Effective testing strategies and deployment approaches like containers and serverless are treated as core architecture concerns, not afterthoughts. - **The catalog spans three layers** (Early): Infrastructure, application infrastructure, and application patterns are grouped by the kind of problem they solve. 【Reading Tips】 - **Deep-read the decomposition and communication chapters** (Early–Middle): These establish the vocabulary and decisions that every later pattern depends on. - **Skim the FTGO narrative in the opening** if you already know monolith pain points — extract the problem framing, then move on. - **Treat the pattern catalog as reference**: Read the grouped overview early, then return to individual patterns when a real design problem arises. - **Pause on partial failure, sagas, and duplicate messaging** (Middle): These are the hardest spots; the book's Java examples reward close reading. - **Take away the decision framework**, not just the patterns — the book's value is knowing when each pattern applies. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering roughly the first half of the book in detail; later chapters on testing, deployment, and the full pattern catalog are described only at a high level, so specific patterns there are not covered.
Page 19
chardson M A N N I N G preface One of my favorite quotes is The future is already here—it’s just not very evenly distributed. —William Gibson, science fictio...
View in text
Excerpt 2
edecessor Successor Decompose by Figure 1.11 There are two business capability decomposition patterns: Decompose Alternative A Alternative B by business capa...
View in text
Excerpt 3
ss orders use this library and access the access data- base. The trouble with this approach is that it violates one of the key principles of the microservice...
View in text
Excerpt 4
the same shard, which is read by a single consumer instance. As a result, these messages are guaranteed to be processed in order. 3.3.6 Handling duplicate me...
View in text
Excerpt 5
ributes the imple- mentation of the saga among the services. Consequently, it’s sometimes difficult for a developer to understand how a given saga works. Cyc...
View in text
Excerpt 6
different from traditional object modeling, which considers foreign keys in the domain model to be a design smell. It has a number of benefits. The use of id...
View in text
Excerpt 7
) { to REVISION_PENDING. this.state = REVISION_PENDING; } Developing business logic using event sourcing 201EVOLVING EVENTS CAN BE TRICKY With event sourcing...
View in text
Excerpt 8
anagement challenge in a microservice architecture: queries. I’ll describe how to implement queries that retrieve data scattered across multiple services. Su...
View in text
Tags
AI categories
SoftwareBackendProgramming
ISBN: 1617294543
Publish Year: 2018
Language: English
Pages: 520
File Format: PDF
File Size: 7.6 MB
Text Preview (First 20 pages)
Registered users can read the full content for free

Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.

Generating text preview…