Patterns of Enterprise Application Architecture et plus d'un million d'autres livres sont disponibles pour le Kindle d'Amazon. En savoir plus


ou
Identifiez-vous pour activer la commande 1-Click.
ou
en essayant gratuitement Amazon Premium pendant 30 jours. Votre inscription aura lieu lors du passage de la commande. En savoir plus.
Amazon Rachète votre article
Recevez un chèque-cadeau de EUR 19,67
Amazon Rachète cet article
Plus de choix
Vous l'avez déjà ? Vendez votre exemplaire ici
Désolé, cet article n'est pas disponible en
Image non disponible pour la
couleur :
Image non disponible

 
Commencez à lire Patterns of Enterprise Application Architecture sur votre Kindle en moins d'une minute.

Vous n'avez pas encore de Kindle ? Achetez-le ici ou téléchargez une application de lecture gratuite.

Patterns of Enterprise Application Architecture [Anglais] [Relié]

Martin Fowler
4.8 étoiles sur 5  Voir tous les commentaires (4 commentaires client)
Prix : EUR 55,97 Livraison à EUR 0,01 En savoir plus.
  Tous les prix incluent la TVA
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Il ne reste plus que 7 exemplaire(s) en stock (d'autres exemplaires sont en cours d'acheminement).
Expédié et vendu par Amazon. Emballage cadeau disponible.
Voulez-vous le faire livrer le vendredi 19 septembre ? Choisissez la livraison en 1 jour ouvré sur votre bon de commande. En savoir plus.

Formats

Prix Amazon Neuf à partir de Occasion à partir de
Format Kindle EUR 26,67  
Relié EUR 55,97  
Vendez cet article - Prix de rachat jusqu'à EUR 19,67
Vendez Patterns of Enterprise Application Architecture contre un chèque-cadeau d'une valeur pouvant aller jusqu'à EUR 19,67, que vous pourrez ensuite utiliser sur tout le site Amazon.fr. Les valeurs de rachat peuvent varier (voir les critères d'éligibilité des produits). En savoir plus sur notre programme de reprise Amazon Rachète.

Offres spéciales et liens associés


Produits fréquemment achetés ensemble

Patterns of Enterprise Application Architecture + Domain-Driven Design: Tackling Complexity in the Heart of Software
Acheter les articles sélectionnés ensemble


Descriptions du produit

Présentation de l'éditeur

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 experienced object developers have learned.

 

Patterns of Enterprise Application Architecture is written in direct response to the stiff challenges that face enterprise application developers. The author, noted object-oriented designer Martin Fowler, noticed that despite changes in technology--from Smalltalk to CORBA to Java to .NET--the same basic design ideas can be adapted and applied to solve common problems. With the help of an expert group of contributors, Martin distills over forty recurring solutions into patterns. The result is an indispensable handbook of solutions that are applicable to any enterprise application platform.

 

This book is actually two books in one. The first section is a short tutorial on developing enterprise applications, which you can read from start to finish to understand the scope of the book's lessons. The next section, the bulk of the book, is a detailed reference to the patterns themselves. Each pattern provides usage and implementation information, as well as detailed code examples in Java or C#. The entire book is also richly illustrated with UML diagrams to further explain the concepts.

Armed with this book, you will have the knowledge necessary to make important architectural decisions about building an enterprise application and the proven patterns for use when building them.

 

The topics covered include

·  Dividing an enterprise application into layers

·  The major approaches to organizing business logic

·  An in-depth treatment of mapping between objects and relational databases

·  Using Model-View-Controller to organize a Web presentation

·  Handling concurrency for data that spans multiple transactions

·  Designing distributed object interfaces

Quatrième de couverture

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 experienced object developers have learned.

Patterns of Enterprise Application Architecture is written in direct response to the stiff challenges that face enterprise application developers. The author, noted object-oriented designer Martin Fowler, noticed that despite changes in technology--from Smalltalk to CORBA to Java to .NET--the same basic design ideas can be adapted and applied to solve common problems. With the help of an expert group of contributors, Martin distills over forty recurring solutions into patterns. The result is an indispensable handbook of solutions that are applicable to any enterprise application platform.

This book is actually two books in one. The first section is a short tutorial on developing enterprise applications, which you can read from start to finish to understand the scope of the book's lessons. The next section, the bulk of the book, is a detailed reference to the patterns themselves. Each pattern provides usage and implementation information, as well as detailed code examples in Java or C#. The entire book is also richly illustrated with UML diagrams to further explain the concepts.

Armed with this book, you will have the knowledge necessary to make important architectural decisions about building an enterprise application and the proven patterns for use when building them.

The topics covered include:

  • Dividing an enterprise application into layers
  • The major approaches to organizing business logic
  • An in-depth treatment of mapping between objects and relational databases
  • Using Model-View-Controller to organize a Web presentation
  • Handling concurrency for data that spans multiple transactions
  • Designing distributed object interfaces

    0321127420B10152002

  • Détails sur le produit

    • Relié: 560 pages
    • Editeur : Addison Wesley; Édition : 1 (5 novembre 2002)
    • Langue : Anglais
    • ISBN-10: 0321127420
    • ISBN-13: 978-0321127426
    • Dimensions du produit: 23,7 x 19,2 x 3,4 cm
    • Moyenne des commentaires client : 4.8 étoiles sur 5  Voir tous les commentaires (4 commentaires client)
    • Classement des meilleures ventes d'Amazon: 25.097 en Livres anglais et étrangers (Voir les 100 premiers en Livres anglais et étrangers)
    • Table des matières complète
    •  Souhaitez-vous compléter ou améliorer les informations sur ce produit ? Ou faire modifier les images?


    En savoir plus sur l'auteur

    Découvrez des livres, informez-vous sur les écrivains, lisez des blogs d'auteurs et bien plus encore.

    Dans ce livre (En savoir plus)
    Parcourir les pages échantillon
    Couverture | Copyright | Table des matières | Extrait | Index
    Rechercher dans ce livre:

    Quels sont les autres articles que les clients achètent après avoir regardé cet article?


    Commentaires en ligne 

    3 étoiles
    0
    2 étoiles
    0
    1 étoiles
    0
    4.8 étoiles sur 5
    4.8 étoiles sur 5
    Commentaires client les plus utiles
    14 internautes sur 16 ont trouvé ce commentaire utile 
    5.0 étoiles sur 5 Excellent 6 mai 2003
    Par Arnaud
    Format:Relié|Achat vérifié
    Ce livre est devenu ma nouvelle bible !
    Il a l'avantage de ne pas être uniquement un recueil de Design Pattern mais de faire un point complet sur les problèmatiques d'architecture d'application (découpage en couche, mapping O/R, concurrence d'accès etc...).
    Côté Pattern il est très complet et il propose des exemples à la fois pour J2EE et .NET
    Indispensable !
    Avez-vous trouvé ce commentaire utile ?
    8 internautes sur 9 ont trouvé ce commentaire utile 
    5.0 étoiles sur 5 Un couteau suisse de l'architecture 1 octobre 2004
    Format:Relié
    Au moyen de termes et schéma simple vous trouverez dans ce livre tous les modèle d'architecture à utiliser pour réaliser vos projets.
    En utilisant ce livre vous profiterez de la riche expérience de l'auteur pour éviter tous les dangers des projets multi tiers web etc...
    Indispensable
    L'organisation du liuvre permet de trouver rapidement le pattern adéquat sans tout lire
    Avez-vous trouvé ce commentaire utile ?
    5.0 étoiles sur 5 Referentiel complet de patron d architectures 3 avril 2013
    Format:Format Kindle|Achat vérifié
    Ce recueil presente bien les differents pattern qui sont a la base de pas mal de frameworks couramment utilisés. Il permet donc de comprendre mieux comment fonctionnent ces frameworks.

    Et il donne aussi de bonnes idées pour ses propres architectures.

    Une référence.
    Avez-vous trouvé ce commentaire utile ?
    0 internautes sur 1 ont trouvé ce commentaire utile 
    4.0 étoiles sur 5 Eclairant 26 mars 2010
    Par Ludwig
    Format:Relié
    Très bon livre sur les patterns applicatifs. La granularité et le nombre de pattern fait la place belle aux diverses contraintes techniques. On peut juste regretter que les facteurs fonctionnels n'aient pas, eux, engendrer une richesse équivalente.
    Avez-vous trouvé ce commentaire utile ?
    Commentaires client les plus utiles sur Amazon.com (beta)
    Amazon.com: 4.4 étoiles sur 5  89 commentaires
    110 internautes sur 118 ont trouvé ce commentaire utile 
    4.0 étoiles sur 5 Great book, but nothing particularly new 20 février 2003
    Par The Last Person You'd Expect - Publié sur Amazon.com
    Format:Relié
    I agree wholeheartedly with an above post which pointed out that the subject material is mostly known to the average enterprise developer. I am at best an average developer and found I'd already thought of much of this stuff myself.
    One thing I would like to add is that this book was still excellent reading and skimming through the patterns sparked my creative energies. I find that when I read through it, even if I 'know' the patterns already, it helps me explore their organization and consequences.
    I was disappointed that I wasn't blown away with helpful new concepts, but quite happy with my purchase all the same. Buy this if you want a thorough guide to EAA and maybe some enjoyable afternoon reading.
    (The following was added about 2 months after the original review) After owning this book for awhile, I've found it more and more indispensible. My original review, above, mentions that few of the concepts seem new, however, now that I've read it more thoroughly and applied some of the concepts, I don't think that 'mind-blowing originality' is what I should have been looking for.
    Fowler's 'Refactoring' is another example of a great book without any stunningly original concepts. Like Refactoring, PEAA can serve as a great guide to page through when you're stuck on a project and need to review your options.
    36 internautes sur 37 ont trouvé ce commentaire utile 
    5.0 étoiles sur 5 The right path to creating enterprise applications. 4 octobre 2003
    Par Charles Ashbacher - Publié sur Amazon.com
    Format:Relié
    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 no builder of software that can be considered an enterprise application should be without. It is hard to believe that there is an enterprise application being constructed anywhere that does not involve the solving of many of the problems listed in this book.
    My only complaint is the occasional bad English that appears. For example, on page 100 there is the phrase, "The only reason I've concentrating on Java . . . " and on page 119 the phrase "One factor that comes into this is comfortable used the development team is . . . " appears. While no book is error free, this type of error is frequent enough to make one wonder about the quality of the final editing.
    There is nothing harder than making effective and efficient software that will run the IT equivalent of forever. That is what enterprise applications are supposed to do and if you are one of the minions tasked with doing your part to build one, then put yourself on the right path and read this book. You and everyone else who interacts with the software will be rewarded with a better experience.
    Published in the online "Journal of Object Technology", reprinted with permission.
    40 internautes sur 43 ont trouvé ce commentaire utile 
    5.0 étoiles sur 5 Best J2EE / .Net Design Pattern Book 14 décembre 2002
    Par Stephen Molitor - Publié sur Amazon.com
    Format:Relié
    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.
    31 internautes sur 34 ont trouvé ce commentaire utile 
    3.0 étoiles sur 5 Required reading, but definite J2EE bias 23 juin 2003
    Par Larry Musa - Publié sur Amazon.com
    Format:Relié
    I am a fan of Fowler's and especially his "Refactoring" book, which I also rate as a must read for the serious programmer.
    Fowler's new book is an attempt to do for Enterprise Application Architecture what "Design Patterns" (i.e., GOF) did for OOP.
    Unfortunately,while it is an excellent book, there are issues...
    1)First, Design Patterns is a very dense and scholarly read. It is also, frankly, a difficult read. However, after you have spent a couple of days trying to digest a pattern from Design Patterns, you realize, in many cases, you have had an experience with something profound. Even the GOF authors, in the preface, attempt to console readers by admitting "We didn't understand it all on the first writing!". Fowler's book, by contrast, is not on the same level, and can be understood on a first read. Perhaps this is what other reviewers were sensing when they indicated it was for the novice architect?
    2) Fowler does NOT address security. How then,does the word "Enterprise" get the priviledge of adorning the title of his book? Enterprise design should be secure design. But, this will usually require a trade off --- more secure, less performance...or less secure, more scaleable...Fowler does not consider this. Example: A chapter is devoted to the "Table Data GateWay" pattern. The gateway pattern might be OK for J2EE...but it is not the most secure, or the best for performance,in .Net... The problem is it constructs its SQL statements in line, rather than using stored procedures. This allows SQL insertion attacks if your coders are sloppy, and also does not take advantage of the precompiled nature of sprocs.
    3)There is a J2EE bias. This probably is a good thing as the J2EE architectures tend to be more mature and contain good ideas...but you should be aware of it if you are a .NET programmer. Not all of the patterns will be immediately useful to .NET, but will require a careful implementation.
    4)Fowler passes on some of the tough questions. On page 93, while discussing RPC calls versus XML based messaging, he says "my preference is for a message - based approach that's inherently asynchronous." I agree. (RPC style is not the really suited for async, whereas document style messaging is) He then says it is too large of a topic, so does not cover it. Well, if it is the best way, it needs to be covered in an Enterprise level book, no?
    While I may seem to be critical of Fowler's book, I really think it is excellent with fine ideas. But, especially if you are from .Net, implement the patterns with care, and then only you have checked against Microsoft best practices. This is not to say Microsoft is always right, but get the second opinion anyway.
    44 internautes sur 51 ont trouvé ce commentaire utile 
    3.0 étoiles sur 5 Good, but not great 29 juin 2003
    Par Steve Loughran - Publié sur Amazon.com
    Format:Relié
    This book has been getting a lot of hype -the followup to Fowler's seminal Refactoring, enterprise edition of the GoF, etc etc.
    It's a dense and informative read. If you didnt know anything about cricket, you will by the end, as all its examples are basd on the game. I, sadly, find cricket deadly dull as a consequence of having it force fed at me in the UK educational system. This may bias me against the examples somewhat.
    As to the content, well, it is a set of patterns focused on 'enterprise' applications. In this context, enterprise means server-side code connected to a database, usually with a Web Front end. Martin goes into superb depth on how to map from databases to java and .net objects, making you think about whether or not the stuff that your framework of choice gives you is the right tool for the job. Sadly, all that does is make you more aware of the failings of EJB, JDBC, whatever .NET has. Because, unless you are going to roll your own database bridge by hand, you are going to have to run with what they give you -whether it [stinks] or not.
    I dont do much O/R mapping. I hand it off to tools like Castor and worry about my real problems: shipping web services to implausible deadlines to be managed by an operations team that phone me whenever something goes wrong. So my problems are web service related 'good API design', and 'executional patterns': how to design code that is easily tested, what is a good strategy for implementing configuration information, what is a good XML format for future flexibility. I also have to worry about the client side: how to architect a client that works well over long haul and intermittent links, and how to present this to the user.
    Martin's book doesnt cover these kind of problems. I do like his critique of Entity EJBs (as opposed to session beans), where he observes that because EJBs are all distributable, people tend to do just that, leading to performance problems that are very profitable to him as a consultant.
    The implicit message is that these days, he is spending his time tuning object to DB linkages, and not worrying about all the other aspects of the problem. Another reviewer mentioned security, but my concern is about designing for high availablity, a series of practises that focus on redundancy, caching, and interdependencies and self-diagnosis of faults, rather than caring about minutae of O/R binding.
    So I'm giving the book 3-stars, as it doesn't suit my problems. Maybe it suits other people better.
    -steve
    Ces commentaires ont-ils été utiles ?   Dites-le-nous
    Rechercher des commentaires
    Rechercher uniquement parmi les commentaires portant sur ce produit

    Discussions entre clients

    Le forum concernant ce produit
    Discussion Réponses Message le plus récent
    Pas de discussions pour l'instant

    Posez des questions, partagez votre opinion, gagnez en compréhension
    Démarrer une nouvelle discussion
    Thème:
    Première publication:
    Aller s'identifier
     

    Rechercher parmi les discussions des clients
    Rechercher dans toutes les discussions Amazon
       


    Rechercher des articles similaires par rubrique


    Commentaires

    Souhaitez-vous compléter ou améliorer les informations sur ce produit ? Ou faire modifier les images?