Customer Reviews

Web Services Patterns: Java Edition

5 star:		(2)
4 star:		(5)
3 star:		(1)
2 star:		(2)
1 star:		(0)

 

 

I've been architecting Web Services since before they were called Web Services, so I was really hoping to come away with some new insights based on the other book reviews here. Unfortunately, this book fell short in several ways. Pros: I liked the idea of WS patterns - it's a good idea and he did an ok job, I also liked how he tied the example application to the text. Cons: the writing style was a little dry and repetitive, very few of the patterns actually applied to how clients interact with services (something most of us that implement services are interested in), all of the examples used rpc/encoded SOAP messages which is pretty much an obsolete practice, and the author seemed to have much less Web Service experience than pattern experience. For example, in the Partial Population Pattern he recommends that clients use "keys" to identify parts of the message that they want returned. A more XML-friendly approach would be to use a limited form of XPath rather than keys, thus allowing for more flexibility. The pattern also assumes that the response schema allows variations in the message to be returned, something that I don't believe he discussed.

This is the first book which shows how to build Webservices using well defined architectural patterns. This book has an excellent case study based introduction and discusses Web services architecture to begin with and tides over how to apply Java based design patterns to ease development. This books contains an excellent catalog of 20 Web services patterns and its Java implementation.

The authors managed to introduce all patterns while anchoring the presentation with a practical and interesting discussion of real world case study. This approach makes this book succeed on all levels, both in presenting essential patterns and demonstrating how these designs often work together in real Web services.

This book is a perfect companion guide for choosing patterns in real implementation. This book does not introduce and walkthrough Web services standards and Java APIs, for that we chose to use "Developing Java Web services - Wiley Press" book, very helpful.

In all, this book will be absolutely required reading for anyone who lays claim to be an Architect on today's Web services.

This book is not a typical Web Services hype book. It covers the practical issues of developing Web Services, through the age old patterns approach. Paul Monday takes the standard Gang of Four and J2EE Design Patterns and shows developers and architects how these patterns would be applied in a Web Services world.

The book is targeted at developers and architects who have alreadt have a solid understanding of Web Services and Design Patterns.

The code samples are based on Apache Axis and work great. I strongly recommend that you go through them in detail to get full value from this book.

Perhaps Monday is attempting what Martin Fowler did some ten years ago, when Fowler wrote a now classic book on refactoring. Here, Monday identifies several useful patterns in WS usage. We're talking about a collective, distributed computation here. That is (or can be) usually asynchronous. Another book ("Remoting Patterns" Wiley 0470-856629) discussed patterns for a general distributed case.

But Monday focuses on what might emerge as useful within the strictures of WS. Especially if we use Web Services Description Language or Business Process Execution Language. In terms of example code, he chooses Java to express this. But the text makes clear that the patterns are of course independent of any given coding language. (The WSDL and BPEL and other WS variants are declarative languages.)

You may find the book useful if you are new to WS. It gives a higher level view of what might be done. Whereas other WS books could be concentrating more on the WS syntax. Also, you may find out whether BPEL is sufficiently expressive for your needs. BPEL was conceived in large part because WSDL ran into limitations. But BPEL itself needs a practical workout by developers.

This book is all about illustrating architectural pattern for Java Web services development. It presents a collection of design patterns,for the Java Web services patterns for the development community. If you plan to do Java based Web services architecture development, this book makes a case for how to build a Web services architecture using patterns and serves as a guidelines manual with catalog of design patterns.

This Sun author presented this book truly unbiased on choosing the Web services implementation. The book chooses to use Apache Axis 1.0 for illustrating the architecture of Web services and applying patterns for development.

With Web services specifications still evolving, I feel this book dictates the patterns for the early adopters. In the next two years, this book may require a revision based on the upcoming SOAP 1.2 specs and a series WS-* specs.

I strongly commend this patterns book for architects and tech leads who wish to build Web services and related projects.

If you have done a lot of work with OO design, and are designing SOA based systems, this book is for you. It does a brilliant job of explaining how SOA encourages a component Architecture style, rather than a Object Oriented design methodology. Some consequences of that include, 1) passing simple data structures and expecting simple Collections from Services, such as Arrays. 2) Using composition much more, rather than inheritance. 3) Separating the Business Logic (and process) from the Business Data, so that the business process can be exposed at a higher level of abstraction, and shared across multiple Activities that can fulfill the business logic.

This book is still very relevant, and a great read for Architects, developers and Managers.

I enjoyed reading this book because it discusses middle-tier issues well. Many Chapters (ex. "SOA Pattern" and "Service Directory Pattern") are good descriptions of WS, but are not Patterns.There is not enough technical info to implement a WS. There are issues with WS not discussed in this book. Therefore it is not a good summary of WS nor of their Patterns.

Some of the fonts chosen remember me of some books I read 15 years ago. There are bad recommendations like promoting a distributed architecture in the "Physical Tiers Pattern". The chapter describe how you can communicate between two processes with RMI or CORBA.

The only two patterns that were not obvious for me were the "Faux Implementation" and "Partial Population", but few strategies are presented for implementing them.

In overall, the author seems naïve and not very experimented.

Now that we have read all the books on the basics of web services and have a good understanding of how they are supposed to work it is time to get down to actually trying to create some decent designs for our web services applications. That is where this book fits in. The book shows how to apply design patterns to a web service architecture in order to solve common design problems. If you are designing a web service architecture you will want to read this book before drawing another UML diagram.

The book starts out by looking at the design patterns used in web services itself. These are the patterns utilized by software such as Apache Axis. This part of the book was interesting but not overly useful. The next part, making up most of the book, covers design patterns that you are likely to need in developing web applications. This part of the book is excellent. Each pattern is discussed in detail and then demonstrated in a case study that is developed throughout the book. Some of the patterns covered are event monitor, observer (with a good comparison of the advantages and disadvantages of the two), business process, asynchronous business process, physical tiers, faux implementation, and service factory. The book covers twenty different patterns so if these don't sound applicable to your application there is bound to be another that will be applicable.

The book contains only snippets of code from the case study so you will need to download the code in order to get the full value of the case study. The book does include the parts of code that apply to the pattern under discussion. The reader of this book should be comfortable with web services and design patterns in general and be ready for an in-depth discussion of web services architecture.

This book is a good description of how to bridge traditional OO designs into a web services world. It takes a Java perspective and describes quite well where the differences are in a distributed component model such as WS. It describes very basic GOF patterns, how they have been adapted to J2SE and J2EE, and how these patterns need to be modified to fit into a WS environment.

If you have a Java/OO perspective and some J2EE background building web apps, this book is a very good way of understanding how you will have to modify some approaches to move to distributed, message-based systems with adapters and coarsely-grained data transfers.