Skip to content

Book Review: Microservices Patterns

Microservices Patterns

Microservice Patterns
With examples in Java

Chris Richardson

Microservice Patterns teaches enterprise developers and architects how to build applications with the microservice architecture. This book also teaches readers how to refactor a monolithic application to a microservice architecture.

Buy Now

Microservices and the related patterns have become a staple of most enterprise software architectures over the past decade or so, and during the transition period we have learned that there are definitely wrong ways and the right ways of implementing a Microservices based architecture style. With that being said, many organisations are also actively engaged in migrating their existing software stack from what is now termed as Monolithic Architectures to adopting and integrating Microservices architectures.

In my opinion, core reading for any developer trying to get familiar with Microservices should be Sam Newmans, Building Microservices and his follow up Monolith to Microservices because both of these books dive deep into the murky world of Microservices and provide a lot of the great insight, awareness and knowledge required to adopt the patterns.

Building Microservices

Designing Fine-Grained Systems

Microservice technologies are moving quickly. Author Sam Newman provides you with a firm grounding in the concepts while diving into current solutions for modeling, integrating, testing, deploying, and monitoring your own autonomous services.

Why I read this book

I am a predominantly Dotnet focused developer, and the majority of the work I undertake is predominantly focused around the C# & Dotnet Core based ecosystem. However, I do make it a habit of reading books, that are focused outside of that particular remit, because different ecosystems are solving the same problems so in particular I like to keep an eye on the Java and Rust ecosystems because these two ecosystems are very similar to Dotnet C# so I find its very easy to understand and follow along. With that in mind that why you’ll often find me reviewing books outside of the my particular area of focus. With this one primarily focused on Java for examples, but the concepts and domain in reality are common to all ecosystems.

Why I like this book

In many instances reading technology text books can be very dry reading, primarily because often its not a leisure based reading exercise and the many authors tend to stick to bombarding you facts, processes and knowledge without really focusing on making it an entertaining activity to indulge in.

This book actually takes a different tact, it starts of by creating a fictional story of Mary the CTO of FTGO an ecommerce food delivery company who are migrating from a Monolithic Architecture and implementing a Microservice Architecture. Which in in many respects follows the same formula as per the The Phoenix Project: A Novel about IT, DevOps, and Helping Your Business Win and the plethora of Devops related titles that followed it.

The first 3 chapters can be a treasure trove for all those, who are starting the process of getting into and understanding Microservice Architecture. The first chapter in particular introduces the concept of the Microservice architecture pattern language which is well worth learning and further research.

An interesting observation, is that the book also makes several references to a book I often reference too, Design Patterns : Elements of reusable object-Oriented Software

Design Patterns

Elements of Reusable Object-Oriented Software

23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves

Chapter 2 is also a treasure trove for those who are still getting familiar with microservices or involved in projects that are migrating from Monolithic architectures to microservices. I personally like this chapter if for nothing else is frank discussion on why layered architecture style is not suited to microservice development, a topic I have previously discussed in Why I don’t like layered architecture for microservices

What I learned from this book

Despite this book, being over 3+ years from when it was initially published, the information is still very highly relevant and in all probability will remain to be so for a long period of time. Primarily because this book is not tied to any specific technology or framework or anything that could date it from a technological perspective.

Despite the title full title in a somewhat misleading way says with examples in Java there were very few actually code examples and if they were they may as well have been in pseudo code because they were really easy to understand. There were the mentions to Java Frameworks like spring etc, but the features mentioned are also present in other frameworks that I am familiar with.

The book is also largely unopinionated on what technologies should be used and offers various options with their pros and cons. 

Topics dsicussed in great detail in this book relate to:

  • Application decomposition strategies.
  • Interprocess communication in microservices.
  • Managing transactions in microservices.
  • Domain-driven design as it applies to microservices.
  • Event sourcing in microservices.
  • Query patterns in microservices.
  • Testing strategies for microservices.
  • Productionizing microservices.
  • Deploying microservices.
  • Refactoring from monolith to microservice.

Why I recommend this book

This book will be more than worth your while reading, even if you are somewhat familiar with some microservice concepts. It is clear that the author through hos body of work and this book as invested a lot of time and effort to ensure we all benefit and learn from his experience.

Microservice Patterns

44 reusable patterns to develop and deploy reliable production-quality microservices-based applications.

Latest posts by Gary Woodfine (see all)