Get Your Hands Dirty on Clean Architecture: A hands-on guide to creating clean web applications with code examples in Java

by Tom Hombergs

Gain insight into how hexagonal architecture can help to keep the cost of development low over the complete lifetime of an application We would all like to build software architecture that yields adaptable and flexible software with low development costs. But, unreasonable deadlines and shortcuts make it very hard to create such an architecture. Get Your Hands Dirty on Clean Architecture starts with a discussion about the conventional layered architecture style and its disadvantages. It also talks about the advantages of the domain-centric architecture styles of Robert C. Martin's Clean Architecture and Alistair Cockburn's Hexagonal Architecture. Then, the book dives into hands-on chapters that show you how to manifest a hexagonal architecture in actual code. You'll learn in detail about different mapping strategies between the layers of a hexagonal architecture and see how to assemble the architecture elements into an application. The later chapters demonstrate how to enforce architecture boundaries. You'll also learn what shortcuts produce what types of technical debt and how, sometimes, it is a good idea to willingly take on those debts. After reading this book, you'll have all the knowledge you need to create applications using the hexagonal architecture style of web development. This book is for you if you care about the architecture of the software you are building. To get the most out of this book, you must have some experience with web development. The code examples in this book are in Java. If you are not a Java programmer but can read object-oriented code in other languages, you will be fine. In the few places where Java or framework specifics are needed, they are thoroughly explained.

Genres: Programming, Software, Technology, Architecture, Technical, Nonfiction, Computer Science

156 pages, Kindle Edition

Published September 30, 2019

Reviews

[Regis Hattori · Rating 4 out of 5]

I have read just a few chapters of Uncle Bob Clean Architecture book and I thought it was too abstract.

I think this book has a good equilibrium between theory and practice although it could be more practical since it is supposed to be a "hands-on guide".

It is very short and condensed a lot of concepts in a few words so I think it worths the reading.

[Jevgenij · Rating 5 out of 5]

A very good book. Interestingly, the original Clean Architecture book is rather weak, but this one fixes all its flaws: it's short, very clear, well structured, with good explanations and examples. I guess at times it advocates a bit too much overengineering, but still, lots and lots of valuable ideas here.

[dantelk · Rating 5 out of 5]

A great book on Hexagonal Architecture paradigms; easy to understand, clear, good examples. Recommended to other engineers who use OOP in their daily lives.

[تركي · Rating 5 out of 5]

الكتاب جد ممتاز وغطى نواحي يلامسها المبرمج. وأسلوب الكاتب شيّق، وفيه سمت التواضع وخفة الرّوح.
الكتاب يأخذك شيئا فشيئا عن امتيازات Hexagonal Architecture عن الطريقة التقليدية Layered Architecture من غير أن يبخس حقها في كونها مناسبة لمشاريع معينة أو صغيرة. هو وضح عيوب الأخير، وبيّن كيف الأول تفوّق عليه

وبعدها أخذك لنواحي تطوير عدة، منها كتابة الاختبارات، وسؤالات عامة يطرحها المبرمج المهتم بكتابة كود "نظيف".

[Vahid Yaghini · Rating 4 out of 5]

It's a well written book. It's obvious that Tom has done his best to bring the abstract concepts of clean architecture to the ground and show how they will look like when actually implemented and how practically useful they can be. And that's exactly where my problem begins. My issue actually is not so much with the book itself but rather with the over hyped concept of hexagonal architecture. In fact reading a book like this made it clear for me that giving up familiarity and simplicity of organising the code in layered architecture in favour of verbose ports and adapters alternatives is not really worth it. The retracted one star is because, in my opinion, this point has been overlooked meaning the "problems" with layered architecture and the solutions that clean architecture provides are overstated. Ironically this point wouldn't be so obvious if the book was written in a vague and abstract fashion like the other books out there.

[Yaroslav Brahinets · Rating 5 out of 5]

Have you ever wondered how to read legacy code less, avoid changing the code you wrote in the past, write new code quickly, and architect it differently than ordinary layered or onion architectures?

Book fills the void and provides a clear glance at the hexagonal architecture, well known for the ports and adapters concept. The author describes how to externalise the implementation details to the edges of the architecture and make it possible to evolve your programs in parallel with multiple programmers.

Chapters are structured well, written understandably and accompanied by a GitHub repository with a simple but remarkable example of a payments app where business logic dependencies can be easily substituted and managed by bigger teams than usual. In the end, welcome to the author's blog available on reflectoring.io

[Ahmed Abouzied]

The author has an excellent git repository hosted on Github that has the source code of the project through which this book tries to illustrate the idea behind hexagonal architecture. I found that going in detail through this Github repository has helped me to understand how to implement a Spring boot application through hexagonal architecture.

The book however was not that good. The code samples are not well organized and rather confusing. And the arguments about architecture decisions were good but not very deep. They felt like good blogs or articles but not as deep as I expect a book on architecture would go.

[Marius Sørensen · Rating 5 out of 5]

9/10

Best software development book I have read

[Gualtiero Testa · Rating 5 out of 5]

As developers, we organize our application code in classes and packages/modules.
There are several ways to compose the code. A popular approach is the "three-tiered" architecture where the logic is divided in presentation, business and data layers.
See link #1.
Alternative architectures are the "hexagonal" or "port-adapters" (see link #2) and R. Martin's Clean Architecture (link #3).
There are books which explain the architectures benefits and downsides. Among them, I suggest R. Martin's "Clean Architecture" book.
On the other hand, Tom Hombergs' book complements these theoretical books showing how to implement the architectures using significant examples in Java.
The author explains:
- how to organize code in packages
- how to interface the logic between different application layers
- how to pass and map data object through layers
All examples are clear and well documented.
I've personally found quite useful the explanation of the possible data mapping strategies.
I highly suggest Tom Hombergs' "Get your hands dirty on clean architecture" book.

Links:
https://en.wikipedia.org/wiki/Multiti...
https://en.wikipedia.org/wiki/Hexagon...
https://blog.cleancoder.com/uncle-bob...

[Ionut Penciuc · Rating 2 out of 5]

Much too shallow for an architecture book.
The only thing I liked was that it provided a nice practical overview for the Hexagonal Architecture approach (the overall design, the separation of concerns, the usage of dedicated models, etc.). But this could’ve also been a blog post.
The other aspects are presented very lightly and in a subjective manner.
I also found some of the “advice” as not being very practical (e.g. the usage of long constructors instead of input builders, the great focus on the whole Spring framework usage, the writing of the tests with a “dynamic” expected value instead of an explicit one, etc.).

[Vasya Rudas · Rating 5 out of 5]

From my perspective this is a most valuable book in my career as a Software Engineer and a Tech Lead. The practical recommendations of how to implement a Clean Architecture by Robert Martin in a Hexagonal aka Ports and Adapters approach is worth reading. Also author provide compromises and benefits how each approach can help to keep architecture clean or otherwise provide redundant complexity during development. So developer must make a right decision of which approach they should use in a concrete situation.

[Antony · Rating 4 out of 5]

Really enjoyed this. There are so many books on the theory of software architecture and so few on the practice. This was nice and detailed, practical and (other books on software architecture take note) with code examples! This book covers hexagonal architecture, which isn't hexagonal at all as it turns out, aka Uncle Bob's clean architecture, in some depth.

[Laust · Rating 5 out of 5]

A quick read, with good focused examples and lots of pros and cons described. A very useful info-dump if you are having trouble keeping a layered architecture clean.

[Unpollito · Rating 5 out of 5]

This book is an introductory text on hexagonal architecture. I found it to be a very enjoyable read and one that really resonated with me as it directly addresses many of my pain points dealing with an existing codebase, such as the difficulty to test items in isolation, or to figure out the different code paths in it.

The author does an excellent job at keeping it concise and juicy, conveying the right amount of information so that every bit of the book is interesting and useful, without becoming overwhelming. It also contains enough UML and code samples to illustrate the points being made and help everything click together - a welcome contrast to other books, such as Uncle Bob's "Clean Architecture", which feel really abstract and disconnected in comparison.

The only caveat that I would point out is that this book is not meant to be a bible on the topic of hexagonal architecture - as I mentioned above, it's an introductory text. Therefore, if you are knowledgeable in the topic and want to dive into deeper nuances, it may be too shallow for you. However, for me, as a newcomer to this architectural style, it was absolutely on point.

[Adam · Rating 4 out of 5]

Reasonable takes. A good resource to structure your thoughts around when building software.

And even when I felt that i disagreed about something it was ok to let it pass. Must have been minor stuff.

It was good that it had chapters such as chapter 8 Mapping boundaries. Important piece of the puzzle, a shame it held no real new useful stuff to take to heart.

I didn't read the code sections in depth, I don't know how much that would have given me, quite little I guess.

It was also quite funnily opinionated about builders==bad, constructors==good, out of nowhere.

One thing that has stood out recently for me is package structure, how I personally use it less than others. Watching colleagues navigate by browsing packages in the code. Or the book having chapters on it and how to keep it structured a certain way. I could maybe gain something there, I've been pretty content with find usages, and searches and such. I do think I use it less if it is a legacy code base rather than a new one i've helped birth though.

[Roman Mkrtchian · Rating 5 out of 5]

This book explains the main challenges and trade offs of hexagonal architecture in only 100 pages, which is really nice and useful for many people I think.

It's good material to learn that architecture with your team if you're used to layered architectures only. My advice is to read it collectively little by little, practicing what is described inside in mob programming.

There is some Java related content, but really not that much.

The chapter about tests is maybe the one a bit controversial, as it presents 5 test sets, with 2 of them being communication-based tests, testing that the next layer's functions have been called with the correct arguments.
If I refer to the definition given in Vladimir Khorikov's Unit Testing book, the author's vision is close to the London school of testing.

[Alexandre Gomes · Rating 5 out of 5]

Fantastic short book on how to design and enforce the architecture of a java enterprise application, leveraging its package structure. A lot of times nothing more than a vague and intangible concept, impossible to materialize, the author shows how a well thought through structure for the application package hierarchy is not only able to make a big part of the architecture visible but also to actually enforce it in a build pipeline using a tool like ArchUnit to assert dependencies between application packages.

The author refers both a DDD rich domain model as well as a use case driven anemic model business logic organization approaches and despite focusing a lot on the hexagonal architecture I found the ideas easily applicable to architectures like devon4j and alike.

Best book by far on architecture as code that I've seen so far.

[Sergey Machulskis · Rating 5 out of 5]

Much better than Martin's book because it's actually usable. The book should be the basis of the "Software architecture 101" course.

There's a lot of bullshit on the interplay between DI frameworks like Spring and application architecture. Most of the bullshit lives in legacy proprietary code, but some part of it goes to the Internet in form of incompetent posts (see top answers on Spring on stackowerflow.com, or popular blogs on it). It's sad to see such incompetence, but this book is a diamond in the rough. It's very straight and explains how to use the tool properly.

The most enjoyable chapter for me was a chapter about mapping between layers.

[Florian · Rating 5 out of 5]

Using layers, often with packages reflecting those layers (controllers, daos, services) is the default for many projects.

This short but well written book will show you with very concrete examples how to structure your application differently, using hexagonal architecture, putting your domain logic in the centre.

Hexagonal architecture might not be the right fit for every team and project but even if you can't or don't want to use it this book will have valuable suggestions on how to model or structure applications.

[Slavko Recek · Rating 5 out of 5]

A perfect technical book in every aspect. Tom is able to explain a complicated topic like hexagonal architecture in terms that any experienced developer can understand. He provides a clear opinionated approach how to implement this arhitectual style in a spring application. The most important part of each chapter are his arguments how a decision makes your software better.
I recommend it to every developer and arhitect that cares about beautiful and maintainable software.

[Vladimir Ananiev · Rating 5 out of 5]

Great introduction to Clean (Hexagonal) Architecture. Short enough to read in a single sitting, with enough detail and examples to get me thinking and wanting to learn more.
Especially liked he chapters about mappings between boundaries and taking shortcuts consciously.

[Khaled Al-Ansari · Rating 4 out of 5]

One of the simplest and easiest books yet full of information, I like how the author approached the idea of hexagonal architecture from code first till the deployment part! the book is really insightful and good for almost all levels SWE.

[Johnny · Rating 4 out of 5]

Tom does a much better job explaining Clean Architecture than Robert C Martin did in Clean Architecture.

[Paucls · Rating 5 out of 5]

Excellent read, great and clear introduction to Hexagonal Architecture, covering all the key concepts and more.

[Minhaz · Rating 5 out of 5]

Precise and to the point.

[André Gomes · Rating 5 out of 5]

Very nice book! Awesome...

[Ángel M · Rating 5 out of 5]

Amazing book

[Daniel Rodriguez Del Villar · Rating 5 out of 5]

Perfect. Concise. Quick to read and a great reference.

The code examples are great to land all the ideas and concepts from the Clean Architecture, Bob Martin’s book.

[Morten · Rating 4 out of 5]

A good intro to hexagonal architecture.

[André Gomes · Rating 5 out of 5]

Great book! Very insightful