When I first saw this book I thought it looked nice and noted that it was associated with Martin Fowler, but figured that I had plenty of patterns books and didn't need yet another patterns book. I couldn't have been more mistaken. Recently I was reading the early access edition of Spring Integration in Practice from Manning Press and noticed that they kept referring to the Enterprise Integration Patterns book. It turns out that the book breaks new ground to cover messaging patterns in a way that I've not seen in any previous book. "Messaging patterns" are not simply messaging in the sense of Java Message Service (JMS) (although they may include that). They are patterns that have to do with work flow through an application where the message carries the payload that needs to be worked on, often in multiple steps. The book has plenty of diagrams to explain these patterns and the web site has links to free stencils that can be downloaded for Visio and other applications. While the web site has quite a bit of free content, there's considerably more meat in the book, so don't think that you've seen it all if you've been reading through patterns on the web site.

In short, Enterprise Integration Patterns is an essential book for those working in the enterprise spaces that want to learn from other developers that have come before them and captured a bit of what they've learned. It will certainly help simplify complex designs and contribute to avoiding a host of possible missteps. Definitely worth your money.

Deserves to take place in the great line up of GoF, POSA1, POSA2, EAA, Core Security Patterns (other "patterns" books omitted intentionally).

I have done Messaging and message based integration before, but this book takes essentially what is an art form and makes a science out of it.

First it starts with 4 different styles of integration (File based, Shared Database, RPC, Messaging) and discusses them intelligently giving their advantages and disadvantages.

Then it gets in to the major aspects/ pieces of Message based integration (Message, Channel, Routing, Transformation, End Points, System Management etc). It again discusses them as patterns and develops a good vocabulary of the messaging domain.

Then comes the meat where for each aspect of Messaging, it gives about 8 to 15 specific patterns, names them, shows their pros and cons, gives the trade off and intelligently discusses their usage. As part of the examples it draws example from JMS/ TIBCO/ MSMQ etc. Priceless.

What I loved about this book is how it makes you rethink everything you may have been doing before in software architecture/ integration using technologies such as Web Services, JMS, J2EE etc.

For example, many would not have fully groked MDBs as "event driven", "competing", "transactional" message consumers, that are suited for "Point to Point" integration. Yes I know every body uses them but do you really understand the implications for transaction scope and threading? . Or Polling message consumers have their advantages ?

Good discussion on relate standards and technologies included (Web Services, Axis Implementation, WS-*, SOAP etc)

Buy this guys and may be enterprise integration would be less messy.

Enterprise Integration Patterns are increasingly central to what I am doing on integration projects nowadays and how I am using them. It always depends on the context and technologies with which we are using the patterns. There have been many libraries and frameworks over the years to help with integration. But frequently the concepts behind the Enterprise Integration Patterns get transformed into some complex class hierarchies or objects that need to be wired together just so, and the original intentions and patterns are often lost. As a Java developer I am often forced from then on to focus on the low-level detail and some complex class library API, losing the bigger picture and patterns.

Many frameworks, like e.g. Apache Camel and enterprise service buses, like Fuse ESB, support the usage of enterprise integration patterns and watching the codebase, community, and number of components, technologies, and data formats grow massively as more and more developers have found frameworks like Apache Camel an ideal way to design, implement, and maintain the enterprise integration patterns, this awesome book has become the bible of enterprise integration patterns on which many of the concepts of Apache Camel are based. That's why... it should not be missed in any serious developer's technical library.

This is an excellent book on the patterns and concepts in enterprise integration. I've been doing enterprise integration since this book was written with a middleware product (webMethods) and J2EE and finally got around to reading this book. I found the book to be very well written and easy to read: the authors walk you through different thought processes for solving a particular problem and why the pattern is the best solution. Even though the book is 15 years old as of my review it is still pertinent today.

The patterns explain the different problems one typically needs to solve to do asynchronous messaging integration with legacy and modern applications.

Many of the patterns are included in commercial middleware products like webMethods, Tibco, Mulesoft, etc. Others you will need to build yourself to solve specialized problems.

The book examples are JMS and MSMQ centric, with a few Tibco examples too. The code examples are geared toward building solutions with those simple technologies rather than showing all of the middleware vendor tools. Therefore, I wouldn't read this book to learn how to code things. Read it to understand how asynchronous messaging problems should be solved, and to evaluation SOA and middleware products for features that implement these patterns.

In the last few years SOA and microservices have been the buzzwords in enterprise integration, but there are still many patterns from this book you may use because there are still many legacy apps in use that can't be modified to directly support web services, and many tasks still need to be asynchronous and decoupled.

I've been a s/w architect for years so ... I've encountered most of these integration patterns. As I went through patterns that I haven't used, I kept the same question in my head: how is this better than if I just did it without a pattern (this is the same question I keep applying to frameworks and tools such as ESBs and business process orchestration languages like BPEL). With this, I found the authors thought along the same lines and were able to provide those answers without my having to think about the issue of not using the pattern. You have to know what the alternatives are that the pattern is trying to resolve and just why the alternatives are a problem -- and this book delivers on that. Note: I found it was helpful to keep in mind that these are application integration patterns: patterns for integrating applications as opposed to patterns for building an enterprise application.

This is the third pattern book in my collection (the other two are Analysis Patterns by Martin Fowler and the definitive Design Patterns by the Gang of Four) and IMHO this is the best example yet of where patterns can really improve the development process. This is the first book I've seen to address the area of enterprise development where the real heavy lifting takes place. Applications don't miraculously integrate with one another; it takes talented, knowledgeable IT personnel to wire everything together. If you're one of those people, Enterprise Integration Patterns is an important addition to your toolkit.

Chapter 2 takes the reader through the integration efforts of a fictional enterprise to demonstrate some of the patterns in action. The descriptions of the problems and their possible solutions... just make sense. You can really see the benefit that these patterns provide to simplifying, organizing and clarifying the situation.

I cannot recommend this book enough for software architects designing applications that interact in any way with another outside system. With today's movement towards cloud computing and always-online environments, that's practically everything. Going further, when you consider that an application can coordinate its own interaction with internal subsystems using Enterprise Integration Patterns, this design philosophy truly applies everywhere. Enterprise Integration Patterns take to the next level the same separation-of-concerns principles that Object-Oriented Design introduced, teaching us encapsulation of entire systems regardless of architecture.

This won't be the most in-depth review, but I'd encourage you to visit these two sites for a deeper exploration of the topic:

[...][...]

-- Apache's extensive Java reference implementation, including a nice Wiki with example use cases and creative recipes.

It's 2023, and this book is STILL relevant. Entire categories of tooling have probably sprung up, been fashionable and then fallen by the wayside and this book just keeps chugging along. That's because this book isn't about any particular technology, it's about explaining patterns that you can reach for again and again as you face certain situations over your architecture/designer/developer career.

Great timeless book. Good for the software engineer.

Tenia tiempo queriendo comprar este libro y no me arrepiento. La calidad del libro y el contenido son excelentes

20 years old and more relevant today than when it was written. Also comes in an excellent hardcover format which I wish were the standard for books in this price range *stares at oreiley*.

The only downside I can think of is that the book sort of conflates different kinds of messaging with each other (i.e. what it calls command messages, document messages, and events), when they are really quite different and should be split between truly asynchronous ones and real time ones. However, the fact that each pattern is self contained makes it less of an issue since you can just focus on the patterns relevant for your current context.

Still in 2016 this book is relevant. It is a proof of its quality. When you think today about integrating solutions, of all the good technics that can come to your mind, a lot of them can be found in this this one (rpc, ftp, messaging solutions)

various frameworks (like spring integration or camel eip) are implementations of patterns written in this book.

With classic object oriented and domain driven patterns, the EI patterns belong to my list of must have for writing large scale solutions.

Indispensável, um clássico.