Customer Reviews

Java Web Services: Up and Running: Up and Running

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

 

 

The reviewers of this book who rave about the details in this book certainly did not try to execute any of the example code. If they had, they would know that these are errors all the way through the book in the code examples.

The errors are not trival if you are trying to learn by focusing on what exactly the code is doing. In one example in the first chapter, there is a whole class left out of the source code, nor does the book mention it in the text.

Go to the errata section on the publishers website, the list of errors is long. The error I mention above is not in the errata either.

How does a book like this get out to the store shelves without proper editing?

If this is the best the author can do, please don't screw over the readers that are making their best efforts to get it right. If you would rather write a conceptual book, that's fine, just leave the details out.

The author appears to be a C/C++ veteran instead of a Java guru. Method names such as read_teams_from_file and variable names such as team_map are everywhere.

The author also appears to ignore other common industry practice or industry norm. E.g. in the RestfulTeams service (page 137), information about the new team to create is contained in the HTTP header rather than in the body of the HTTP request to demonstrate "the flexibility of REST-style services".

While it is interesting to show it is possible to develop a Dispatch client against a SOAP based service with HTTP_BINDING (page 158), the author does not even mention the better, easier and more concise alternative, i.e., to use the default SOAP_BINDING for the Dispatch client.

Section 5.3.2 HTTP BASIC Authentication (page 212) is another example of abusing a well defined and well understood IT industry terminology, while the true HTTP BASIC Authentication (on Tomcat) is covered under another section (page 219, Container-Managed Authentication and Authorization) without explicitly lableing it as such.

Overall, the first 120 pages is a good introduction to JAX-WS 2.1. The rest of the book appears to be filler from various lecture notes.

I bought this book primarily to read about writing RESTful Web Services with JAX-RS which is one of the two topics mentioned in the product description.

I must say I am really disappointed with the coverage of this topic. Not many pages are devoted to it, and there are also some flaws in the presentation of REST and in the examples. For example when describing HTTP GET, the author equals "side-effect-free" with "idempotent", which is wrong. The Representations (the XML-formats) are strange, for GET they are serialized Java-objects without any semantics, for POST they are XMLs with the verb <create_team> as the root-tag.

The presentation of JAX-RS (Jersey) is only 4 pages, and far from what I need to do something useful.

As for the rest of the book I don't know, so the rating is based on the presentation of REST and JAX-RS.

I bought this book together with the "Java SOA Cookbook" by Eben Hewitt, and I also have read "RESTful Web Services" by Leonard Richardson. The chapter on REST and JAX-RS in the "Java SOA Cookbook" if faaar better, and "RESTful Web Services" is a good general introduction to REST.

This is a good book, although some examples don't work actually. The most appeal thing is this book is that examples include some codes from other Java APIs like XML for instance, and how to use them in WebServices development. About the main topic I would say this book was perfect for my needs. I'm new in Webservices and I could make a tour using SOAP and RESTful webservices, and it was very interesting for me.
I just want to warn some readers, specifically those who don't have prior knowledge in advanced concepts like dependency injection and servlets, that this book requires this knowledge.

Disclaimer: I have very little appreciation for web services technology so my ideas on this book might suffer from that. My general opinion on the existence and success of web services technology is , to quote Dijkstra: "Simplicity is a great virtue but it requires hard work to achieve it and education to appreciate it. And to make matters worse: complexity sells better".
Anyhow, back to the review. This book has actually many fine points: it's code driven, to the point, informal and packed with interesting info...so why do I give it only 3 stars? Well.. because it s' too informal and packed with info. This book reminds me of an old professor of mine who was really a brilliant experimental physics researcher but a lousy teacher.. he would start explaining something, than his mind would jump to something barely related to that, and then, hey wait there is also this other thing I need to tell you about.. You get the point. This book has similar flaws, it touches many subjects but fails to dedicate enough space and coherence to give you a solid foundation on which to build on with your experience.
Web Services technology is too complicated (read an over-engineered mess) to be covered in sufficent solid detail in a 300 pages book. The author should have doubled the size of the book or halved the span of its contents. I hope he will choose the first option in a second edition. Till then, it remains more of a book written for its author then for its readers...

As an alumnus of the university at which the well-known Richard Johnsonbaugh / Martin Kalin duo teach as professors, this reviewer is aware of the fact that these gentlemen typically receive positive feedback by their students (they teach at the undergraduate level and so this reviewer cannot attest to this feedback). However, teaching is different than writing, and this reviewer has generally not had positive experiences with their writings (see for example the first review by this reviewer, on "Schaum's Outline of Discrete Mathematics", in which this reviewer recommended that book as an alternative to Richard Johnsonbaugh's "Discrete Mathematics: Fourth Edition"). The book at hand, "Java Web Services: Up and Running", is a break from this stereotype because it is a great introduction to Java web services from various angles. While Kalin provides enough theory to propel the reader into good understanding of the programming material, this book is essentially a programming text, and because the bulk of the content consists of working programming examples, the risk that the complaints often heard by readers about lack of practical code might arise should be alleviated. Another strength of this book is the use of many of the latest implementations of Java libraries in this space, although with any technical text of this genre the field is moving quickly and so it is at risk of becoming obsolete from an implementation perspective in the near future (although just partially, because many libraries are backward-compatible, at least to some extent). For example, the cover of this text states that it includes material on JAX-WS 2.1, but the reference implementation of the technology, Glassfish Metro, is already planning a May 2009 release of JAX-WS 2.2, just a few months after book publication. Another strength of this book is its coverage of web services security in easy to understand language, including transport level security, message level security, and the WS-Security specification, with working examples throughout the chapters dedicated to these topics. While XML configuration files do come into play to some respect within the discussions, the focus is on programmatic use of associated libraries. This provides the benefit to those new to these technologies of understanding what is happening under the covers that are offered by technologies now being offered by various IDEs. While Kalin does mention that there are tradeoffs to be made in using these libraries programmatically, however, it is very curious that the Spring Framework is not mentioned (see my review for "Spring in Action" by Craig Walls, for example). Kalin discusses the fact that message level security is more tedious than transport level security, and seems to prefer HTTPS to avoid this additional complexity, but since only programmatic, reference implementations are discussed the benefits of using Spring are completely missed. And as someone experienced with Apache Axis, Apache Axis2, Apache CXF, and Glassfish Metro, the beneficial abstraction that Spring provides is something this reviewer thinks that those new to Java web services should not ignore after they understand the material presented in this text. But for what this text claims to be, a "thorough introduction to Java's APIs for both XML Web Services (JAX-WS) and RESTful Web Services (JAX-RS)" that "takes a clear pragmatic approach to these technologies by providing a mix of architectural overview, complete working code examples, and short yet precise instructions for compiling, deploying, and executing an application", this book hits the bull's-eye.

A very practical and useful, yet comparatively short book that covers what you really need to know and focuses on making JAX-WS and JAX-RS (REST) work. The author does an excellent job on this subject. O'reilly publishing has been slow to release new Web Services titles so this was great to see. Detailed explanations of RPC and DOC LITERAL styles, the differences that result in generated WSDL between the two, JAXB, and how to work with Handlers to access or manipulate SOAP Header data are CLEARLY explained in the first 3 chapters alone. What makes the book so good is that the author focuses in on the HOW and WHY getting right to the code and explaining clearly what is being done. My only suggestion thus far would be to add a section covering the use Ant for JAX-WS tasks used in building and packaging the applications. Other than that, the book is outstanding.

I've found this to be a very easy to read introductory book on Web services, precisely because it begins at the beginning and even answers the question "What are web services and what is their appeal?" Web services support language transparency because the service and its clients need not be written in the same language. It is this language transparency that is the key to web service interoperability, and is the basis of the appeal of web services as they are now defined. To underscore this appeal, clients against Java web services are written in various languages such as CSharp, Perl, and Ruby, and Java clients are demonstrated that consume services written in other languages, including languages unknown. For example, The very first example in the book is a SOAP-based web service written in Java that has clients in Perl, Ruby, and Java.

Chapter two studies SOAP and the WSDL (Web Service Definition Language) closely, and illustrates how the WSDL can generate Java classes on the client side. Also of use in writing Java clients is the wsimport utility and the JAX-B (Java API for XML-Binding), both of which are covered here.

The book goes into the details of coding web services with both SOAP and REST, providing a chapter on each of these. There is a separate chapter that deals with the ongoing REST versus SOAP debate. The jist of it is that writing web services with the SOAP protocol is too complex and SOAP services can appear over-structured, while REST is based on the HTTP protocol, which makes interoperability both simple and easy. However, people must not be completely satisfied with what HTTP brings to the table since the SOAP protocol continues to thrive. I like how the author kept the technical implementation chapters separate from the debate chapter, thus adding to the clarity of both subjects.

Since Web services require security in this day and age, that topic is discussed next. The technologies available for securing web services are explored. The emphasis is on the subjects of wire-level security, user authentication and authorization, and WS-Security (WSS), which is a collection of protocols that specify encryption and decryption of information. This is a topic that is often brushed over or kept theoretical in coding-centric books such as these, but the author gets practical here and does not just stay at a high level when discussing the subject.

The book next departs from the Endpoint publisher and the Tomcat web container which has been the deployment mechanism shown so far and discusses how web services can be deployed using a Java Application Server (JAS). Glassfish is discussed at length.

The final chapter is the one I mentioned earlier on the SOAP-based versus REST-style web services debate. This chapter is written essay-style and largely avoids coding details. It gives a short history of distributed computing to present a clearer view of the choices involved in developing web services.

This book is very comprehensive incorporating a great deal of code, definitions, explanations, and well-done diagrams. This is a fast-moving field in which books become out-of-date quickly, and it is good to have a very recent, readable, and comprehensive text for newcomers. The only prerequisites that I can see are to have an understanding of programming in the Java language, XML, and the basics of data communication across a network.

Don't be misguided from the fact that this is a short book, it is short because contains only the necessary to get you started with webservices, no bloated writing. It's very easy to read, good real world examples again respectable providers, reviews many frameworks for REST, straight forward explanation of WSDL and SOAP handling, deploying web services for dev but also for tomcat and glassfish, and the examples client in Perl and Ruby are welcome as well(personally I would like to see more ruby). This book is very practical, if you don't have time or the will to spend your time reading a 900 pages book just to learn how to create a simple webservice, then buy this book you won't regret it. The only minor flaw I found is that most of the examples aren't written with the Java convention for naming, but it's an small improvement they could make for a next edition.

Are you a programmer who is interested in developing Java web services and Java clients against web services, whatever the implementation language? If you are, then this book is for you. Author Martin Kalin has done an outstanding job of writing a book that is a code-driven introduction to JAX-WS, the framework of Choice for Java web services, whether SOAP-based or REST-style.

Kalin, begins by focusing on the basics of writing, deploying, and consuming SOAP-based services in core Java. Next, the author focuses on the service contract, which is a WSDL document in SOAP-based services. Then, he introduces you to SOAP and logical handlers, which give the service-side and client-side programmer direct access to either the entire SOAP message or just its payload. The author continues by opening up with a technical analysis of what constitutes a REST-style service and moves quickly to code examples. Next, he gives you an overview of security requirements for real-world web services, SOAP-based and REST-style. Then, the author presents a survey of what comes with a Java Application Server: an EJB container, a messaging system, a naming service, an integrated database system, and so on. Finally, the author looks at the controversy surrounding SOAP-based and REST-style web services.

This most excellent book interprets JAX-WS broadly. More importantly, it includes leading-edge developments such as the Jersey project for REST-style web services, officially known as JAX-RS.