Patterns of Enterprise Application Architecture

by Martin Fowler

Book Overview

The practice of enterprise application development has benefited from the emergence of many new enabling technologies. Multi-tiered object-oriented platforms, such as Java and .NET, have become commonplace. These new tools and technologies are capable of building powerful applications, but they are not easily implemented. Common failures in enterprise applications often occur because their developers do not understand the architectural lessons that...

• Format: Hardcover
• Language: English
• ISBN: 0321127420
• ISBN13: 9780321127426
• Release Date: November 2002
• Publisher: Addison-Wesley Professional
• Length: 560 Pages
• Weight: 2.45 lbs.
• Dimensions: 1.3" x 7.6" x 9.3"

Customer Reviews

Outstanding work in the field

I normally don't bother to write reviews, but some of the shallow ones I found here irritated me enough to write. I have been a developer, architect, and development manager. My latest project was a 100+ developer year enterprise application. Fowler clearly knows the field, he speaks with confidence of development experiences with projects that went live. I have no idea of what a newbie to enterprise application development would gain from this book. The DTO pattern, for example, is profoundly powerful and his representation of it is accurate, but he presents it in a casual, low-key way, and its significance might well escape the uninitiated. When you talk to programmers who only know the one thing they worked on you hear a naive, blind conviction in their voice, but when you read Fowler, you hear the weary lessons of hundreds of developers on dozens of large projects. If you are experienced, read chapter 8 first, then the patterns, then 1 - 7 if need be. If you are new, read chapter 8 first, then the patterns, then CODE the patterns a dozen times, then read the rest of the book. Fowler says you should read 1-8 then the patterns as needed, but I say the 8 pages of chapter 8 roll up the first seven chapters very nicely, and then please read all the patterns in associative order from your point of view.

The right path to creating enterprise applications.

Fowler avoids giving a precise definition of an enterprise application, preferring to list a set of characteristics that most share. In general, they are very large systems, with many user interface screens used to concurrently access and update an enormous amount of data. In nearly all cases, the data must be persistent, in fact it most often is very persistent, meaning that it has to live through iterations of the software, alterations of the operating system, changes in the hardware, and staff and programmer turnover. Furthermore, enterprise applications usually must communicate with other applications, which are often just as large and complex. Examples include payroll and patient records, credit card processing, insurance claim processing, banking, and foreign exchange trading. In short, most of the programs that run the modern global economy, which are many of the most complex software projects currently in use. Finally, the programs must be constructed so that they can be "easily and quickly" changed by people who did not create them to adapt to conditions that can change very quickly and often without any input from the programmer. With so much at stake, there must be a set of best practices, which is what is captured in this book. The patterns of software construction explained by Fowler are generally in the small, in the sense that they describe specific operations rather than demonstrate a large architectural form. Each of the specific patterns is presented by first listing a one-sentence description of the purpose of the pattern and a UML diagram illustrating the structure. This is followed by sections describing how the pattern works, when to use it and one or more examples demonstrating specific implementations of the pattern using source code skeletons. Both C# and Java are used in the demonstrations, which does not create an understandability problem. The languages and contexts are so similar that anyone who can understand either one will have no problem reading and understanding the code. Some examples of the fifty one patterns listed on the inside front cover are:Lazy load - where an object will load only the data currently needed, but does maintain links to all other data that may be needed. Front controller - a single handler object that consolidates all requests made for a web site. It can then send requests to the specific objects for services such as security, internationalization issues and specific displays targeted for particular users and locations.Optimistic offline lock - used to prevent conflicts when concurrent business transactions are executing. The solution is to roll back the transaction when a conflict is detected. Server session state - keeps the data for the session stored on a server in a serialized form. While the examples are often of necessity extremely simple, they do illustrate some of the most effective and tested solutions to common software development problems. Therefore, this is a book that n

Excellent book - a must read

This is by far the best description of enterprise patterns I have read to date.Fowler points out that none of these patterns are new (and many have been around for a long while), but never have I seen such a vast array of useful enterprise patterns so well documented.I had heard and/or seen a lot of these patterns already, but the way he describes the patterns and the trade offs involved in choosing the patterns is truly awesome.The first half of the book is a discussion of enterprise architecture in general. I particularly enjoyed the section 'Layering' and 'Organizing Domain Logic'. I could really relate to these discussions, and much of what is written relates to problems I face often in designing my applications.I now have a much better understanding of what a true OO Domain model should look like, and I feel more comfortable in designing a fully OO business model.Some of the patterns presented in relation to database mapping may not be so useful because there are a lot of OR mapping frameworks available to do this for us now. But I still find these patterns useful in understanding how to use an OR mapping framework correctly and how they work under the covers. And you may not always have access to such a framework.I found the discussions on concurrency and transactions very valuable. I also think that the presentation patterns section is quite good too, although again there are a lot of presentation frameworks/tools available for this kink of thing like struts, webwork/velocity, asp.net etc.The only thing that I think this book lacks is a discussion on how to link the layers of an application together. Maybe I will read the book again soon in case I missed something, but I don't think he talks about how to integrate a domain model with the presentation layer, and he kind of skips how to integrate a domain model to the database layer (he just says use mapping which is difficult).I am giving this book 5 stars because it will change (has changed) the way I think about designing software in much the same way that reading a book like Gang of Four.

An indispensible handbook for Architects and Developers

This book is the masterpiece. This book is full of sound advice, tips and traps. The patterns in this book they are very well identified, specified, clarified, and classified. Martin brings the patterns to life with just the right mixture of prose and code. He provides a lot of code samples. If you have really complex business logic, you will find how the patterns presented in this book are useful. This book is useful for both J2EE and NET developers. This is particularly useful when attempting to gain an understanding of how application architectures differ between .NET and J2EE. Domain logic patterns described in this book are very interesting, they help you to map domain logic to a design; Data source architectural patterns can be considered as extension of entity bean and DAO; object-relational structural patterns can help you to map object to table design; there are other interesting patterns as Unit of Work (in Object-Relational Behavioral Patterns) and Query Object (in Object-Relational Metadata Mapping Patterns). In a whole, you see all of the basic patterns of object-relational mapping in this book.This book also presents some interesting presentation patterns, besides those presented in Core J2EE patterns, you can find Application Controller, Transform View, Two Step Views patterns very useful also.There are others very useful concurrency patterns, session state patterns, distribution patterns presented in the book, and you can find some "Base Patterns", which can be considered "classical" patterns.Martin has successfully shown how to use patterns to link together all of the parts of an enterprise system.Just as Design Patterns did seven years ago, this book will become the basis of a vocabulary that we will use from now on to speak about information system's architecture. This book will be a handbook of many developers.

Best J2EE / .Net Design Pattern Book

This is the best book I've found on J2EE and .Net patterns. I think it's destined to become a classic. I found the discussions on when to distrbute ('sell your favorite grandmother first'), Unit Of Work, Domain Model and Data Mapper patterns extremely useful. It has changed the way I think about enterprise applications. I think it fits somewhere between the original 'Design Patterns' book, by Gamma, et al, and a book like 'J2EE Patterns' in terms of its scope. 'Design Patterns' describes existing patterns that are applicable to any kind of application. 'J2EE Patterns' describes patterns in terms of one platform (although many of them apply to other platforms as well.) Fowler's book describes a set of patterns that work with a certain kind of application, business apps, but that are applicable to more than one platform.It's better than the 'J2EE Patterns' book, which doesn't do a good job explaining which parts of J2EE to avoid, and which 'patterns' are in fact workarounds for problems in the platform itself. (For example, the 'Composite Entity' pattern.) I have to strongly disagree with the first reviewer. Fowler does explain which patterns work best on which platform. The first section of the book gives a good road map for deciding which set of patterns to use for your app. He mentions explicitly that .Net pulls you in the direction of Table Module, but that with J2EE you would be less likely to use that pattern. As far as the patterns being available in frameworks, I still find it useful to know about the patterns the framework implements. That way you know which framework to select. We recently went through an O/R mapping tool selection process. Reading the Unit Of Work, Data Mapper, Repository, Lazy Load and Identity Map chapters helped *immensely* in that process. Likewise reading the Front Controller pattern gave me some new ideas on how best to utilize the Struts framework. I totally disagree with the notion that "learning about the patterns that are associated with these frameworks will provide little value". Ignorance is definitely not bliss here.Finally, the idea that because the book 'just' collects and names patterns that already exist somehow decreases its value is hogwash. These are tried and true patterns that many developers have found useful. Naming and clearly describing common patterns is very helpful. This is exactly what the original 'Design Patterns' book did. By this logic, I guess the original reviewer would have given 'Design Patterns' only 3 stars. It's a great book.